diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index d38bbada3..fedc90c66 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -8,9 +8,9 @@
     "ghcr.io/devcontainers/features/git:1": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
-  "forwardPorts": [1212, 3000],
+  "forwardPorts": [1313, 3000],
   "portsAttributes": {
-    "1212": { "label": "Webpack Dev Server (Renderer)" },
+    "1313": { "label": "Webpack Dev Server (Renderer)" },
     "3000": { "label": "Electron Debug Port" }
   },
   "mounts": [
diff --git a/.github/workflows/migration-ci.yml b/.github/workflows/migration-ci.yml
index 5463468bd..a466a2dea 100644
--- a/.github/workflows/migration-ci.yml
+++ b/.github/workflows/migration-ci.yml
@@ -22,10 +22,10 @@ jobs:
           cache: 'npm'
 
       - name: Install dependencies
-        run: npm ci
+        run: npm ci --ignore-scripts
 
       - name: Validate architecture layers
-        run: npx tsx src2/__architecture__/validate.ts
+        run: npx tsx src/__architecture__/validate.ts
 
   unit-tests:
     name: Unit Tests + Coverage (src2)
@@ -41,10 +41,10 @@ jobs:
           cache: 'npm'
 
       - name: Install dependencies
-        run: npm ci
+        run: npm ci --ignore-scripts
 
-      - name: Run src2 tests with 100% coverage threshold
-        run: npx jest --config jest.config.src2.json --collectCoverage --ci
+      - name: Run tests with coverage
+        run: npx jest --config jest.config.json --collectCoverage --ci
 
       - name: Upload coverage report
         uses: actions/upload-artifact@v4
diff --git a/configs/webpack/webpack.config.main.dev.ts b/configs/webpack/webpack.config.main.dev.ts
index 00d6731c5..07d4a8188 100644
--- a/configs/webpack/webpack.config.main.dev.ts
+++ b/configs/webpack/webpack.config.main.dev.ts
@@ -1,5 +1,7 @@
 /**
- * Webpack config for development electron main process
+ * Webpack config for development electron main process (new src)
+ *
+ * Builds from src/main/. All @root imports resolve to src/.
  */
 
 import { join } from 'path'
@@ -7,16 +9,17 @@ import webpack from 'webpack'
 import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer'
 import { merge } from 'webpack-merge'
 
+import { dependencies as externals } from '../../release/app/package.json'
 import checkNodeEnv from '../../scripts/check-node-env'
-import baseConfig from './webpack.config.base'
 import webpackPaths from './webpack.paths'
 
-// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
-// at the dev webpack config is not accidentally run in a production environment
 if (process.env.NODE_ENV === 'production') {
   checkNodeEnv('development')
 }
 
+const srcPath = join(webpackPaths.rootPath, 'src')
+const srcMainPath = join(srcPath, 'main')
+
 const configuration: webpack.Configuration = {
   devtool: 'inline-source-map',
 
@@ -24,9 +27,31 @@ const configuration: webpack.Configuration = {
 
   target: 'electron-main',
 
+  externals: [...Object.keys(externals || {}), 'terser-webpack-plugin'],
+
+  stats: 'errors-only',
+
+  module: {
+    rules: [
+      {
+        test: /\.[jt]sx?$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'ts-loader',
+          options: {
+            transpileOnly: true,
+            compilerOptions: {
+              module: 'esnext',
+            },
+          },
+        },
+      },
+    ],
+  },
+
   entry: {
-    main: join(webpackPaths.srcMainPath, 'main.ts'),
-    preload: join(webpackPaths.srcMainPath, 'modules/preload/preload.ts'),
+    main: join(srcMainPath, 'main.ts'),
+    preload: join(srcMainPath, 'modules/preload/preload.ts'),
   },
 
   output: {
@@ -37,12 +62,19 @@ const configuration: webpack.Configuration = {
     },
   },
 
-
   resolve: {
-    extensions: ['.ts', '.js'],
+    extensions: ['.js', '.jsx', '.json', '.ts', '.tsx'],
+    modules: [srcPath, 'node_modules'],
+    alias: {
+      '@root/utils': join(srcPath, 'frontend', 'utils'),
+      '@root': srcPath,
+    },
   },
 
   plugins: [
+    new webpack.EnvironmentPlugin({
+      NODE_ENV: 'development',
+    }),
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     new BundleAnalyzerPlugin({
@@ -54,15 +86,10 @@ const configuration: webpack.Configuration = {
     }),
   ],
 
-  /**
-   * Disables webpack processing of __dirname and __filename.
-   * If you run the bundle in node.js it falls back to these values of node.js.
-   * https://github.com/webpack/webpack/issues/2010
-   */
   node: {
     __dirname: false,
     __filename: false,
   },
 }
 
-export default merge(baseConfig, configuration)
+export default configuration
diff --git a/configs/webpack/webpack.config.main.old.dev.ts b/configs/webpack/webpack.config.main.old.dev.ts
new file mode 100644
index 000000000..00d6731c5
--- /dev/null
+++ b/configs/webpack/webpack.config.main.old.dev.ts
@@ -0,0 +1,68 @@
+/**
+ * Webpack config for development electron main process
+ */
+
+import { join } from 'path'
+import webpack from 'webpack'
+import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer'
+import { merge } from 'webpack-merge'
+
+import checkNodeEnv from '../../scripts/check-node-env'
+import baseConfig from './webpack.config.base'
+import webpackPaths from './webpack.paths'
+
+// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
+// at the dev webpack config is not accidentally run in a production environment
+if (process.env.NODE_ENV === 'production') {
+  checkNodeEnv('development')
+}
+
+const configuration: webpack.Configuration = {
+  devtool: 'inline-source-map',
+
+  mode: 'development',
+
+  target: 'electron-main',
+
+  entry: {
+    main: join(webpackPaths.srcMainPath, 'main.ts'),
+    preload: join(webpackPaths.srcMainPath, 'modules/preload/preload.ts'),
+  },
+
+  output: {
+    path: webpackPaths.dllPath,
+    filename: '[name].bundle.dev.js',
+    library: {
+      type: 'umd',
+    },
+  },
+
+
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+
+  plugins: [
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    new BundleAnalyzerPlugin({
+      analyzerMode: process.env.ANALYZE === 'true' ? 'server' : 'disabled',
+      analyzerPort: 8888,
+    }),
+    new webpack.DefinePlugin({
+      'process.type': '"browser"',
+    }),
+  ],
+
+  /**
+   * Disables webpack processing of __dirname and __filename.
+   * If you run the bundle in node.js it falls back to these values of node.js.
+   * https://github.com/webpack/webpack/issues/2010
+   */
+  node: {
+    __dirname: false,
+    __filename: false,
+  },
+}
+
+export default merge(baseConfig, configuration)
diff --git a/configs/webpack/webpack.config.renderer.dev.ts b/configs/webpack/webpack.config.renderer.dev.ts
index 4e26b436e..0825e6132 100644
--- a/configs/webpack/webpack.config.renderer.dev.ts
+++ b/configs/webpack/webpack.config.renderer.dev.ts
@@ -1,187 +1,77 @@
-import 'webpack-dev-server'
+/**
+ * Webpack dev config for the new src/ renderer.
+ *
+ * Extends the standard renderer dev config but swaps the entry point and
+ * HTML template to use src/ instead of src_old/renderer/.
+ * The main process, preload, DLL, and all build infrastructure remain identical.
+ *
+ * Usage: npm run start:dev
+ */
 
-import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin'
-import autoprefixer from 'autoprefixer'
-import chalk from 'chalk'
-import { execSync, spawn } from 'child_process'
 import EslintPlugin from 'eslint-webpack-plugin'
-import fs from 'fs'
 import HtmlWebpackPlugin from 'html-webpack-plugin'
-import MonacoEditorWebpackPlugin from 'monaco-editor-webpack-plugin'
-import { join, resolve } from 'path'
-import tailwindcss from 'tailwindcss'
+import { join } from 'path'
 import webpack from 'webpack'
-import { merge } from 'webpack-merge'
+import { mergeWithCustomize, customizeArray } from 'webpack-merge'
 
-import checkNodeEnv from '../../scripts/check-node-env'
-import { getAppInfoDefines } from './webpack.app-info'
-import baseConfig from './webpack.config.base'
+import rendererDevConfig from './webpack.config.renderer.old.dev'
 import webpackPaths from './webpack.paths'
 
-// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
-// at the dev webpack config is not accidentally run in a production environment
-if (process.env.NODE_ENV === 'production') {
-  checkNodeEnv('development')
-}
-
-const port = process.env.PORT || 1212
-const manifest = resolve(webpackPaths.dllPath, 'renderer.json')
-const skipDLLs =
-  module.parent?.filename.includes('webpack.config.renderer.dev.dll') ||
-  module.parent?.filename.includes('webpack.config.eslint')
-
-/**
- * Warn if the DLL is not built
- */
-if (!skipDLLs && !(fs.existsSync(webpackPaths.dllPath) && fs.existsSync(manifest))) {
-  console.log(
-    chalk.black.bgYellow.bold(
-      'The DLL files are missing. Sit back while we build them for you with "npm run build-dll"',
-    ),
-  )
-  execSync('npm run postinstall')
-}
-
-interface ICustomConfiguration extends webpack.Configuration {
-  devServer?: object
+const port = process.env.PORT || 1313
+const srcPath = join(webpackPaths.rootPath, 'src')
+
+// Remove the base HtmlWebpackPlugin and EslintPlugin so we can replace/skip them
+const basePlugins = (rendererDevConfig.plugins ?? []).filter(
+  (p) => !(p instanceof HtmlWebpackPlugin) && !(p instanceof EslintPlugin),
+)
+
+// Remove the duplicate bare ts-loader rule (/\.ts?$/) from the renderer config.
+// The base config already handles .ts files via /\.[jt]sx?$/ with transpileOnly + module:'esnext'.
+// The duplicate causes double-compilation: the bare ts-loader uses tsconfig's module:"commonjs",
+// injecting `exports.xxx` references that are undefined in webpack's module scope.
+const baseRules = (rendererDevConfig.module?.rules ?? []).filter((r) => {
+  if (r && typeof r === 'object' && 'test' in r && r.test instanceof RegExp) {
+    return r.test.toString() !== '/\\.ts?$/'
+  }
+  return true
+})
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const { devServer: _devServer, ...rendererWithoutDevServer } = rendererDevConfig
+
+const baseConfig = {
+  ...rendererWithoutDevServer,
+  module: { ...rendererDevConfig.module, rules: baseRules },
+  plugins: basePlugins,
 }
 
-const configuration: ICustomConfiguration = {
-  devtool: 'inline-source-map',
-
-  mode: 'development',
-
-  target: ['web', 'electron-renderer'],
-
+const srcOverrides: webpack.Configuration = {
   entry: [
     `webpack-dev-server/client?http://localhost:${port}/dist`,
     'webpack/hot/only-dev-server',
-    join(webpackPaths.srcRendererPath, 'index.tsx'),
+    join(srcPath, 'main.tsx'),
   ],
 
-  output: {
-    path: webpackPaths.distRendererPath,
-    publicPath: '/',
-    filename: 'renderer.dev.js',
-    library: {
-      type: 'umd',
-    },
-  },
-
-  module: {
-    rules: [
-      {
-        test: /\.s?(c|a)ss$/,
-        use: [
-          'style-loader',
-          {
-            loader: 'css-loader',
-            options: {
-              modules: true,
-              sourceMap: true,
-              importLoaders: 1,
-            },
-          },
-          'sass-loader',
-        ],
-        include: /\.module\.s?(c|a)ss$/,
-      },
-      {
-        test: /\.s?css$/,
-        use: [
-          'style-loader',
-          'css-loader',
-          'sass-loader',
-          {
-            loader: 'postcss-loader',
-            options: {
-              postcssOptions: {
-                plugins: [tailwindcss, autoprefixer],
-              },
-            },
-          },
-        ],
-        exclude: /\.module\.s?(c|a)ss$/,
-      },
-      // Fonts
-      {
-        test: /\.(woff|woff2|eot|ttf|otf)$/i,
-        type: 'asset/resource',
-      },
-      // Images
-      {
-        test: /\.(png|jpg|jpeg|gif)$/i,
-        type: 'asset/resource',
-      },
-      // SVG
-      {
-        test: /\.svg$/,
-        use: [
-          {
-            loader: '@svgr/webpack',
-            options: {
-              prettier: false,
-              svgo: false,
-              svgoConfig: {
-                plugins: [{ removeViewBox: false }],
-              },
-              titleProp: true,
-              ref: true,
-            },
-          },
-          'file-loader',
-        ],
-      },
-
-    ],
+  devServer: {
+    port,
+    compress: true,
+    hot: true,
+    headers: { 'Access-Control-Allow-Origin': '*' },
+    static: { publicPath: '/' },
+    historyApiFallback: { verbose: true },
+    // No setupMiddlewares — start:electron handles main process separately.
   },
 
   resolve: {
-    extensions: ['.ts', '.js'],
+    alias: {
+      '@src': join(webpackPaths.rootPath, 'src'),
+    },
   },
-  plugins: [
-    ...(skipDLLs
-      ? []
-      : [
-          new webpack.DllReferencePlugin({
-            context: webpackPaths.dllPath,
-            manifest: require(manifest),
-            sourceType: 'var',
-          }),
-        ]),
-
-    new webpack.NoEmitOnErrorsPlugin(),
-
-    /**
-     * Create global constants which can be configured at compile time.
-     *
-     * Useful for allowing different behaviour between development builds and
-     * release builds
-     *
-     * NODE_ENV should be production so that modules do not perform certain
-     * development checks
-     *
-     * By default, use 'development' as NODE_ENV. This can be overriden with
-     * 'staging', for example, by changing the ENV variables in the npm scripts
-     */
-    new webpack.EnvironmentPlugin({
-      NODE_ENV: 'development',
-    }),
-
-    new webpack.DefinePlugin({
-      ...getAppInfoDefines(),
-    }),
-
-    new webpack.LoaderOptionsPlugin({
-      options: {},
-      debug: true,
-    }),
-
-    new ReactRefreshWebpackPlugin(),
 
+  plugins: [
     new HtmlWebpackPlugin({
-      filename: join('index.html'),
-      template: join(webpackPaths.srcRendererPath, 'index.ejs'),
+      filename: 'index.html',
+      template: join(srcPath, 'index.ejs'),
       minify: {
         collapseWhitespace: true,
         removeAttributeQuotes: true,
@@ -192,60 +82,11 @@ const configuration: ICustomConfiguration = {
       isDevelopment: process.env.NODE_ENV !== 'production',
       nodeModules: webpackPaths.appNodeModulesPath,
     }),
-
-    new MonacoEditorWebpackPlugin({
-      languages: ['python'],
-    }),
-
-    new EslintPlugin({
-      configType: 'flat',
-      extensions: ['ts', 'tsx'],
-      eslintPath: 'eslint/use-at-your-own-risk',
-    }),
   ],
-
-  node: {
-    __dirname: false,
-    __filename: false,
-  },
-
-  devServer: {
-    port,
-    compress: true,
-    hot: true,
-    headers: { 'Access-Control-Allow-Origin': '*' },
-    static: {
-      publicPath: '/',
-    },
-    historyApiFallback: {
-      verbose: true,
-    },
-    setupMiddlewares(middlewares: never) {
-      console.log('Starting preload.js builder...')
-      const preloadProcess = spawn('npm', ['run', 'start:preload'], {
-        shell: true,
-        stdio: 'inherit',
-      })
-        .on('close', (code: number) => process.exit(code))
-        .on('error', (spawnError) => console.error(spawnError))
-
-      console.log('Starting Main Process...')
-      let args = ['run', 'start:main']
-      if (process.env.MAIN_ARGS) {
-        args = args.concat(['--', ...process.env.MAIN_ARGS.matchAll(/"[^"]+"|[^\s"]+/g)].flat())
-      }
-      spawn('npm', args, {
-        shell: true,
-        stdio: 'inherit',
-      })
-        .on('close', (code: number) => {
-          preloadProcess.kill()
-          process.exit(code)
-        })
-        .on('error', (spawnError) => console.error(spawnError))
-      return middlewares
-    },
-  },
 }
 
-export default merge(baseConfig, configuration)
+export default mergeWithCustomize({
+  customizeArray: customizeArray({
+    entry: 'replace',
+  }),
+})(baseConfig, srcOverrides)
diff --git a/configs/webpack/webpack.config.renderer.old.dev.ts b/configs/webpack/webpack.config.renderer.old.dev.ts
new file mode 100644
index 000000000..28649a5d3
--- /dev/null
+++ b/configs/webpack/webpack.config.renderer.old.dev.ts
@@ -0,0 +1,256 @@
+import 'webpack-dev-server'
+
+import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin'
+import autoprefixer from 'autoprefixer'
+import chalk from 'chalk'
+import { execSync, spawn } from 'child_process'
+import EslintPlugin from 'eslint-webpack-plugin'
+import fs from 'fs'
+import HtmlWebpackPlugin from 'html-webpack-plugin'
+import MonacoEditorWebpackPlugin from 'monaco-editor-webpack-plugin'
+import { join, resolve } from 'path'
+import tailwindcss from 'tailwindcss'
+import webpack from 'webpack'
+import { merge } from 'webpack-merge'
+
+import checkNodeEnv from '../../scripts/check-node-env'
+import { getAppInfoDefines } from './webpack.app-info'
+import baseConfig from './webpack.config.base'
+import webpackPaths from './webpack.paths'
+
+// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
+// at the dev webpack config is not accidentally run in a production environment
+if (process.env.NODE_ENV === 'production') {
+  checkNodeEnv('development')
+}
+
+const port = process.env.PORT || 1212
+const manifest = resolve(webpackPaths.dllPath, 'renderer.json')
+const skipDLLs =
+  module.parent?.filename.includes('webpack.config.renderer.dev.dll') ||
+  module.parent?.filename.includes('webpack.config.eslint')
+
+/**
+ * Warn if the DLL is not built
+ */
+if (!skipDLLs && !(fs.existsSync(webpackPaths.dllPath) && fs.existsSync(manifest))) {
+  console.log(
+    chalk.black.bgYellow.bold(
+      'The DLL files are missing. Sit back while we build them for you with "npm run build-dll"',
+    ),
+  )
+  execSync('npm run postinstall')
+}
+
+interface ICustomConfiguration extends webpack.Configuration {
+  devServer?: object
+}
+
+const configuration: ICustomConfiguration = {
+  devtool: 'inline-source-map',
+
+  mode: 'development',
+
+  target: ['web', 'electron-renderer'],
+
+  entry: [
+    `webpack-dev-server/client?http://localhost:${port}/dist`,
+    'webpack/hot/only-dev-server',
+    join(webpackPaths.srcRendererPath, 'index.tsx'),
+  ],
+
+  output: {
+    path: webpackPaths.distRendererPath,
+    publicPath: '/',
+    filename: 'renderer.dev.js',
+    library: {
+      type: 'umd',
+    },
+  },
+
+  module: {
+    rules: [
+      {
+        test: /\.s?(c|a)ss$/,
+        use: [
+          'style-loader',
+          {
+            loader: 'css-loader',
+            options: {
+              modules: true,
+              sourceMap: true,
+              importLoaders: 1,
+            },
+          },
+          'sass-loader',
+        ],
+        include: /\.module\.s?(c|a)ss$/,
+      },
+      {
+        test: /\.s?css$/,
+        use: [
+          'style-loader',
+          'css-loader',
+          'sass-loader',
+          {
+            loader: 'postcss-loader',
+            options: {
+              postcssOptions: {
+                plugins: [tailwindcss, autoprefixer],
+              },
+            },
+          },
+        ],
+        exclude: /\.module\.s?(c|a)ss$/,
+      },
+      // Fonts
+      {
+        test: /\.(woff|woff2|eot|ttf|otf)$/i,
+        type: 'asset/resource',
+      },
+      // Images
+      {
+        test: /\.(png|jpg|jpeg|gif)$/i,
+        type: 'asset/resource',
+      },
+      // SVG
+      {
+        test: /\.svg$/,
+        use: [
+          {
+            loader: '@svgr/webpack',
+            options: {
+              prettier: false,
+              svgo: false,
+              svgoConfig: {
+                plugins: [{ removeViewBox: false }],
+              },
+              titleProp: true,
+              ref: true,
+            },
+          },
+          'file-loader',
+        ],
+      },
+
+      {
+        test: /\.ts?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  plugins: [
+    ...(skipDLLs
+      ? []
+      : [
+          new webpack.DllReferencePlugin({
+            context: webpackPaths.dllPath,
+            manifest: require(manifest),
+            sourceType: 'var',
+          }),
+        ]),
+
+    new webpack.NoEmitOnErrorsPlugin(),
+
+    /**
+     * Create global constants which can be configured at compile time.
+     *
+     * Useful for allowing different behaviour between development builds and
+     * release builds
+     *
+     * NODE_ENV should be production so that modules do not perform certain
+     * development checks
+     *
+     * By default, use 'development' as NODE_ENV. This can be overriden with
+     * 'staging', for example, by changing the ENV variables in the npm scripts
+     */
+    new webpack.EnvironmentPlugin({
+      NODE_ENV: 'development',
+    }),
+
+    new webpack.DefinePlugin({
+      ...getAppInfoDefines(),
+    }),
+
+    new webpack.LoaderOptionsPlugin({
+      options: {},
+      debug: true,
+    }),
+
+    new ReactRefreshWebpackPlugin(),
+
+    new HtmlWebpackPlugin({
+      filename: join('index.html'),
+      template: join(webpackPaths.srcRendererPath, 'index.ejs'),
+      minify: {
+        collapseWhitespace: true,
+        removeAttributeQuotes: true,
+        removeComments: true,
+      },
+      isBrowser: false,
+      env: process.env.NODE_ENV,
+      isDevelopment: process.env.NODE_ENV !== 'production',
+      nodeModules: webpackPaths.appNodeModulesPath,
+    }),
+
+    new MonacoEditorWebpackPlugin({
+      languages: ['python'],
+    }),
+
+    new EslintPlugin({
+      configType: 'flat',
+      extensions: ['ts', 'tsx'],
+      eslintPath: 'eslint/use-at-your-own-risk',
+    }),
+  ],
+
+  node: {
+    __dirname: false,
+    __filename: false,
+  },
+
+  devServer: {
+    port,
+    compress: true,
+    hot: true,
+    headers: { 'Access-Control-Allow-Origin': '*' },
+    static: {
+      publicPath: '/',
+    },
+    historyApiFallback: {
+      verbose: true,
+    },
+    setupMiddlewares(middlewares: never) {
+      console.log('Starting preload.js builder...')
+      const preloadProcess = spawn('npm', ['run', 'start:preload'], {
+        shell: true,
+        stdio: 'inherit',
+      })
+        .on('close', (code: number) => process.exit(code))
+        .on('error', (spawnError) => console.error(spawnError))
+
+      console.log('Starting Main Process...')
+      let args = ['run', 'start:main']
+      if (process.env.MAIN_ARGS) {
+        args = args.concat(['--', ...process.env.MAIN_ARGS.matchAll(/"[^"]+"|[^\s"]+/g)].flat())
+      }
+      spawn('npm', args, {
+        shell: true,
+        stdio: 'inherit',
+      })
+        .on('close', (code: number) => {
+          preloadProcess.kill()
+          process.exit(code)
+        })
+        .on('error', (spawnError) => console.error(spawnError))
+      return middlewares
+    },
+  },
+}
+
+export default merge(baseConfig, configuration)
diff --git a/configs/webpack/webpack.config.renderer.src2.dev.ts b/configs/webpack/webpack.config.renderer.src2.dev.ts
deleted file mode 100644
index c44ebbccd..000000000
--- a/configs/webpack/webpack.config.renderer.src2.dev.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * Webpack dev config for the src2/ migration renderer.
- *
- * Extends the standard renderer dev config but swaps the entry point and
- * HTML template to use src2/ instead of src/renderer/.
- * The main process, preload, DLL, and all build infrastructure remain identical.
- *
- * Usage: npm run start:src2
- */
-
-import EslintPlugin from 'eslint-webpack-plugin'
-import HtmlWebpackPlugin from 'html-webpack-plugin'
-import { join } from 'path'
-import webpack from 'webpack'
-import { mergeWithCustomize, customizeArray } from 'webpack-merge'
-
-import rendererDevConfig from './webpack.config.renderer.dev'
-import webpackPaths from './webpack.paths'
-
-const port = process.env.PORT || 1212
-const src2Path = join(webpackPaths.rootPath, 'src2')
-
-// Remove the base HtmlWebpackPlugin and EslintPlugin so we can replace/skip them
-const basePlugins = (rendererDevConfig.plugins ?? []).filter(
-  (p) => !(p instanceof HtmlWebpackPlugin) && !(p instanceof EslintPlugin),
-)
-const baseConfig = { ...rendererDevConfig, plugins: basePlugins }
-
-const src2Overrides: webpack.Configuration = {
-  entry: [
-    `webpack-dev-server/client?http://localhost:${port}/dist`,
-    'webpack/hot/only-dev-server',
-    join(src2Path, 'main.tsx'),
-  ],
-
-  resolve: {
-    alias: {
-      '@src2': join(webpackPaths.rootPath, 'src2'),
-    },
-  },
-
-  plugins: [
-    new HtmlWebpackPlugin({
-      filename: 'index.html',
-      template: join(src2Path, 'index.ejs'),
-      minify: {
-        collapseWhitespace: true,
-        removeAttributeQuotes: true,
-        removeComments: true,
-      },
-      isBrowser: false,
-      env: process.env.NODE_ENV,
-      isDevelopment: process.env.NODE_ENV !== 'production',
-      nodeModules: webpackPaths.appNodeModulesPath,
-    }),
-  ],
-}
-
-export default mergeWithCustomize({
-  customizeArray: customizeArray({
-    entry: 'replace',
-  }),
-})(baseConfig, src2Overrides)
diff --git a/configs/webpack/webpack.paths.ts b/configs/webpack/webpack.paths.ts
index edbcb5339..716e0c582 100644
--- a/configs/webpack/webpack.paths.ts
+++ b/configs/webpack/webpack.paths.ts
@@ -4,7 +4,7 @@ const rootPath = join(__dirname, '../..')
 
 const dllPath = join(__dirname, '../dll')
 
-const srcPath = join(rootPath, 'src')
+const srcPath = join(rootPath, 'src_old')
 const srcMainPath = join(srcPath, 'main')
 const srcRendererPath = join(srcPath, 'renderer')
 
@@ -20,7 +20,7 @@ const distRendererPath = join(distPath, 'renderer')
 
 const buildPath = join(releasePath, 'build')
 
-const typesPath = join(srcPath, 'types')
+const typesPath = join(rootPath, 'src', 'types')
 
 export default {
   rootPath,
diff --git a/docs/dead-code-inventory.md b/docs/dead-code-inventory.md
new file mode 100644
index 000000000..803a9315d
--- /dev/null
+++ b/docs/dead-code-inventory.md
@@ -0,0 +1,69 @@
+# Dead Code Inventory
+
+Audit date: 2026-03-17
+Branch: `fix/step-31-final-adjustments`
+
+This document tracks dead code identified during a code quality audit.
+Items here are documented for later cleanup — they are not blocking any work.
+
+---
+
+## Unused Exported Function
+
+### `getVariableSize()` — `src/frontend/utils/variable-sizes.ts:101-146`
+
+Exported function that takes a full `PLCVariable` object and returns byte size.
+Superseded by `getTypeSizeByName()` (line 152) which takes just a type name string.
+
+- Never imported by any other file in the codebase.
+- Not called internally within the file.
+- The sibling function `getTypeSizeByName` covers the same logic and is actively used.
+
+**Action:** Remove the function. No callers to update.
+
+---
+
+## Unnecessary Export Keyword
+
+### `parseVariableValue()` — `src/frontend/utils/variable-sizes.ts:189-258`
+
+Exported but only called internally by `parseValueByTypeName()` (line 277).
+No external file imports `parseVariableValue` directly.
+
+**Action:** Remove the `export` keyword. The function itself is live code (used by `parseValueByTypeName` which is consumed by `useDebugPolling.ts`).
+
+---
+
+## Commented-Out Imports
+
+These are leftover commented imports that should be removed:
+
+| File | Line | Content |
+|------|------|---------|
+| `src/main/modules/preload/preload.ts` | 1 | `// import './splash-screen/index'` |
+| `src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts` | 4 | `// import type { VariableNode } from '...'` |
+| `src/types/common/project.ts` | 1, 3 | `// import { z } from 'zod'`, `// import { CONSTANTS, formatDate } from '@/utils'` |
+| `src/frontend/utils/PLC/xml-generator/codesys/pou-xml.ts` | 1 | `// import { PLCVariable } from '@root/types/PLC'` |
+| `src/frontend/components/_organisms/global-variables-editor/index.tsx` | 1 | `// import * as PrimitiveSwitch from '@radix-ui/react-switch'` |
+
+**Action:** Delete each commented line.
+
+---
+
+## TODO/FIXME Comments (Incomplete Implementations)
+
+These are not dead code but flag missing validation logic:
+
+| File | Description |
+|------|-------------|
+| `src/types/PLC/open-plc.ts:165-168` | Task name uniqueness — needs homologation |
+| `src/types/PLC/open-plc.ts:234-236` | Schema validation TODOs |
+| `src/types/PLC/units/task.ts` | Task interval regex validation missing |
+| `src/types/PLC/units/instance.ts` | Instance task/program validation missing |
+| `src/types/PLC/units/library.ts` | Library validation TODOs |
+| `src/backend/editor/hardware/hardware-module.ts` | TODO comment |
+| `src/backend/editor/compiler/compiler-module.ts` | TODO comment |
+| `src/backend/editor/services/project-service/utils/read-project.ts` | TODO comment |
+| `src/main/main.ts` | Multiple TODO comments |
+
+**Action:** Track as separate backlog items, not dead code cleanup.
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 94db363bf..04d3a3748 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -9,7 +9,7 @@ import tseslint from 'typescript-eslint'
 /** @type {import('@types/eslint').Linter.FlatConfig} */
 export default [
   {
-    files: ['src/**/*.ts', 'src/**/*.tsx'],
+    files: ['src/**/*.ts', 'src/**/*.tsx', 'src_old/**/*.ts', 'src_old/**/*.tsx'],
     ignores: [
       '**/*.d.ts',
       '**/*.test.{js,jsx,ts,tsx}',
@@ -59,7 +59,7 @@ export default [
     ...reactRecommended,
     name: 'eslint-plugin-react',
     files: ['**/*.{js,jsx,ts,tsx}'],
-    ignores: ['src/main/**/*'],
+    ignores: ['src_old/main/**/*'],
     languageOptions: {
       parserOptions: {
         project: true,
diff --git a/jest.config.json b/jest.config.json
index 6aaa26da5..4de4b15d0 100644
--- a/jest.config.json
+++ b/jest.config.json
@@ -1,33 +1,76 @@
 {
-  "setupFiles": ["<rootDir>/jest.setup.js"],
-  "modulePathIgnorePatterns": ["<rootDir>/release/"],
-  "moduleDirectories": ["node_modules", "release/app/node_modules"],
+  "displayName": "src",
+  "rootDir": ".",
+  "roots": ["<rootDir>/src"],
+  "setupFiles": ["<rootDir>/src/jest-vi-shim.ts"],
+  "moduleDirectories": ["node_modules"],
   "moduleFileExtensions": ["js", "json", "jsx", "ts", "tsx"],
   "moduleNameMapper": {
-    "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/configs/mocks/fileMock.js",
-    "\\.(css|less|sass|scss)$": "identity-obj-proxy",
     "^@root/(.*)$": "<rootDir>/src/$1",
-    "^@process:renderer/(.*)$": "<rootDir>/src/renderer/$1",
-    "^@process:main/(.*)$": "<rootDir>/src/main/$1"
+    "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/configs/mocks/fileMock.js",
+    "\\.(css|less|sass|scss)$": "identity-obj-proxy"
   },
-  "testEnvironment": "node",
+  "testEnvironment": "jsdom",
   "testEnvironmentOptions": {
     "url": "http://localhost/"
   },
-  "testMatch": ["**/?(*.)+(spec|test).(ts|tsx|js|jsx)", "**/__tests__/**/*.(ts|tsx|js|jsx)"],
-  "testPathIgnorePatterns": ["release/app/dist", "configs/dll", "e2e", "src2"],
+  "testMatch": [
+    "<rootDir>/src/**/?(*.)+(spec|test).(ts|tsx)",
+    "<rootDir>/src/**/__tests__/**/*.(ts|tsx)"
+  ],
   "transform": {
-    "\\.(ts|tsx|js|jsx)$": [
-      "ts-jest",
-      {
-        "tsconfig": "tsconfig.json"
-      }
-    ],
-    "^.+.tsx?$": [
+    "\\.(ts|tsx)$": [
       "ts-jest",
       {
         "tsconfig": "tsconfig.json"
       }
     ]
+  },
+  "collectCoverageFrom": [
+    "src/**/*.{ts,tsx}",
+    "!src/**/*.d.ts",
+    "!src/**/__tests__/**",
+    "!src/**/*.{test,spec}.{ts,tsx}",
+    "!src/__architecture__/**",
+    "!src/**/index.ts",
+    "!src/middleware/shared/ports/*.ts",
+    "!src/middleware/shared/providers/types.ts",
+    "!src/middleware/adapters/**",
+    "!src/middleware/editor-platform.ts",
+    "!src/App.tsx",
+    "!src/main.tsx",
+    "!src/backend/styles/**",
+    "!src/backend/shared-data/**",
+    "!src/frontend/locales/**",
+    "!src/frontend/components/**",
+    "!src/frontend/assets/**",
+    "!src/frontend/data/**",
+    "!src/frontend/hooks/**",
+    "!src/frontend/services/**",
+    "!src/frontend/screens/**",
+    "!src/frontend/store/index.ts",
+    "!src/frontend/store/slices/project/validation/**",
+    "!src/frontend/utils/generate-uuid.ts",
+    "!src/frontend/utils/variable-types.ts",
+    "!src/frontend/utils/variable-reference-types.ts",
+    "!src/frontend/utils/hex.ts",
+    "!src/frontend/utils/debug-parser.ts",
+    "!src/frontend/utils/debug-tree-builder.ts",
+    "!src/frontend/utils/debug-tree-traversal.ts",
+    "!src/frontend/utils/debug-variable-finder.ts",
+    "!src/frontend/utils/pou-helpers.ts",
+    "!src/frontend/utils/variable-sizes.ts",
+    "!src/backend/shared/array-variable-utils.ts",
+    "!src/jest-vi-shim.ts"
+  ],
+  "coverageDirectory": "coverage/src",
+  "coverageReporters": ["text", "text-summary", "lcov", "json-summary"],
+  "coverageThreshold": {
+    "global": {
+      "branches": 100,
+      "functions": 100,
+      "lines": 100,
+      "statements": 100
+    }
   }
 }
diff --git a/jest.config.old.json b/jest.config.old.json
new file mode 100644
index 000000000..c821bfc9a
--- /dev/null
+++ b/jest.config.old.json
@@ -0,0 +1,34 @@
+{
+  "setupFiles": ["<rootDir>/jest.setup.js"],
+  "modulePathIgnorePatterns": ["<rootDir>/release/"],
+  "moduleDirectories": ["node_modules", "release/app/node_modules"],
+  "moduleFileExtensions": ["js", "json", "jsx", "ts", "tsx"],
+  "moduleNameMapper": {
+    "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/configs/mocks/fileMock.js",
+    "\\.(css|less|sass|scss)$": "identity-obj-proxy",
+    "^@root/(.*)$": "<rootDir>/src_old/$1",
+    "^@process:renderer/(.*)$": "<rootDir>/src_old/renderer/$1",
+    "^@process:main/(.*)$": "<rootDir>/src_old/main/$1"
+  },
+  "testEnvironment": "node",
+  "testEnvironmentOptions": {
+    "url": "http://localhost/"
+  },
+  "roots": ["<rootDir>/src_old"],
+  "testMatch": ["**/?(*.)+(spec|test).(ts|tsx|js|jsx)", "**/__tests__/**/*.(ts|tsx|js|jsx)"],
+  "testPathIgnorePatterns": ["release/app/dist", "configs/dll", "e2e"],
+  "transform": {
+    "\\.(ts|tsx|js|jsx)$": [
+      "ts-jest",
+      {
+        "tsconfig": "tsconfig.json"
+      }
+    ],
+    "^.+.tsx?$": [
+      "ts-jest",
+      {
+        "tsconfig": "tsconfig.json"
+      }
+    ]
+  }
+}
diff --git a/jest.config.src2.json b/jest.config.src2.json
deleted file mode 100644
index 81c4ddf54..000000000
--- a/jest.config.src2.json
+++ /dev/null
@@ -1,75 +0,0 @@
-{
-  "displayName": "src2",
-  "rootDir": ".",
-  "roots": ["<rootDir>/src2"],
-  "setupFiles": ["<rootDir>/src2/jest-vi-shim.ts"],
-  "moduleDirectories": ["node_modules"],
-  "moduleFileExtensions": ["js", "json", "jsx", "ts", "tsx"],
-  "moduleNameMapper": {
-    "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/configs/mocks/fileMock.js",
-    "\\.(css|less|sass|scss)$": "identity-obj-proxy"
-  },
-  "testEnvironment": "jsdom",
-  "testEnvironmentOptions": {
-    "url": "http://localhost/"
-  },
-  "testMatch": [
-    "<rootDir>/src2/**/?(*.)+(spec|test).(ts|tsx)",
-    "<rootDir>/src2/**/__tests__/**/*.(ts|tsx)"
-  ],
-  "transform": {
-    "\\.(ts|tsx)$": [
-      "ts-jest",
-      {
-        "tsconfig": "tsconfig.json"
-      }
-    ]
-  },
-  "collectCoverageFrom": [
-    "src2/**/*.{ts,tsx}",
-    "!src2/**/*.d.ts",
-    "!src2/**/__tests__/**",
-    "!src2/**/*.{test,spec}.{ts,tsx}",
-    "!src2/__architecture__/**",
-    "!src2/**/index.ts",
-    "!src2/middleware/shared/ports/*.ts",
-    "!src2/middleware/shared/providers/types.ts",
-    "!src2/middleware/adapters/**",
-    "!src2/middleware/editor-platform.ts",
-    "!src2/App.tsx",
-    "!src2/main.tsx",
-    "!src2/backend/styles/**",
-    "!src2/backend/shared-data/**",
-    "!src2/frontend/locales/**",
-    "!src2/frontend/components/**",
-    "!src2/frontend/assets/**",
-    "!src2/frontend/data/**",
-    "!src2/frontend/hooks/**",
-    "!src2/frontend/services/**",
-    "!src2/frontend/screens/**",
-    "!src2/frontend/store/index.ts",
-    "!src2/frontend/store/slices/project/validation/**",
-    "!src2/frontend/utils/generate-uuid.ts",
-    "!src2/frontend/utils/variable-types.ts",
-    "!src2/frontend/utils/variable-reference-types.ts",
-    "!src2/frontend/utils/hex.ts",
-    "!src2/frontend/utils/debug-parser.ts",
-    "!src2/frontend/utils/debug-tree-builder.ts",
-    "!src2/frontend/utils/debug-tree-traversal.ts",
-    "!src2/frontend/utils/debug-variable-finder.ts",
-    "!src2/frontend/utils/pou-helpers.ts",
-    "!src2/frontend/utils/variable-sizes.ts",
-    "!src2/backend/shared/array-variable-utils.ts",
-    "!src2/jest-vi-shim.ts"
-  ],
-  "coverageDirectory": "coverage/src2",
-  "coverageReporters": ["text", "text-summary", "lcov", "json-summary"],
-  "coverageThreshold": {
-    "global": {
-      "branches": 100,
-      "functions": 100,
-      "lines": 100,
-      "statements": 100
-    }
-  }
-}
diff --git a/package.json b/package.json
index 30ebd57a4..4e391e115 100644
--- a/package.json
+++ b/package.json
@@ -14,24 +14,29 @@
     "build:renderer": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./configs/webpack/webpack.config.renderer.prod.ts",
     "lint": "cross-env NODE_ENV=development eslint ./src/**/*.{ts,tsx}",
     "lint:fix": "cross-env NODE_ENV=development eslint ./src/**/*.{ts,tsx} --debug --fix",
+    "lint:old": "cross-env NODE_ENV=development eslint ./src_old/**/*.{ts,tsx}",
+    "lint:old:fix": "cross-env NODE_ENV=development eslint ./src_old/**/*.{ts,tsx} --debug --fix",
     "format": "cross-env NODE_ENV=development prettier --write \"./src/**/*.{ts,tsx}\"",
+    "format:old": "cross-env NODE_ENV=development prettier --write \"./src_old/**/*.{ts,tsx}\"",
     "postinstall": "ts-node scripts/download-binaries.ts && ts-node scripts/check-native-dep.js && electron-builder install-app-deps && npm run build:dll",
     "setup:binaries": "ts-node scripts/download-binaries.ts",
     "package": "ts-node scripts/clean.js dist && npm run build && electron-builder build --publish never && npm run build:dll",
     "rebuild": "electron-rebuild --parallel --types prod,dev,optional --module-dir release/app",
     "prestart": "ts-node scripts/download-binaries.ts && cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./configs/webpack/webpack.config.main.dev.ts",
-    "start:dev": "ts-node scripts/check-port-in-use.js && npm run prestart && npm run start:renderer",
-    "start:main": "concurrently -k \"cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --watch --config ./configs/webpack/webpack.config.main.dev.ts\" \"electronmon .\"",
-    "start:preload": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./configs/webpack/webpack.config.preload.dev.ts",
+    "start:dev": "cross-env PORT=1313 ts-node scripts/check-port-in-use.js && npm run prestart && npm run start:renderer",
     "start:renderer": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack serve --config ./configs/webpack/webpack.config.renderer.dev.ts",
-    "start:src2": "ts-node scripts/check-port-in-use.js && npm run prestart && npm run start:renderer:src2",
-    "start:renderer:src2": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack serve --config ./configs/webpack/webpack.config.renderer.src2.dev.ts",
-    "test:unit": "jest --watch --no-coverage",
+    "start:electron": "cross-env PORT=1313 ts-node scripts/check-port-in-use.js && npm run prestart && concurrently -k \"npm run start:renderer\" \"cross-env PORT=1313 electronmon .\"",
+    "start:preload": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./configs/webpack/webpack.config.preload.dev.ts",
+    "prestart:old": "ts-node scripts/download-binaries.ts && cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./configs/webpack/webpack.config.main.old.dev.ts",
+    "start:dev:old": "ts-node scripts/check-port-in-use.js && npm run prestart:old && npm run start:renderer:old",
+    "start:main:old": "concurrently -k \"cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --watch --config ./configs/webpack/webpack.config.main.old.dev.ts\" \"electronmon .\"",
+    "start:renderer:old": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack serve --config ./configs/webpack/webpack.config.renderer.old.dev.ts",
+    "test": "jest --collectCoverage",
+    "test:watch": "jest --watch --no-coverage",
+    "test:old": "jest --config jest.config.old.json --collectCoverage --",
+    "test:old:unit": "jest --config jest.config.old.json --watch --no-coverage",
     "test:e2e": "npm run build && npx playwright test",
-    "test": "jest --collectCoverage --",
-    "test:src2": "jest --config jest.config.src2.json --collectCoverage",
-    "test:src2:watch": "jest --config jest.config.src2.json --watch --no-coverage",
-    "validate:arch": "npx tsx src2/__architecture__/validate.ts",
+    "validate:arch": "npx tsx src/__architecture__/validate.ts",
     "prepare": "husky"
   },
   "browserslist": [],
@@ -183,7 +188,8 @@
       "!node_modules",
       "!node_modules/**/*",
       "!.*",
-      "src/**/*"
+      "src/**/*",
+      "src_old/**/*"
     ],
     "logLevel": "quiet"
   },
@@ -191,6 +197,10 @@
     "./src/**/*": [
       "npm run lint:fix",
       "npm run format"
+    ],
+    "./src_old/**/*": [
+      "npm run lint:old:fix",
+      "npm run format:old"
     ]
   }
 }
diff --git a/scripts/fix-import-depths.ts b/scripts/fix-import-depths.ts
index a73e35dc0..748d88c2c 100644
--- a/scripts/fix-import-depths.ts
+++ b/scripts/fix-import-depths.ts
@@ -1,6 +1,6 @@
 #!/usr/bin/env npx tsx
 /**
- * Fix relative import paths in src2/ that have incorrect depth (wrong number of ../ segments).
+ * Fix relative import paths in src/ that have incorrect depth (wrong number of ../ segments).
  *
  * For each relative import, resolves it from the importing file's directory.
  * If the target doesn't exist, tries removing or adding ../ segments until it resolves.
@@ -12,7 +12,7 @@
 import * as fs from 'fs'
 import * as path from 'path'
 
-const SRC2_DIR = path.resolve(__dirname, '..', 'src2')
+const SRC_DIR = path.resolve(__dirname, '..', 'src')
 const DRY_RUN = process.argv.includes('--dry-run')
 const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx']
 const RESOLVE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js', '/index.jsx']
@@ -71,9 +71,9 @@ function fixImportPath(fromDir: string, importPath: string): string | null {
   for (let add = 1; add <= 5; add++) {
     const newDotDots = dotdotCount + add
     const candidate = [...Array(newDotDots).fill('..'), ...tail].join('/')
-    // Safety: don't escape the src2 root
+    // Safety: don't escape the src root
     const resolved = path.resolve(fromDir, candidate)
-    if (!resolved.startsWith(SRC2_DIR)) break
+    if (!resolved.startsWith(SRC_DIR)) break
     if (resolveImport(fromDir, candidate)) {
       return candidate
     }
@@ -89,8 +89,8 @@ const IMPORT_RE = /(?:from\s+|import\s*\(?\s*)(['"])(\.\.?\/[^'"]+)\1/g
 let totalFixes = 0
 let totalFiles = 0
 
-const files = getAllFiles(SRC2_DIR)
-console.log(`Scanning ${files.length} files in src2/...`)
+const files = getAllFiles(SRC_DIR)
+console.log(`Scanning ${files.length} files in src/...`)
 
 for (const filePath of files) {
   const content = fs.readFileSync(filePath, 'utf-8')
diff --git a/src/App.tsx b/src/App.tsx
new file mode 100644
index 000000000..3068e21b4
--- /dev/null
+++ b/src/App.tsx
@@ -0,0 +1,74 @@
+import '@xyflow/react/dist/style.css'
+import 'tailwindcss/tailwind.css'
+import './backend/styles/globals.css'
+
+import { useEffect } from 'react'
+
+import { AppLayout } from './frontend/components/_templates/app-layout'
+import {
+  AdditionalFunctionBlocks,
+  ArduinoFunctionBlocks,
+  Arithmetic,
+  BitShift,
+  Bitwise,
+  CharacterString,
+  CommunicationBlocks,
+  Comparison,
+  Jaguar,
+  MQTT,
+  Numerical,
+  P1AM,
+  Selection,
+  SequentMicrosystemsModules,
+  StandardFunctionBlocks,
+  Time,
+  TypeConversion,
+} from './frontend/data/library'
+import { StartScreen } from './frontend/screens/start-screen'
+import { WorkspaceScreen } from './frontend/screens/workspace-screen'
+import { openPLCStoreBase, useOpenPLCStore } from './frontend/store'
+import { editorPorts, setRuntimeIpAddress } from './middleware/editor-platform'
+import { PlatformProvider } from './middleware/shared/providers'
+
+// Initialize system libraries at module load time (before first render)
+openPLCStoreBase
+  .getState()
+  .libraryActions.setSystemLibraries([
+    AdditionalFunctionBlocks,
+    ArduinoFunctionBlocks,
+    CommunicationBlocks,
+    Jaguar,
+    MQTT,
+    P1AM,
+    SequentMicrosystemsModules,
+    StandardFunctionBlocks,
+    Arithmetic,
+    BitShift,
+    Bitwise,
+    CharacterString,
+    Comparison,
+    Numerical,
+    Selection,
+    Time,
+    TypeConversion,
+  ])
+
+export default function App() {
+  const {
+    project: {
+      meta: { path },
+    },
+  } = useOpenPLCStore()
+
+  // Sync store runtime IP to the platform adapter so the runtime port can access it
+  const runtimeIpAddress = useOpenPLCStore((state) => state.deviceDefinitions.configuration.runtimeIpAddress || '')
+  useEffect(() => {
+    setRuntimeIpAddress(runtimeIpAddress)
+  }, [runtimeIpAddress])
+
+  return (
+    <PlatformProvider ports={editorPorts}>
+      <AppLayout>{path === '' ? <StartScreen /> : <WorkspaceScreen />}</AppLayout>
+    </PlatformProvider>
+  )
+}
diff --git a/src2/__architecture__/validate.ts b/src/__architecture__/validate.ts
similarity index 78%
rename from src2/__architecture__/validate.ts
rename to src/__architecture__/validate.ts
index f31f8c93e..dcca3c405 100644
--- a/src2/__architecture__/validate.ts
+++ b/src/__architecture__/validate.ts
@@ -1,10 +1,10 @@
 /**
- * Architecture validation script for the src2/ migration.
+ * Architecture validation script.
  *
- * Scans all .ts/.tsx files in src2/, extracts imports, and validates
+ * Scans all .ts/.tsx files in src/, extracts imports, and validates
  * that dependency rules between architectural layers are respected.
  *
- * Run: npx tsx src2/__architecture__/validate.ts
+ * Run: npx tsx src/__architecture__/validate.ts
  * Exit code 0 = pass, 1 = violations found
  */
 
@@ -31,14 +31,14 @@ type LayerName =
 interface LayerRule {
   /** Human-readable layer name */
   name: string
-  /** Layers this layer is allowed to import from (within src2/) */
+  /** Layers this layer is allowed to import from (within src/) */
   allowedDeps: LayerName[]
 }
 
 const LAYER_RULES: Record<LayerName, LayerRule> = {
   utils: {
     name: 'Domain (frontend/utils/)',
-    allowedDeps: ['utils'],
+    allowedDeps: ['utils', 'ports', 'data'],
   },
   data: {
     name: 'Data (frontend/data/)',
@@ -54,7 +54,7 @@ const LAYER_RULES: Record<LayerName, LayerRule> = {
   },
   adapters: {
     name: 'Adapters (middleware/adapters/)',
-    allowedDeps: ['ports', 'provider', 'utils'],
+    allowedDeps: ['ports', 'provider', 'utils', 'backend-shared'],
   },
   'backend-shared': {
     name: 'Backend Shared (backend/shared/)',
@@ -62,19 +62,19 @@ const LAYER_RULES: Record<LayerName, LayerRule> = {
   },
   store: {
     name: 'Store (frontend/store/)',
-    allowedDeps: ['ports', 'provider', 'store', 'utils', 'backend-shared'],
+    allowedDeps: ['ports', 'provider', 'store', 'utils'],
   },
   services: {
     name: 'Services (frontend/services/)',
-    allowedDeps: ['ports', 'provider', 'store', 'services', 'utils', 'backend-shared'],
+    allowedDeps: ['ports', 'provider', 'store', 'services', 'utils'],
   },
   hooks: {
     name: 'Hooks (frontend/hooks/)',
-    allowedDeps: ['ports', 'provider', 'store', 'hooks', 'services', 'utils', 'backend-shared'],
+    allowedDeps: ['ports', 'provider', 'store', 'hooks', 'services', 'utils'],
   },
   components: {
     name: 'Components (frontend/components/)',
-    allowedDeps: ['ports', 'provider', 'store', 'hooks', 'services', 'components', 'data', 'utils', 'backend-shared'],
+    allowedDeps: ['ports', 'provider', 'store', 'hooks', 'services', 'components', 'data', 'utils'],
   },
   architecture: {
     name: 'Architecture (__architecture__/)',
@@ -86,7 +86,8 @@ const LAYER_RULES: Record<LayerName, LayerRule> = {
 // Helpers
 // ---------------------------------------------------------------------------
 
-const SRC2_ROOT = resolve(dirname(new URL(import.meta.url).pathname), '..')
+// @ts-expect-error TS1343 — this script runs via `npx tsx` (ESM), not through webpack
+const SRC_ROOT = resolve(dirname(new URL(import.meta.url).pathname), '..')
 
 function collectFiles(dir: string, ext: string[]): string[] {
   const results: string[] = []
@@ -104,7 +105,7 @@ function collectFiles(dir: string, ext: string[]): string[] {
 
 /** Determine which architectural layer a file belongs to */
 function getLayer(filePath: string): LayerName | null {
-  const rel = relative(SRC2_ROOT, filePath).replace(/\\/g, '/')
+  const rel = relative(SRC_ROOT, filePath).replace(/\\/g, '/')
 
   if (rel.startsWith('__architecture__/')) return 'architecture'
 
@@ -162,14 +163,14 @@ function extractImports(source: string): { path: string; line: number }[] {
 
 /** Resolve a relative import path to an absolute file path (best-effort) */
 function resolveImport(importPath: string, fromFile: string): string | null {
-  // Only check relative imports (within src2/)
+  // Only check relative imports (within src/)
   if (!importPath.startsWith('.')) return null
 
   const dir = dirname(fromFile)
   const resolved = resolve(dir, importPath)
 
-  // Check if it resolves to something inside src2/
-  if (!resolved.startsWith(SRC2_ROOT)) return null
+  // Check if it resolves to something inside src/
+  if (!resolved.startsWith(SRC_ROOT)) return null
 
   return resolved
 }
@@ -183,22 +184,17 @@ function resolveImport(importPath: string, fromFile: string): string | null {
  * functionality (e.g., sync utilities that bridge store types with component
  * types, or store helpers that reference component node builders).
  *
- * Each entry maps a file path (relative to SRC2_ROOT, forward-slash separated)
+ * Each entry maps a file path (relative to SRC_ROOT, forward-slash separated)
  * to the set of extra layers it is allowed to import from beyond what its own
  * layer rule permits.
  */
 const KNOWN_EXCEPTIONS: Record<string, LayerName[]> = {
-  // Syncs React Flow nodes with PLC variables — needs store types, port types, and component constants
-  'frontend/utils/graphical/sync-nodes-with-variables.ts': ['ports', 'store', 'components'],
-  // Determines which FB variables to clean up — needs port types and component block types
-  'frontend/utils/graphical/get-function-block-variables-to-cleanup.ts': ['ports', 'components'],
-  // FBD paste/duplicate helpers — needs component atom types and molecule node builders
+  // FBD paste/duplicate helpers — needs molecule-level buildGenericNode from components
   'frontend/store/slices/fbd/utils/index.ts': ['components'],
-  // Debug utilities need port types, store types, and library data for variable resolution
-  'frontend/utils/variable-sizes.ts': ['ports'],
-  'frontend/utils/pou-helpers.ts': ['ports', 'data', 'store'],
-  'frontend/utils/debug-tree-traversal.ts': ['ports', 'data', 'store'],
-  'frontend/utils/debug-tree-builder.ts': ['ports', 'store'],
+  // Ladder paste/duplicate helpers — needs nodesBuilder from component atoms
+  'frontend/store/slices/ladder/utils/index.ts': ['components'],
+  // Ladder slice — needs nodesBuilder + defaultCustomNodesStyles for rung creation
+  'frontend/store/slices/ladder/slice.ts': ['components'],
 }
 
 // ---------------------------------------------------------------------------
@@ -217,7 +213,7 @@ interface Violation {
 function validate(): Violation[] {
   const violations: Violation[] = []
 
-  const files = collectFiles(SRC2_ROOT, ['.ts', '.tsx']).filter(
+  const files = collectFiles(SRC_ROOT, ['.ts', '.tsx']).filter(
     (f) => !f.includes('__architecture__/') && !f.includes('__tests__/') && !f.match(/\.(test|spec)\.[jt]sx?$/),
   )
 
@@ -227,17 +223,17 @@ function validate(): Violation[] {
 
     const source = readFileSync(file, 'utf-8')
     const imports = extractImports(source)
-    const relFile = relative(SRC2_ROOT, file).replace(/\\/g, '/')
+    const relFile = relative(SRC_ROOT, file).replace(/\\/g, '/')
     const exceptions = KNOWN_EXCEPTIONS[relFile] ?? []
 
     for (const imp of imports) {
       const resolved = resolveImport(imp.path, file)
-      if (!resolved) continue // External or non-src2 import — skip
+      if (!resolved) continue // External or non-src import — skip
 
       const toLayer = getLayer(resolved)
       if (!toLayer) continue // Can't determine target layer — skip
 
-      const rule = LAYER_RULES[fromLayer]
+      const rule: LayerRule = LAYER_RULES[fromLayer]
       if (!rule.allowedDeps.includes(toLayer) && fromLayer !== toLayer && !exceptions.includes(toLayer)) {
         violations.push({
           file: relFile,
diff --git a/src2/__tests__/platform-context.test.tsx b/src/__tests__/platform-context.test.tsx
similarity index 96%
rename from src2/__tests__/platform-context.test.tsx
rename to src/__tests__/platform-context.test.tsx
index 5367f1fc4..bab0685f5 100644
--- a/src2/__tests__/platform-context.test.tsx
+++ b/src/__tests__/platform-context.test.tsx
@@ -1,6 +1,7 @@
 import { renderHook } from '@testing-library/react'
 import { type ReactNode } from 'react'
 
+import { EDITOR_CAPABILITIES } from '../middleware/shared/ports/platform-capabilities'
 import {
   PlatformProvider,
   useAccelerator,
@@ -17,7 +18,6 @@ import {
   useWindow,
 } from '../middleware/shared/providers'
 import type { PlatformPorts } from '../middleware/shared/providers/types'
-import { EDITOR_CAPABILITIES } from '../middleware/shared/ports/platform-capabilities'
 
 function createStubPort<T extends object>(): T {
   return new Proxy({} as T, {
@@ -35,6 +35,7 @@ const testPorts: PlatformPorts = {
   simulator: createStubPort(),
   project: createStubPort(),
   device: createStubPort(),
+  orchestrator: createStubPort(),
   system: createStubPort(),
   window: createStubPort(),
   accelerator: createStubPort(),
@@ -55,9 +56,7 @@ describe('PlatformProvider', () => {
   it('throws when usePlatform is used outside PlatformProvider', () => {
     // Suppress expected React error boundary console output
     const spy = jest.spyOn(console, 'error').mockImplementation(() => {})
-    expect(() => renderHook(() => usePlatform())).toThrow(
-      'usePlatform must be used within a PlatformProvider',
-    )
+    expect(() => renderHook(() => usePlatform())).toThrow('usePlatform must be used within a PlatformProvider')
     spy.mockRestore()
   })
 })
diff --git a/src/main/modules/compiler/compiler-module.spec.ts b/src/backend/editor/compiler/compiler-module.spec.ts
similarity index 100%
rename from src/main/modules/compiler/compiler-module.spec.ts
rename to src/backend/editor/compiler/compiler-module.spec.ts
diff --git a/src/backend/editor/compiler/compiler-module.ts b/src/backend/editor/compiler/compiler-module.ts
new file mode 100644
index 000000000..a52bd83ab
--- /dev/null
+++ b/src/backend/editor/compiler/compiler-module.ts
@@ -0,0 +1,2335 @@
+import { exec, spawn } from 'node:child_process'
+import { promises as fs } from 'node:fs'
+import { cp, mkdir, readFile, writeFile } from 'node:fs/promises'
+import type { IncomingMessage } from 'node:http'
+import https from 'node:https'
+import os from 'node:os'
+import path from 'node:path'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+
+import { getRuntimeHttpsOptions } from '@root/backend/editor/utils/runtime-https-config'
+import type { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import type { PLCProjectData } from '@root/types/PLC/open-plc'
+import { type CppPouData as CppPouDataCode, generateCBlocksCode } from '@root/utils/cpp/generateCBlocksCode'
+import { type CppPouData as CppPouDataHeader, generateCBlocksHeader } from '@root/utils/cpp/generateCBlocksHeader'
+import { getErrorMessage } from '@root/utils/get-error-message'
+import { generateModbusMasterConfig } from '@root/utils/modbus/generate-modbus-master-config'
+import { generateModbusSlaveConfig } from '@root/utils/modbus/generate-modbus-slave-config'
+import { generateOpcUaConfig, OpcUaConfigError } from '@root/utils/opcua'
+import { XmlGenerator } from '@root/utils/PLC/xml-generator'
+import { parsePlcStatus } from '@root/utils/plc-status'
+import { generateS7CommConfig } from '@root/utils/s7comm'
+import { app as electronApp, dialog } from 'electron'
+import type { MessagePortMain } from 'electron/main'
+import JSZip from 'jszip'
+
+import { CreateXMLFile } from '../utils'
+import type { ArduinoCoreControl, HalsFile } from './compiler-types'
+import { FormatMacAddress } from './utils/formatters'
+
+interface MethodsResult<T> {
+  success: boolean
+  data?: T
+}
+type HandleOutputDataCallback = (chunk: Buffer | string, logLevel?: 'info' | 'error') => void
+
+type CompileArduinoProgramArgs = {
+  boardTarget: string
+  boardHalsContent: HalsFile[string]
+  compilationPath: string
+  handleOutputData: HandleOutputDataCallback
+}
+
+class CompilerModule {
+  binaryDirectoryPath: string
+  sourceDirectoryPath: string
+  halsFilePath: string
+
+  arduinoCliBinaryPath: string
+  arduinoCliConfigurationFilePath: string
+  arduinoCliBaseParameters: string[]
+
+  xml2stBinaryPath: string
+
+  iec2cBinaryPath: string
+
+  // ############################################################################
+  // =========================== Static properties ==============================
+  // ############################################################################
+  static readonly HOST_PLATFORM = process.platform
+  static readonly HOST_ARCHITECTURE = process.arch
+  static readonly DEVELOPMENT_MODE = process.env.NODE_ENV === 'development'
+  // This will later be replaced by platform specific libraries
+  static readonly GLOBAL_LIBRARIES = [
+    'Arduino_EdgeControl',
+    'ArduinoJson',
+    'Arduino_MachineControl',
+    'ArduinoMqttClient',
+    'AVR_PWM',
+    'CAN',
+    'CONTROLLINO',
+    'DallasTemperature',
+    'Ethernet',
+    'megaAVR_PWM',
+    'OneWire',
+    'P1AM',
+    'Portenta_H7_PWM',
+    'PubSubClient',
+    'RP2040_PWM',
+    'SAMD_PWM',
+    'SAMDUE_PWM',
+    'STM32_CAN',
+    'STM32_PWM',
+    'WiFiNINA',
+  ]
+
+  // Runtime API polling configuration (important-comment)
+  static readonly COMPILATION_STATUS_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes (important-comment)
+  static readonly COMPILATION_STATUS_POLL_INTERVAL_MS = 1000 // 1 second (important-comment)
+
+  constructor() {
+    this.binaryDirectoryPath = this.#constructBinaryDirectoryPath()
+    this.sourceDirectoryPath = this.#constructSourceDirectoryPath()
+    this.halsFilePath = this.#constructHalsFilePath()
+
+    this.arduinoCliBinaryPath = this.#constructArduinoCliBinaryPath()
+    this.arduinoCliConfigurationFilePath = join(electronApp.getPath('userData'), 'User', 'arduino-cli.yaml')
+    // INFO: We use this approach because some commands can receive additional parameters as a string array.
+    this.arduinoCliBaseParameters = ['--config-file', this.arduinoCliConfigurationFilePath]
+
+    this.xml2stBinaryPath = this.#constructXml2stBinaryPath()
+
+    this.iec2cBinaryPath = this.#constructIec2cBinaryPath()
+  }
+
+  // ############################################################################
+  // =========================== Static methods =================================
+  // ############################################################################
+  static async readJSONFile<T>(filePath: string): Promise<T> {
+    const data = await readFile(filePath, 'utf-8')
+    return JSON.parse(data) as T
+  }
+
+  // ############################################################################
+  // =========================== Private methods ================================
+  // ############################################################################
+
+  private parseLogLevel(message: string): { level: 'info' | 'warning' | 'error'; cleanedMessage: string } {
+    const logLevelMatch = message.match(/^\[(INFO|WARNING|ERROR)\]\s*/)
+
+    if (logLevelMatch) {
+      const level = logLevelMatch[1].toLowerCase() as 'info' | 'warning' | 'error'
+      const cleanedMessage = message.replace(/^\[(INFO|WARNING|ERROR)\]\s*/, '')
+      return {
+        level,
+        cleanedMessage,
+      }
+    }
+
+    return {
+      level: 'info',
+      cleanedMessage: message,
+    }
+  }
+
+  // Initialize paths based on the environment
+  #constructBinaryDirectoryPath(): string {
+    if (CompilerModule.HOST_ARCHITECTURE !== 'x64' && CompilerModule.HOST_ARCHITECTURE !== 'arm64') return ''
+    const platformSpecificPath = join(CompilerModule.HOST_PLATFORM, CompilerModule.HOST_ARCHITECTURE)
+    return join(
+      CompilerModule.DEVELOPMENT_MODE ? process.cwd() : process.resourcesPath,
+      CompilerModule.DEVELOPMENT_MODE ? 'resources' : '',
+      'bin',
+      CompilerModule.DEVELOPMENT_MODE ? platformSpecificPath : '',
+    )
+  }
+
+  #constructSourceDirectoryPath(): string {
+    return join(
+      CompilerModule.DEVELOPMENT_MODE ? process.cwd() : process.resourcesPath,
+      CompilerModule.DEVELOPMENT_MODE ? 'resources' : '',
+      'sources',
+    )
+  }
+
+  #constructHalsFilePath(): string {
+    return join(
+      CompilerModule.DEVELOPMENT_MODE ? process.cwd() : process.resourcesPath,
+      CompilerModule.DEVELOPMENT_MODE ? 'resources' : '',
+      'sources',
+      'boards',
+      'hals.json',
+    )
+  }
+
+  #constructArduinoCliBinaryPath(): string {
+    return join(this.binaryDirectoryPath, 'arduino-cli')
+  }
+
+  #constructXml2stBinaryPath(): string {
+    return join(this.binaryDirectoryPath, 'xml2st', CompilerModule.HOST_PLATFORM === 'darwin' ? 'xml2st' : '')
+  }
+
+  #constructIec2cBinaryPath(): string {
+    return join(this.binaryDirectoryPath, 'iec2c')
+  }
+
+  async #getBoardRuntime(board: string) {
+    const halsFileContent = await CompilerModule.readJSONFile<HalsFile>(this.halsFilePath)
+    return halsFileContent[board]['compiler']
+  }
+
+  #executeXml2st(args: string[]) {
+    let xml2stBinaryPath = this.xml2stBinaryPath
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      xml2stBinaryPath += '.exe'
+    }
+    return spawn(xml2stBinaryPath, args)
+  }
+
+  #executeArduinoCliCommand(args: string[]) {
+    let arduinoCliBinaryPath = this.arduinoCliBinaryPath
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      arduinoCliBinaryPath += '.exe'
+    }
+    return spawn(arduinoCliBinaryPath, args)
+  }
+
+  // ############################################################################
+  // =========================== Public methods =================================
+  // ############################################################################
+
+  // ++ ========================= Utility methods ============================= ++
+
+  getHostHardwareInfo() {
+    return `
+      System Architecture - ${process.arch}
+      Operating System - ${process.platform}
+      Processor - ${process.env.PROCESSOR_IDENTIFIER}
+      Logical CPU Cores - ${os.cpus().length}
+      CPU Frequency - ${os.cpus()[0].speed} MHz
+      CPU Model - ${os.cpus()[0].model}
+    `
+  }
+
+  async checkArduinoCliAvailability(): Promise<MethodsResult<string>> {
+    let binaryPath = this.arduinoCliBinaryPath
+    const [flag, configFilePath] = this.arduinoCliBaseParameters
+    const executeCommand = promisify(exec)
+
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      // INFO: On Windows, we need to add the .exe extension to the binary path.
+      binaryPath += '.exe'
+    }
+    // INFO: We use the version command to check if the arduino-cli is available.
+    // INFO: If the command is not available, it will throw an error.
+    const { stdout, stderr } = await executeCommand(`"${binaryPath}" version ${flag} "${configFilePath}" --json`)
+    if (stderr) {
+      throw new Error(`Arduino CLI not available: ${stderr}`)
+    }
+
+    /**
+     * Parses the JSON output from the Arduino CLI.
+     * @example The output will be like:
+     * {
+     *  "Application": "arduino-cli",
+     *  "VersionString": "x.y.z",
+     *  "Commit": "commit-hash",
+     *  "Status": "version-status",
+     *  "Date": "release-date",
+     * }
+     * @updatedAt 17/07/2025
+     */
+    const stdoutAsJsonObject = JSON.parse(stdout) as Record<string, string>
+
+    const { VersionString } = stdoutAsJsonObject
+
+    return { success: true, data: VersionString }
+  }
+
+  async checkIec2cAvailability(): Promise<MethodsResult<string>> {
+    let binaryPath = this.iec2cBinaryPath
+    const executeCommand = promisify(exec)
+
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      // INFO: On Windows, we need to add the .exe extension to the binary path.
+      binaryPath += '.exe'
+    }
+    // INFO: We use the version command to check if the iec2c is available.
+    // INFO: If the command is not available, it will throw an error.
+    const { stdout, stderr } = await executeCommand(`"${binaryPath}" -v`)
+    if (stderr) {
+      throw new Error(`IEC2C not available: ${stderr}`)
+    }
+
+    const firstLine = stdout.split('\n')[0] // Get the first line of the output
+    const lineAsArray = firstLine.split(' ') // Split the line by spaces
+    const version = lineAsArray[lineAsArray.length - 1] // The version is the last element in the array
+
+    return { success: true, data: version }
+  }
+
+  async getArduinoInstalledCores() {
+    const coreControlFilePath = join(electronApp.getPath('userData'), 'User', 'Runtime', 'arduino-core-control.json')
+    const coreControlFileContent = await CompilerModule.readJSONFile<ArduinoCoreControl>(coreControlFilePath)
+    return coreControlFileContent
+  }
+
+  async getArduinoInstalledLibraries() {
+    const libraryControlFilePath = join(
+      electronApp.getPath('userData'),
+      'User',
+      'Runtime',
+      'arduino-library-control.json',
+    )
+    const libraryControlFileContent =
+      await CompilerModule.readJSONFile<Array<Record<string, string>>>(libraryControlFilePath)
+
+    const installedLibraries = libraryControlFileContent.map((lib) => Object.keys(lib)[0])
+
+    return installedLibraries
+  }
+
+  // ++ =========================== Defines.h methods ==========================++
+  async createMD5Hash(content: string): Promise<string> {
+    const crypto = await import('node:crypto')
+    return crypto.createHash('md5').update(content).digest('hex')
+  }
+  // ++ ========================= Build Steps ================================= ++
+
+  // +++++++++++++++++++++++++ Initialization Methods ++++++++++++++++++++++++++++
+  async createBasicDirectories(
+    projectFolderPath: string,
+    boardTarget: string,
+  ): Promise<MethodsResult<string | string[]>> {
+    // INFO: We don't need to check if the directories already exist, as mkdir with { recursive: true } will handle that.
+    // INFO: We will create a build directory (if it does not exist), a board-specific directory, and a source directory within the board directory.
+    let result: MethodsResult<string | string[]> = { success: false }
+    const buildDirectory = join(projectFolderPath, 'build')
+    const boardDirectory = join(buildDirectory, boardTarget)
+    const sourceDirectory = join(boardDirectory, 'src')
+
+    // Create the directories recursively.
+    // INFO: We don't have to create the build directory separately
+    const results = await Promise.all([
+      mkdir(boardDirectory, { recursive: true }),
+      mkdir(sourceDirectory, { recursive: true }),
+    ])
+    if (results[0] || results[1]) {
+      result = { success: true, data: [boardDirectory, sourceDirectory] }
+    } else {
+      result = { success: true }
+    }
+
+    return result
+  }
+
+  // INFO: This method is a placeholder for copying static files.
+  async copyStaticFiles(compilationPath: string, boardTarget: string): Promise<MethodsResult<string>> {
+    let result: MethodsResult<string> = { success: false }
+    let filesToCopy: Promise<void>[] = []
+
+    const staticArduinoFilesPath = join(this.sourceDirectoryPath, 'arduino')
+    const staticBaremetalFilesPath = join(this.sourceDirectoryPath, 'Baremetal')
+    const staticMatIECLibraryFilesPath = join(this.sourceDirectoryPath, 'MatIEC', 'lib')
+
+    const sourceTargetFolderPath = join(compilationPath, 'src')
+
+    if (boardTarget !== 'openplc-compiler') {
+      filesToCopy = [
+        cp(staticArduinoFilesPath, sourceTargetFolderPath, { recursive: true }),
+        cp(staticMatIECLibraryFilesPath, join(sourceTargetFolderPath, 'lib'), { recursive: true }),
+        cp(staticBaremetalFilesPath, join(compilationPath, 'examples', 'Baremetal'), { recursive: true }),
+      ]
+    } else {
+      // INFO: If the board target is OpenPLC, we copy the MatIEC library files and C/C++ block templates.
+      const cBlocksHeaderPath = join(this.sourceDirectoryPath, 'arduino', 'c_blocks.h')
+      const cBlocksCodePath = join(this.sourceDirectoryPath, 'Baremetal', 'c_blocks_code.cpp')
+      filesToCopy = [
+        cp(staticMatIECLibraryFilesPath, join(sourceTargetFolderPath, 'lib'), { recursive: true }),
+        cp(cBlocksHeaderPath, join(sourceTargetFolderPath, 'c_blocks.h')),
+        cp(cBlocksCodePath, join(sourceTargetFolderPath, 'c_blocks_code.cpp')),
+      ]
+    }
+
+    try {
+      // Implement the logic to copy static build files.
+      const results = await Promise.all(filesToCopy)
+      if (results.every((res) => res === undefined)) {
+        result = { success: true, data: 'Static build files available' }
+      }
+    } catch (error) {
+      throw new Error(`Error copying static files: ${error as string}`)
+    }
+
+    return result
+  }
+
+  // +++++++++++++++++++++++++++ Compilation Methods +++++++++++++++++++++++++++++
+
+  async handleGenerateXMLfromJSON(sourceTargetFolderPath: string, jsonData: PLCProjectData) {
+    return new Promise<MethodsResult<{ xmlPath: string; xmlContent: string }>>((resolve, reject) => {
+      const { data: xmlData } = XmlGenerator(jsonData, 'old-editor')
+      if (typeof xmlData !== 'string') {
+        reject(new Error('XML data is not a string'))
+        return
+      }
+
+      const xmlCreationResult = CreateXMLFile(sourceTargetFolderPath, xmlData, 'plc')
+
+      if (xmlCreationResult.success) {
+        resolve({ success: true, data: { xmlPath: sourceTargetFolderPath, xmlContent: xmlData } })
+      } else {
+        reject(new Error('Failed to create XML file'))
+      }
+    })
+  }
+
+  async handleTranspileXMLtoST(
+    generatedXMLFilePath: string,
+    handleOutputData: (chunk: Buffer | string, logLevel?: 'info' | 'error') => void,
+  ) {
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const executeCommand = this.#executeXml2st(['--generate-st', generatedXMLFilePath])
+
+      let stderrData = ''
+
+      // INFO: We use the xml2st command to transpile the XML file to ST.
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          handleOutputData(`ST file generated at: ${generatedXMLFilePath.replace('plc.xml', 'program.st')}`, 'info')
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`xml2st process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  async handleTranspileSTtoC(
+    generatedSTFilePath: string,
+    handleOutputData: (chunk: Buffer | string, logLevel?: 'info' | 'error') => void,
+  ) {
+    // As the iec2c binary generates the C files in the same directory as the binary location,
+    // we need to set the target directory for the output files accordingly with the generated ST file path.
+    const targetDirectoryForOutput = join(generatedSTFilePath.replace('program.st', ''))
+
+    let binaryPath = this.iec2cBinaryPath
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      // INFO: On Windows, we need to add the .exe extension to the binary path.
+      binaryPath += '.exe'
+    }
+
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const executeCommand = spawn(binaryPath, ['-f', '-p', '-i', '-l', generatedSTFilePath], {
+        cwd: targetDirectoryForOutput,
+      })
+
+      let stderrData = ''
+
+      // INFO: We use the iec2c command to transpile the ST file to C.
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          handleOutputData(`C files generated at: ${targetDirectoryForOutput}`, 'info')
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`iec2c process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  async handleGenerateDebugFiles(
+    sourceTargetFolderPath: string,
+    handleOutputData: (chunk: Buffer | string, logLevel?: 'info' | 'error') => void,
+  ) {
+    const generatedSTFilePath = join(sourceTargetFolderPath, 'program.st') // Assuming the XML file is named 'program.st'
+    const generatedVARIABLESFilePath = join(sourceTargetFolderPath, 'VARIABLES.csv') // Assuming the VARIABLES file is named 'VARIABLES.csv'
+
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const executeCommand = this.#executeXml2st(['--generate-debug', generatedSTFilePath, generatedVARIABLESFilePath])
+
+      let stderrData = ''
+
+      // INFO: We use the xml2st command to generate debug files.
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          handleOutputData(`Debug files generated at: ${sourceTargetFolderPath}`, 'info')
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`xml2st process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  async handleGenerateGlueVars(
+    sourceTargetFolderPath: string,
+    handleOutputData: (chunk: Buffer | string, logLevel?: 'info' | 'error') => void,
+  ) {
+    const generatedLocatedVariablesFilePath = join(sourceTargetFolderPath, 'LOCATED_VARIABLES.h')
+
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const executeCommand = this.#executeXml2st(['--generate-gluevars', generatedLocatedVariablesFilePath])
+
+      let stderrData = ''
+
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          handleOutputData(`Glue vars generated at: ${sourceTargetFolderPath}`, 'info')
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`xml2st process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  // TODO: This method is used to update the index of the Arduino core.
+  // We should validate if this is necessary and if it works correctly.
+  async handleCoreUpdateIndex(handleOutputData: HandleOutputDataCallback) {
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      let binaryPath = this.arduinoCliBinaryPath
+      const [flag, configFilePath] = this.arduinoCliBaseParameters
+
+      if (CompilerModule.HOST_PLATFORM === 'win32') {
+        // INFO: On Windows, we need to add the .exe extension to the binary path.
+        binaryPath += '.exe'
+      }
+      const executeCommand = spawn(binaryPath, ['core', 'update-index', flag, configFilePath])
+
+      let stderrData = ''
+
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`Arduino CLI process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  async handleCoreInstallation(
+    boardCore: string | null,
+    handleOutputData: (chunk: Buffer | string, logLevel?: 'info' | 'error') => void,
+  ) {
+    if (boardCore === null) return
+
+    const isCoreInstalled = Object.keys(await this.getArduinoInstalledCores()).some((core) => core === boardCore)
+    if (isCoreInstalled) {
+      handleOutputData(`Core ${boardCore} is already installed.`, 'info')
+      return
+    }
+
+    let binaryPath = this.arduinoCliBinaryPath
+
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      // INFO: On Windows, we need to add the .exe extension to the binary path.
+      binaryPath += '.exe'
+    }
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const executeCommand = spawn(binaryPath, ['core', 'install', boardCore, ...this.arduinoCliBaseParameters])
+
+      let stderrData = ''
+
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`Arduino CLI process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  // Handle library installation
+  // In the future, this method will be responsible for installing any missing libraries.
+  // This should receive a list of libraries to install.
+  async handleLibraryInstallation(handleOutputData: HandleOutputDataCallback) {
+    // 1. Check what are the required libraries for the project - This will be the global libraries and the extra libraries that comes from the hals.json file.
+    // This will be filled later, for now is just a placeholder.
+    const extraLibraries: string[] = ['P1AM'] // We provide this value just for testing purposes.
+    const requiredLibraries = Array.from(new Set([...CompilerModule.GLOBAL_LIBRARIES, ...extraLibraries]))
+
+    // 2. Check if all required libraries are already installed
+    const installedLibraries = await this.getArduinoInstalledLibraries()
+    const missingLibraries = requiredLibraries.filter((lib) => !installedLibraries.includes(lib))
+
+    if (missingLibraries.length === 0) {
+      handleOutputData(`All required libraries are already installed.`, 'info')
+      return
+    }
+
+    let binaryPath = this.arduinoCliBinaryPath
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      // INFO: On Windows, we need to add the .exe extension to the binary path.
+      binaryPath += '.exe'
+    }
+
+    // 3. If not installed, run the installation command
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const executeCommand = spawn(binaryPath, [
+        'lib',
+        'install',
+        ...missingLibraries,
+        ...this.arduinoCliBaseParameters,
+      ])
+
+      let stderrData = ''
+
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          handleOutputData(`All libraries installed!`, 'info')
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`Arduino CLI process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+    // 4. Update the library index
+  }
+
+  // TODO: This method is used to update the index of the Arduino libraries.
+  // We should validate if this is necessary and if it works correctly.
+  async handleLibraryUpdateIndex(handleOutputData: HandleOutputDataCallback) {
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      let binaryPath = this.arduinoCliBinaryPath
+      const [flag, configFilePath] = this.arduinoCliBaseParameters
+
+      if (CompilerModule.HOST_PLATFORM === 'win32') {
+        // INFO: On Windows, we need to add the .exe extension to the binary path.
+        binaryPath += '.exe'
+      }
+      const executeCommand = spawn(binaryPath, ['lib', 'update-index', flag, configFilePath])
+
+      let stderrData = ''
+
+      executeCommand.stdout?.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      executeCommand.stderr?.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+      executeCommand.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`Arduino CLI process exited with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  async handleGenerateDefinitionsFile({
+    projectPath,
+    buildMD5Hash,
+    boardTarget,
+    boardRuntime,
+    _handleOutputData,
+  }: {
+    projectPath: string
+    boardTarget: string
+    buildMD5Hash: string
+    boardRuntime: string
+    _handleOutputData: HandleOutputDataCallback
+  }) {
+    let DEFINES_CONTENT: string = ''
+
+    // === Directories and files paths ===
+    const devicesDirectoryPath = join(projectPath, 'devices')
+    const devicesConfigurationFilePath = join(devicesDirectoryPath, 'configuration.json')
+    const devicesPinMappingFilePath = join(devicesDirectoryPath, 'pin-mapping.json')
+
+    const buildTargetDirectoryPath = join(projectPath, 'build', boardTarget)
+
+    const stProgramFilePath = join(buildTargetDirectoryPath, 'src', 'program.st')
+
+    const definitionsFilePath = join(buildTargetDirectoryPath, 'examples', 'Baremetal', 'defines.h')
+
+    // === Files contents that we need ===
+    const halsFileContent = await CompilerModule.readJSONFile<HalsFile>(this.halsFilePath)
+    const {
+      communicationConfiguration: { modbusRTU, modbusTCP, communicationPreferences },
+    } = await CompilerModule.readJSONFile<DeviceConfiguration>(devicesConfigurationFilePath)
+    const devicePinMapping = await CompilerModule.readJSONFile<DevicePin[]>(devicesPinMappingFilePath)
+    const stProgramFileContent = await readFile(stProgramFilePath, 'utf-8')
+
+    // We extract the board entry from the hals file content to validate if it has the define property.
+    const boardEntry = halsFileContent[boardTarget]
+
+    // ===== Defines.h content generation =====
+
+    // 1. We need to verify if the board entry in the hals.json file has the define property.
+    if (boardEntry && boardEntry.define) {
+      // 1.2. If it has the defines property, we will write a header and iterate over the defines to create the content for the defines.h file.
+      DEFINES_CONTENT = '// Board defines\n'
+      if (Array.isArray(boardEntry.define)) {
+        // 1.3. If the defines property is an array, we will iterate over it and add each define to the content.
+        boardEntry.define.forEach((define) => {
+          DEFINES_CONTENT += `#define ${define}\n`
+        })
+      } else if (typeof boardEntry.define === 'string') {
+        // 1.4. If the defines property is a string, we will add it directly to the content.
+        DEFINES_CONTENT += `#define ${boardEntry.define}\n`
+      }
+    }
+
+    // 2. If the board entry does not have the define property, we will just write a double line break to the file.
+    DEFINES_CONTENT += '\n\n'
+
+    // 3. Now we write the information for the defines.h file based on the device configuration and other preferences.
+
+    /**
+     * TODOS
+     * 3. In the device configuration we need to verify why the values that should be null are being set to empty strings.
+     * 4. We need to ensure that the pins are correctly sorted according to their address.
+     */
+
+    // 3.1. Program MD5
+    DEFINES_CONTENT += '//Program MD5\n'
+    DEFINES_CONTENT += `#define PROGRAM_MD5 "${buildMD5Hash}"`
+    DEFINES_CONTENT += `\n\n`
+
+    // 3.2. Device Configuration
+    DEFINES_CONTENT += '//Comms Configuration\n'
+    if (boardRuntime === 'simulator') {
+      // Simulator forces fixed Modbus RTU settings over emulated USART0.
+      // On ATmega2560, Serial = USART0. avr8js bridges usart0.
+      DEFINES_CONTENT += '#define SIMULATOR_MODE\n'
+      DEFINES_CONTENT += '#define MBSERIAL_IFACE Serial\n'
+      DEFINES_CONTENT += '#define MBSERIAL_BAUD 115200\n'
+      DEFINES_CONTENT += '#define MBSERIAL_SLAVE 1\n'
+    } else {
+      DEFINES_CONTENT += `#define MBSERIAL_IFACE ${modbusRTU.rtuInterface}\n`
+      DEFINES_CONTENT += `#define MBSERIAL_BAUD ${modbusRTU.rtuBaudRate}\n`
+      if (modbusRTU.rtuSlaveId !== null) DEFINES_CONTENT += `#define MBSERIAL_SLAVE ${modbusRTU.rtuSlaveId}\n`
+      if (modbusRTU.rtuRS485ENPin !== null) DEFINES_CONTENT += `#define MBSERIAL_TXPIN ${modbusRTU.rtuRS485ENPin}\n`
+    }
+    if (modbusTCP.tcpMacAddress !== null)
+      DEFINES_CONTENT += `#define MBTCP_MAC ${FormatMacAddress(modbusTCP.tcpMacAddress)}\n`
+    // OBS: This is giving us an empty string and this is being printed as a space
+    if (modbusTCP.tcpStaticHostConfiguration.ipAddress !== null)
+      DEFINES_CONTENT += `#define MBTCP_IP ${modbusTCP.tcpStaticHostConfiguration.ipAddress.replaceAll('.', ',')}\n`
+    if (modbusTCP.tcpStaticHostConfiguration.dns !== null)
+      DEFINES_CONTENT += `#define MBTCP_DNS ${modbusTCP.tcpStaticHostConfiguration.dns.replaceAll('.', ',')}\n`
+    if (modbusTCP.tcpStaticHostConfiguration.gateway !== null)
+      DEFINES_CONTENT += `#define MBTCP_GATEWAY ${modbusTCP.tcpStaticHostConfiguration.gateway.replaceAll('.', ',')}\n`
+    if (modbusTCP.tcpStaticHostConfiguration.subnet !== null)
+      DEFINES_CONTENT += `#define MBTCP_SUBNET ${modbusTCP.tcpStaticHostConfiguration.subnet.replaceAll('.', ',')}\n`
+
+    if (communicationPreferences.enabledRTU || boardRuntime === 'simulator') {
+      DEFINES_CONTENT += '#define MBSERIAL\n'
+      DEFINES_CONTENT += '#define MODBUS_ENABLED\n'
+    }
+
+    if (communicationPreferences.enabledTCP) {
+      DEFINES_CONTENT += '#define MBTCP\n'
+      DEFINES_CONTENT += '#define MODBUS_ENABLED\n'
+      if (modbusTCP.tcpInterface === 'Wi-Fi') {
+        if (modbusTCP.tcpWifiSSID !== null) {
+          DEFINES_CONTENT += `#define MBTCP_SSID "${modbusTCP.tcpWifiSSID}"\n`
+        }
+        if (modbusTCP.tcpWifiPassword !== null) {
+          DEFINES_CONTENT += `#define MBTCP_PWD "${modbusTCP.tcpWifiPassword}"\n`
+        }
+        DEFINES_CONTENT += '#define MBTCP_WIFI\n'
+      } else {
+        DEFINES_CONTENT += '#define MBTCP_ETHERNET\n'
+      }
+    }
+
+    DEFINES_CONTENT += `\n\n`
+
+    // INFO: If null, only the define value
+    // 3.3. IO Config defines
+    DEFINES_CONTENT += '//IO Config\n'
+    // INFO: This approach assumes that the pins are sorted.
+    const digitalInputPins = devicePinMapping.filter((pin) => pin.pinType === 'digitalInput')
+    const analogInputPins = devicePinMapping.filter((pin) => pin.pinType === 'analogInput')
+    const digitalOutputPins = devicePinMapping.filter((pin) => pin.pinType === 'digitalOutput')
+    const analogOutputPins = devicePinMapping.filter((pin) => pin.pinType === 'analogOutput')
+
+    DEFINES_CONTENT += `#define PINMASK_DIN ${digitalInputPins.map(({ pin }) => pin).join(', ')}\n`
+    DEFINES_CONTENT += `#define PINMASK_AIN ${analogInputPins.map(({ pin }) => pin).join(', ')}\n`
+    DEFINES_CONTENT += `#define PINMASK_DOUT ${digitalOutputPins.map(({ pin }) => pin).join(', ')}\n`
+    DEFINES_CONTENT += `#define PINMASK_AOUT ${analogOutputPins.map(({ pin }) => pin).join(', ')}\n`
+
+    DEFINES_CONTENT += `#define NUM_DISCRETE_INPUT ${digitalInputPins.length}\n`
+    DEFINES_CONTENT += `#define NUM_ANALOG_INPUT ${analogInputPins.length}\n`
+    DEFINES_CONTENT += `#define NUM_DISCRETE_OUTPUT ${digitalOutputPins.length}\n`
+    DEFINES_CONTENT += `#define NUM_ANALOG_OUTPUT ${analogOutputPins.length}\n`
+    DEFINES_CONTENT += `\n\n`
+
+    // 3.4. Arduino libraries defines
+    DEFINES_CONTENT += '//Arduino libraries\n'
+    if (
+      stProgramFileContent.includes('DS18B20;') ||
+      stProgramFileContent.includes('DS18B20_2_OUT;') ||
+      stProgramFileContent.includes('DS18B20_3_OUT;') ||
+      stProgramFileContent.includes('DS18B20_4_OUT;') ||
+      stProgramFileContent.includes('DS18B20_5_OUT;')
+    ) {
+      DEFINES_CONTENT += '#define USE_DS18B20_BLOCK\n'
+    }
+
+    if (stProgramFileContent.includes('P1AM_INIT;')) DEFINES_CONTENT += '#define USE_P1AM_BLOCKS\n'
+
+    if (stProgramFileContent.includes('CLOUD_BEGIN;')) DEFINES_CONTENT += '#define USE_CLOUD_BLOCKS\n'
+
+    if (stProgramFileContent.includes('MQTT_CONNECT;') || stProgramFileContent.includes('MQTT_CONNECT_AUTH;'))
+      DEFINES_CONTENT += '#define USE_MQTT_BLOCKS\n'
+
+    if (
+      stProgramFileContent.includes('ARDUINOCAN_CONF;') ||
+      stProgramFileContent.includes('ARDUINOCAN_WRITE;') ||
+      stProgramFileContent.includes('ARDUINOCAN_WRITE_WORD;') ||
+      stProgramFileContent.includes('ARDUINOCAN_READ;')
+    ) {
+      DEFINES_CONTENT += '#define USE_ARDUINOCAN_BLOCK\n'
+    }
+
+    if (
+      stProgramFileContent.includes('STM32CAN_CONF;') ||
+      stProgramFileContent.includes('STM32CAN_WRITE;') ||
+      stProgramFileContent.includes('STM32CAN_READ;')
+    ) {
+      DEFINES_CONTENT += '#define USE_STM32CAN_BLOCK\n'
+    }
+
+    if (
+      stProgramFileContent.includes('SM_8RELAY;') ||
+      stProgramFileContent.includes('SM_16RELAY;') ||
+      stProgramFileContent.includes('SM_8DIN;') ||
+      stProgramFileContent.includes('SM_16DIN;') ||
+      stProgramFileContent.includes('SM_4REL4IN;') ||
+      stProgramFileContent.includes('SM_INDUSTRIAL;') ||
+      stProgramFileContent.includes('SM_RTD;') ||
+      stProgramFileContent.includes('SM_BAS;') ||
+      stProgramFileContent.includes('SM_HOME;') ||
+      stProgramFileContent.includes('SM_8MOSFET;')
+    ) {
+      DEFINES_CONTENT += '#define USE_SM_BLOCKS\n'
+    }
+
+    // 4. Finally, we attempt to write the content to the defines.h file.
+    try {
+      await writeFile(definitionsFilePath, DEFINES_CONTENT, { encoding: 'utf8' })
+      _handleOutputData(`Defines file created at: ${definitionsFilePath}`, 'info')
+    } catch (_error) {
+      _handleOutputData('Error writing defines.h file', 'error')
+    }
+  }
+
+  async handlePatchGeneratedFiles(compilationPath: string, handleOutputData: HandleOutputDataCallback) {
+    const pousCFilePath = join(compilationPath, 'src', 'POUS.c')
+    const res0FilePath = join(compilationPath, 'src', 'Res0.c')
+    const config0FilePath = join(compilationPath, 'src', 'Config0.c')
+
+    const pousCContent = await readFile(pousCFilePath, { encoding: 'utf8' })
+    const patchedPousCContent = `#include "POUS.h"\n#include "Config0.h"\n\n${pousCContent}`
+    await writeFile(pousCFilePath, patchedPousCContent, { encoding: 'utf8' })
+
+    const res0FileContent = await readFile(res0FilePath, { encoding: 'utf8' })
+
+    const patchedRes0FileContent = res0FileContent.replaceAll('#include "POUS.c"', '#include "POUS.h"\n')
+
+    await writeFile(res0FilePath, patchedRes0FileContent, { encoding: 'utf8' })
+    handleOutputData('Required files patched', 'info')
+
+    // Unity build: Rename .c files to .inc so Arduino build system doesn't compile them separately.
+    // These files are #included by glueVars.c as a single compilation unit to avoid
+    // duplicate static function definitions that cause binary size bloat.
+    const pousIncFilePath = join(compilationPath, 'src', 'POUS.inc')
+    const res0IncFilePath = join(compilationPath, 'src', 'Res0.inc')
+    const config0IncFilePath = join(compilationPath, 'src', 'Config0.inc')
+
+    await fs.rename(pousCFilePath, pousIncFilePath)
+    await fs.rename(res0FilePath, res0IncFilePath)
+    await fs.rename(config0FilePath, config0IncFilePath)
+    handleOutputData('Files renamed to .inc for unity build', 'info')
+  }
+
+  async handleGenerateArduinoCppFile(projectPath: string, boardTarget: string) {
+    let result: MethodsResult<string> = { success: false }
+
+    const halsFileContent = await CompilerModule.readJSONFile<HalsFile>(this.halsFilePath)
+
+    const boardSourceFile = halsFileContent[boardTarget]['source']
+
+    const boardSourceFilePath = join(this.sourceDirectoryPath, 'hal', boardSourceFile)
+    const arduinoCppFilePath = join(projectPath, 'build', boardTarget, 'src', 'arduino.cpp')
+
+    try {
+      await cp(boardSourceFilePath, arduinoCppFilePath, { recursive: true })
+      result = { success: true, data: arduinoCppFilePath }
+    } catch (error) {
+      throw new Error(`Error copying Arduino source file: ${(error as Error).message}`)
+    }
+    return result
+  }
+
+  async handleGenerateCBlocksHeader(
+    projectData: PLCProjectData & { originalCppPous?: CppPouDataCode[] },
+    sourceTargetFolderPath: string,
+    handleOutputData: HandleOutputDataCallback,
+  ) {
+    const originalCppPous = projectData.originalCppPous || []
+
+    if (originalCppPous.length === 0) {
+      handleOutputData('No C/C++ blocks found, skipping c_blocks.h generation', 'info')
+      return
+    }
+
+    const cppPous = originalCppPous.map((pou) => ({
+      name: pou.name,
+      variables: pou.variables,
+    })) as CppPouDataHeader[]
+
+    const headerContent: string = generateCBlocksHeader(cppPous)
+    const headerFilePath = join(sourceTargetFolderPath, 'c_blocks.h')
+
+    try {
+      await writeFile(headerFilePath, headerContent, { encoding: 'utf8' })
+      handleOutputData(`C blocks header file populated at: ${headerFilePath}`, 'info')
+    } catch (error) {
+      throw new Error(`Error writing c_blocks.h file: ${(error as Error).message}`)
+    }
+  }
+
+  async handleGenerateCBlocksCode(
+    projectData: PLCProjectData & { originalCppPous?: CppPouDataCode[] },
+    compilationPath: string,
+    boardRuntime: string,
+    handleOutputData: HandleOutputDataCallback,
+  ) {
+    const originalCppPous = projectData.originalCppPous || []
+
+    if (originalCppPous.length === 0) {
+      handleOutputData('No C/C++ blocks found, skipping c_blocks_code.cpp generation', 'info')
+      return
+    }
+
+    const cppPous = originalCppPous
+    const codeContent = generateCBlocksCode(cppPous)
+
+    const codeFilePath =
+      boardRuntime === 'openplc-compiler'
+        ? join(compilationPath, 'src', 'c_blocks_code.cpp')
+        : join(compilationPath, 'examples', 'Baremetal', 'c_blocks_code.cpp')
+
+    try {
+      const existingContent = await readFile(codeFilePath, { encoding: 'utf8' })
+      const updatedContent = existingContent + '\n' + codeContent
+      await writeFile(codeFilePath, updatedContent, { encoding: 'utf8' })
+      handleOutputData(`C blocks code file populated at: ${codeFilePath}`, 'info')
+    } catch (error) {
+      throw new Error(`Error writing c_blocks_code.cpp file: ${(error as Error).message}`)
+    }
+  }
+
+  async handleCompileArduinoProgram({
+    boardHalsContent,
+    compilationPath,
+    handleOutputData,
+  }: CompileArduinoProgramArgs) {
+    const baremetalPath = join(compilationPath, 'examples', 'Baremetal')
+
+    let buildProjectFlags = ['compile', '-v']
+
+    if (boardHalsContent['c_flags']) {
+      buildProjectFlags = [
+        ...buildProjectFlags,
+        '--build-property',
+        `compiler.c.extra_flags=${boardHalsContent['c_flags'].map((f) => f).join(' ')}`,
+      ]
+    }
+
+    if (boardHalsContent['cxx_flags']) {
+      buildProjectFlags = [
+        ...buildProjectFlags,
+        '--build-property',
+        `compiler.cpp.extra_flags=${boardHalsContent['cxx_flags'].map((f) => f).join(' ')}`,
+      ]
+    }
+
+    if (boardHalsContent['ld_flags']) {
+      buildProjectFlags = [
+        ...buildProjectFlags,
+        '--build-property',
+        `compiler.c.elf.extra_flags=${boardHalsContent['ld_flags'].map((f: string) => f).join(' ')}`,
+      ]
+    }
+
+    buildProjectFlags = [
+      ...buildProjectFlags,
+      '--library',
+      `${join(compilationPath, 'src')}`, // Basic libraries
+      '--library',
+      `${join(compilationPath, 'src', 'lib')}`, // Arduino libraries
+      '--export-binaries', // Export binaries
+      '-b',
+      boardHalsContent['platform'], // Board target
+      join(baremetalPath, 'Baremetal.ino'), // Arduino .ino file
+      ...this.arduinoCliBaseParameters, // Base parameters
+    ]
+
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const child = this.#executeArduinoCliCommand(buildProjectFlags)
+      let stderrData = ''
+      child.stdout.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      child.stderr.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve({ success: true })
+        } else {
+          reject(new Error(`Compilation failed with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  async handleUploadProgram({
+    projectPath,
+    arduinoPlatform,
+    compilationPath,
+    handleOutputData,
+  }: {
+    projectPath: string
+    arduinoPlatform: string
+    compilationPath: string
+    handleOutputData: HandleOutputDataCallback
+  }) {
+    const devicesDirectoryPath = join(projectPath, 'devices')
+    const devicesConfigurationFilePath = join(devicesDirectoryPath, 'configuration.json')
+    const { communicationPort: port } =
+      await CompilerModule.readJSONFile<DeviceConfiguration>(devicesConfigurationFilePath)
+    const baremetalPath = join(compilationPath, 'examples', 'Baremetal')
+
+    if (!port) {
+      handleOutputData('No communication port specified', 'error')
+      return
+    }
+
+    return new Promise<MethodsResult<string | Buffer>>((resolve, reject) => {
+      const child = this.#executeArduinoCliCommand([
+        'upload',
+        '--port',
+        port,
+        '--fqbn',
+        arduinoPlatform,
+        baremetalPath,
+        ...this.arduinoCliBaseParameters,
+      ])
+
+      let stderrData = ''
+
+      child.stdout.on('data', (data: Buffer) => {
+        handleOutputData(data)
+      })
+      child.stderr.on('data', (data: Buffer) => {
+        stderrData += data.toString()
+      })
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+          })
+        } else {
+          reject(new Error(`Upload failed with code ${code}\n${stderrData}`))
+        }
+      })
+    })
+  }
+
+  // !! Deprecated: This method is a outdated implementation and should be removed.
+  async createXmlFile(
+    pathToUserProject: string,
+    dataToCreateXml: PLCProjectData,
+    parseTo: 'old-editor' | 'codesys',
+  ): Promise<{ success: boolean; message: string }> {
+    const { filePath } = await dialog.showSaveDialog({
+      title: 'Export Project',
+      defaultPath: join(pathToUserProject, 'plc.xml'),
+      buttonLabel: 'Save',
+      filters: [{ name: 'XML Files', extensions: ['xml'] }],
+    })
+
+    if (!filePath) {
+      return { success: false, message: 'User canceled the save dialog' }
+    }
+
+    const { data: projectDataAsString, message } = XmlGenerator(dataToCreateXml, parseTo) as {
+      data: string | undefined
+      message: string
+    }
+    if (!projectDataAsString) {
+      return { success: false, message: message }
+    }
+
+    const result = CreateXMLFile(filePath, projectDataAsString, 'plc')
+    try {
+      await writeFile(filePath, projectDataAsString)
+      console.log('File written to:', filePath)
+    } catch (err) {
+      console.error('Error writing file:', err)
+    }
+
+    return {
+      success: result.success,
+      message: result.success ? ` XML file created at ${filePath}` : 'Failed to create XML file',
+    }
+  }
+
+  // ++ ========================= Compiler builder ============================ ++
+
+  async compressSourceFolder(sourceFolderPath: string): Promise<Buffer> {
+    const zip = new JSZip()
+
+    async function addFilesToZip(currentPath: string, zipFolder: JSZip, relativePath: string = ''): Promise<void> {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true })
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name)
+        const zipPath = relativePath ? path.join(relativePath, entry.name) : entry.name
+
+        if (entry.isDirectory()) {
+          await addFilesToZip(fullPath, zipFolder, zipPath)
+        } else {
+          const fileContent = await fs.readFile(fullPath)
+          zipFolder.file(zipPath, fileContent)
+        }
+      }
+    }
+
+    await addFilesToZip(sourceFolderPath, zip)
+
+    const zipBuffer = await zip.generateAsync({ type: 'nodebuffer' })
+    return zipBuffer
+  }
+
+  async cleanConfFolder(sourceTargetFolderPath: string, handleOutputData: HandleOutputDataCallback): Promise<void> {
+    const confFolderPath = join(sourceTargetFolderPath, 'conf')
+
+    try {
+      await fs.access(confFolderPath)
+      await fs.rm(confFolderPath, { recursive: true })
+      handleOutputData('Cleaned conf folder from previous compilation', 'info')
+    } catch {
+      handleOutputData('No conf folder to clean', 'info')
+    }
+  }
+
+  async handleGenerateModbusSlaveConfig(
+    sourceTargetFolderPath: string,
+    projectData: PLCProjectData,
+    handleOutputData: HandleOutputDataCallback,
+  ): Promise<void> {
+    const modbusSlaveConfig: string | null = generateModbusSlaveConfig(projectData.servers)
+
+    if (modbusSlaveConfig) {
+      const confFolderPath = join(sourceTargetFolderPath, 'conf')
+      await mkdir(confFolderPath, { recursive: true })
+      const configFilePath = join(confFolderPath, 'modbus_slave.json')
+      await writeFile(configFilePath, modbusSlaveConfig, 'utf-8')
+      handleOutputData('Generated conf/modbus_slave.json', 'info')
+    } else {
+      handleOutputData('No Modbus TCP server configured, skipping modbus_slave.json generation', 'info')
+    }
+  }
+
+  async handleGenerateModbusMasterConfig(
+    sourceTargetFolderPath: string,
+    projectData: PLCProjectData,
+    handleOutputData: HandleOutputDataCallback,
+  ): Promise<void> {
+    const modbusMasterConfig: string | null = generateModbusMasterConfig(projectData.remoteDevices)
+
+    if (modbusMasterConfig) {
+      const confFolderPath = join(sourceTargetFolderPath, 'conf')
+      await mkdir(confFolderPath, { recursive: true })
+      const configFilePath = join(confFolderPath, 'modbus_master.json')
+      await writeFile(configFilePath, modbusMasterConfig, 'utf-8')
+      handleOutputData('Generated conf/modbus_master.json', 'info')
+    } else {
+      handleOutputData('No Modbus TCP remote devices configured, skipping modbus_master.json generation', 'info')
+    }
+  }
+
+  async handleGenerateS7CommConfig(
+    sourceTargetFolderPath: string,
+    projectData: PLCProjectData,
+    handleOutputData: HandleOutputDataCallback,
+  ): Promise<void> {
+    try {
+      const s7commConfig: string | null = generateS7CommConfig(projectData.servers)
+
+      if (s7commConfig) {
+        const confFolderPath = join(sourceTargetFolderPath, 'conf')
+        await mkdir(confFolderPath, { recursive: true })
+        const configFilePath = join(confFolderPath, 's7comm.json')
+        await writeFile(configFilePath, s7commConfig, 'utf-8')
+        handleOutputData('Generated conf/s7comm.json', 'info')
+      } else {
+        handleOutputData('No S7Comm server configured, skipping s7comm.json generation', 'info')
+      }
+    } catch (error) {
+      const errorMessage = getErrorMessage(error)
+      handleOutputData(`Failed to generate S7Comm config: ${errorMessage}`, 'error')
+      throw error
+    }
+  }
+
+  /**
+   * Generate OPC-UA server configuration for Runtime v4.
+   * Reads debug.c to resolve variable indices and generates opcua.json.
+   */
+  async handleGenerateOpcUaConfig(
+    sourceTargetFolderPath: string,
+    projectData: PLCProjectData,
+    handleOutputData: HandleOutputDataCallback,
+  ): Promise<void> {
+    try {
+      // Check if there's an enabled OPC-UA server
+      const opcuaServer = projectData.servers?.find(
+        (s) => s.protocol === 'opcua' && s.opcuaServerConfig?.server.enabled,
+      )
+
+      if (!opcuaServer || !opcuaServer.opcuaServerConfig) {
+        handleOutputData('No OPC-UA server configured, skipping opcua.json generation', 'info')
+        return
+      }
+
+      // Read the debug.c file generated by xml2st
+      const debugCPath = join(sourceTargetFolderPath, 'debug.c')
+      let debugContent: string
+
+      try {
+        debugContent = await readFile(debugCPath, 'utf-8')
+      } catch {
+        handleOutputData('Warning: Could not read debug.c file. OPC-UA variable indices may not be resolved.', 'error')
+        debugContent = ''
+      }
+
+      // Get instances from Resources configuration for index resolution
+      const instances = projectData.configuration.resource.instances.map((inst) => ({
+        name: inst.name,
+        task: inst.task,
+        program: inst.program,
+      }))
+
+      // Generate the OPC-UA configuration
+      const opcuaJson: string | null = generateOpcUaConfig(projectData.servers, debugContent, instances)
+
+      if (opcuaJson) {
+        // Ensure conf directory exists
+        const confFolderPath = join(sourceTargetFolderPath, 'conf')
+        await mkdir(confFolderPath, { recursive: true })
+
+        // Write the configuration file
+        const configFilePath = join(confFolderPath, 'opcua.json')
+        await writeFile(configFilePath, opcuaJson, 'utf-8')
+        handleOutputData('Generated conf/opcua.json', 'info')
+
+        // Log the number of configured nodes
+        const nodeCount = opcuaServer.opcuaServerConfig.addressSpace.nodes.length
+        handleOutputData(`OPC-UA Address Space: ${nodeCount} node(s) configured`, 'info')
+      } else {
+        handleOutputData('OPC-UA server enabled but no configuration generated', 'info')
+      }
+    } catch (error) {
+      if (error instanceof OpcUaConfigError) {
+        handleOutputData(`OPC-UA Configuration Error:\n${error.message}`, 'error')
+      } else {
+        const errorMessage = getErrorMessage(error)
+        handleOutputData(`Failed to generate OPC-UA config: ${errorMessage}`, 'error')
+      }
+      throw error
+    }
+  }
+
+  async embedCBlocksInProgramSt(
+    sourceTargetFolderPath: string,
+    handleOutputData: HandleOutputDataCallback,
+  ): Promise<void> {
+    const programStPath = join(sourceTargetFolderPath, 'program.st')
+    const cBlocksHeaderPath = join(sourceTargetFolderPath, 'c_blocks.h')
+    const cBlocksCodePath = join(sourceTargetFolderPath, 'c_blocks_code.cpp')
+
+    try {
+      let programStContent = await readFile(programStPath, 'utf8')
+
+      try {
+        await fs.access(cBlocksHeaderPath)
+        const headerContent = await readFile(cBlocksHeaderPath, 'utf8')
+        const headerLines = headerContent.split('\n')
+        const embeddedHeader = headerLines.map((line) => `(*FILE:c_blocks.h ${line} *)`).join('\n')
+        programStContent += '\n' + embeddedHeader
+
+        handleOutputData('Embedded c_blocks.h into program.st for Runtime v3', 'info')
+      } catch {
+        handleOutputData('c_blocks.h not found, skipping embedding', 'info')
+      }
+
+      try {
+        await fs.access(cBlocksCodePath)
+        const codeContent = await readFile(cBlocksCodePath, 'utf8')
+        const codeLines = codeContent.split('\n')
+        const embeddedCode = codeLines.map((line) => `(*FILE:c_blocks_code.cpp ${line} *)`).join('\n')
+        programStContent += '\n' + embeddedCode
+
+        handleOutputData('Embedded c_blocks_code.cpp into program.st for Runtime v3', 'info')
+      } catch {
+        handleOutputData('c_blocks_code.cpp not found, skipping embedding', 'info')
+      }
+
+      await writeFile(programStPath, programStContent, 'utf8')
+    } catch (error) {
+      throw new Error(`Error embedding C blocks in program.st: ${(error as Error).message}`)
+    }
+  }
+
+  /**
+   * This will be the main entry point for the compiler module.
+   * It will handle all the compilation process, will orchestrate the various steps involved in compiling a program.
+   */
+  // Work in progress - we should specify the arguments and the return type correctly.
+  async compileProgram(
+    args: Array<string | null | PLCProjectData>,
+    _mainProcessPort: MessagePortMain,
+    mainProcessBridge: {
+      makeRuntimeApiRequest: <T = void>(
+        ipAddress: string,
+        jwtToken: string,
+        endpoint: string,
+        responseParser?: (data: string) => T,
+      ) => Promise<{ success: true; data?: T } | { success: false; error: string }>
+    },
+  ): Promise<void> {
+    // Start the main process port to communicate with the renderer process.
+    // INFO: This is necessary to send messages back to the renderer process.
+    _mainProcessPort.start()
+
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Starting compilation process...' })
+    // INFO: We assume the first argument is the project path,
+    // INFO: the second argument is the board target, and the third argument is the project data.
+    const [projectPath, boardTarget, boardCore, compileOnly, projectData, runtimeIpAddress, runtimeJwtToken] = args as [
+      string,
+      string,
+      string | null,
+      boolean,
+      PLCProjectData,
+      string | null,
+      string | null,
+    ]
+
+    const boardRuntime = await this.#getBoardRuntime(boardTarget) // Get the board runtime from the hals.json file
+
+    const halsContent = await CompilerModule.readJSONFile<HalsFile>(this.halsFilePath)
+
+    const normalizedProjectPath = projectPath.replace('project.json', '')
+
+    const compilationPath = join(normalizedProjectPath, 'build', boardTarget) // Assuming the build folder is named 'build'
+
+    const sourceTargetFolderPath = join(compilationPath, 'src') // Assuming the source folder is named 'src'
+
+    let buildMD5Hash: string | null = null
+
+    // --- Print basic information ---
+    _mainProcessPort.postMessage({
+      logLevel: 'info',
+      message: `Compiling program for project: ${projectPath} and board target: ${boardTarget}`,
+    })
+    _mainProcessPort.postMessage({
+      logLevel: 'warning',
+      message: 'Host Hardware Info:',
+    })
+    _mainProcessPort.postMessage({
+      message: this.getHostHardwareInfo(),
+    })
+
+    // --- Check for unsupported features on non-v4 targets ---
+    const isRuntimeV4 = boardTarget === 'OpenPLC Runtime v4'
+    const hasServers = projectData.servers && projectData.servers.length > 0
+    const hasRemoteDevices = projectData.remoteDevices && projectData.remoteDevices.length > 0
+
+    if (!isRuntimeV4 && hasServers) {
+      _mainProcessPort.postMessage({
+        logLevel: 'warning',
+        message: `Warning: Your project contains Modbus Server configurations, but the selected target (${boardTarget}) does not support this feature. Modbus Server is only supported on OpenPLC Runtime v4. The server configurations will be ignored during compilation.`,
+      })
+    }
+
+    if (!isRuntimeV4 && hasRemoteDevices) {
+      _mainProcessPort.postMessage({
+        logLevel: 'warning',
+        message: `Warning: Your project contains Remote IO configurations, but the selected target (${boardTarget}) does not support this feature. Remote IO is only supported on OpenPLC Runtime v4. The remote device configurations will be ignored during compilation.`,
+      })
+    }
+
+    // --- Check tools availability ---
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Checking tools availability...' })
+
+    try {
+      const [arduinoCliCheckResult, iec2cCheckResult] = await Promise.all([
+        this.checkArduinoCliAvailability(),
+        this.checkIec2cAvailability(),
+      ])
+      _mainProcessPort.postMessage({
+        message: `Arduino CLI available at version ${arduinoCliCheckResult.data}\nIEC2C available at version ${iec2cCheckResult.data}`,
+      })
+    } catch (_error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        message: `${_error}\nStopping compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 1: Create basic directories
+    try {
+      await this.createBasicDirectories(normalizedProjectPath, boardTarget)
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: 'Directories for compilation source files created.',
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        message: `${error}\nStopping compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 2: Generate XML from JSON
+    let generateXMLResult: MethodsResult<{ xmlPath: string; xmlContent: string }> = { success: false }
+    try {
+      generateXMLResult = await this.handleGenerateXMLfromJSON(sourceTargetFolderPath, projectData)
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: `Generated XML from JSON at: ${generateXMLResult.data?.xmlPath as string}`,
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error generating XML from JSON: ${error as string}\nStopping compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 3: Transpile XML to ST
+    const generatedXMLFilePath = join(sourceTargetFolderPath, 'plc.xml') // Assuming the XML file is named 'plc.xml'
+    try {
+      await this.handleTranspileXMLtoST(generatedXMLFilePath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error transpiling XML to ST: ${error as string}\nStopping compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // -- Copy static files --
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Copying static files...' })
+    try {
+      await this.copyStaticFiles(compilationPath, boardRuntime)
+      _mainProcessPort.postMessage({ logLevel: 'info', message: 'Static files copied successfully.' })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error copying static files: ${error as string}\nStopping compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 4: Generate C code from ST
+    const generatedSTFilePath = join(sourceTargetFolderPath, 'program.st') // Assuming the ST file is named 'program.st'
+    try {
+      await this.handleTranspileSTtoC(generatedSTFilePath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 5: Generate debug files
+    try {
+      await this.handleGenerateDebugFiles(sourceTargetFolderPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    try {
+      const fs = await import('fs/promises')
+      const programStPath = join(sourceTargetFolderPath, 'program.st')
+      const programStContent = await fs.readFile(programStPath, 'utf-8')
+      const md5Pattern = /\(\*DBG:char md5\[\] = "([a-fA-F0-9]{32})";?\*\)/
+      const match = programStContent.match(md5Pattern)
+
+      if (match && match[1]) {
+        buildMD5Hash = match[1]
+        _mainProcessPort.postMessage({
+          logLevel: 'info',
+          message: `Extracted MD5 hash from program.st: ${buildMD5Hash}`,
+        })
+      } else {
+        _mainProcessPort.postMessage({
+          logLevel: 'warn',
+          message: 'Could not extract MD5 from program.st, continuing without MD5',
+        })
+        buildMD5Hash = null
+      }
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error extracting MD5 from program.st: ${error as string}`,
+      })
+      buildMD5Hash = null
+    }
+
+    // Step 6: Generate glue vars
+    try {
+      await this.handleGenerateGlueVars(sourceTargetFolderPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 7: Generate C/C++ blocks header file
+    try {
+      await this.handleGenerateCBlocksHeader(projectData, sourceTargetFolderPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 8: Generate C/C++ blocks code file
+    try {
+      await this.handleGenerateCBlocksCode(projectData, compilationPath, boardRuntime, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 9: Embed C/C++ blocks in program.st for Runtime v3
+    if (boardRuntime === 'openplc-compiler' && boardTarget === 'OpenPLC Runtime v3') {
+      try {
+        await this.embedCBlocksInProgramSt(sourceTargetFolderPath, (data, logLevel) => {
+          _mainProcessPort.postMessage({ logLevel, message: data })
+        })
+      } catch (error) {
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+        })
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: 'Stopping compilation process.',
+        })
+        _mainProcessPort.close()
+        return
+      }
+    }
+
+    // -- Verify if the runtime target is Arduino or OpenPLC --
+    // INFO: If the runtime target is Arduino, we will continue the compilation process.
+    // INFO: If the runtime target is OpenPLC we will finish the process here.
+    if (boardRuntime === 'openplc-compiler') {
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: 'OpenPLC runtime detected.',
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: 'Source files generated successfully at: ' + sourceTargetFolderPath,
+      })
+
+      if (compileOnly) {
+        _mainProcessPort.postMessage({
+          logLevel: 'info',
+          message: 'Compile only mode - skipping upload to runtime.',
+        })
+        _mainProcessPort.postMessage({
+          message:
+            '-------------------------------------------------------------------------------------------------------------\n',
+        })
+        _mainProcessPort.close()
+        return
+      }
+
+      if (!runtimeIpAddress || !runtimeJwtToken) {
+        _mainProcessPort.postMessage({
+          logLevel: 'warning',
+          message: 'Runtime not configured or not logged in. Skipping upload to runtime.',
+        })
+        _mainProcessPort.postMessage({
+          logLevel: 'info',
+          message: 'To upload the program, configure the runtime IP address and login in the device configuration.',
+        })
+        _mainProcessPort.postMessage({
+          message:
+            '-------------------------------------------------------------------------------------------------------------\n',
+        })
+        _mainProcessPort.close()
+        return
+      }
+
+      try {
+        const isRuntimeV3 = boardTarget === 'OpenPLC Runtime v3'
+
+        let fileBuffer: Buffer
+        let filename: string
+        let contentType: string
+
+        if (isRuntimeV3) {
+          _mainProcessPort.postMessage({
+            logLevel: 'info',
+            message: 'Preparing program.st file for OpenPLC Runtime v3...',
+          })
+          const programStPath = join(sourceTargetFolderPath, 'program.st')
+
+          try {
+            await fs.access(programStPath)
+          } catch {
+            throw new Error(`Required file not found: ${programStPath}. Cannot upload to OpenPLC Runtime v3.`)
+          }
+
+          fileBuffer = await fs.readFile(programStPath)
+          filename = 'program.st'
+          contentType = 'text/plain'
+        } else {
+          // Clean conf folder from previous compilations to avoid stale config files
+          await this.cleanConfFolder(sourceTargetFolderPath, (data, logLevel) => {
+            _mainProcessPort.postMessage({ logLevel, message: data })
+          })
+
+          // Generate Modbus Slave config for Runtime v4
+          await this.handleGenerateModbusSlaveConfig(sourceTargetFolderPath, projectData, (data, logLevel) => {
+            _mainProcessPort.postMessage({ logLevel, message: data })
+          })
+
+          // Generate Modbus Master config for Runtime v4
+          await this.handleGenerateModbusMasterConfig(sourceTargetFolderPath, projectData, (data, logLevel) => {
+            _mainProcessPort.postMessage({ logLevel, message: data })
+          })
+
+          // Generate S7Comm config for Runtime v4
+          await this.handleGenerateS7CommConfig(sourceTargetFolderPath, projectData, (data, logLevel) => {
+            _mainProcessPort.postMessage({ logLevel, message: data })
+          })
+
+          // Generate OPC-UA config for Runtime v4
+          await this.handleGenerateOpcUaConfig(sourceTargetFolderPath, projectData, (data, logLevel) => {
+            _mainProcessPort.postMessage({ logLevel, message: data })
+          })
+
+          _mainProcessPort.postMessage({
+            logLevel: 'info',
+            message: 'Compressing source files for OpenPLC Runtime v4...',
+          })
+          fileBuffer = await this.compressSourceFolder(sourceTargetFolderPath)
+          filename = 'program.zip'
+          contentType = 'application/zip'
+        }
+
+        _mainProcessPort.postMessage({
+          logLevel: 'info',
+          message: `Uploading program to runtime at ${runtimeIpAddress}...`,
+        })
+
+        const boundary = '----WebKitFormBoundary' + Math.random().toString(36).substring(2)
+
+        const header = Buffer.from(
+          `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="file"; filename="${filename}"\r\n` +
+            `Content-Type: ${contentType}\r\n\r\n`,
+        )
+        const footer = Buffer.from(`\r\n--${boundary}--\r\n`)
+        const body = Buffer.concat([header, fileBuffer, footer] as unknown as ReadonlyArray<Uint8Array>)
+
+        await new Promise<void>((resolve, reject) => {
+          const req = https.request(
+            {
+              hostname: runtimeIpAddress,
+              port: 8443,
+              path: '/api/upload-file',
+              method: 'POST',
+              headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': body.length,
+                Authorization: `Bearer ${runtimeJwtToken}`,
+              },
+              ...getRuntimeHttpsOptions(),
+            } as https.RequestOptions,
+            (res: IncomingMessage) => {
+              let data = ''
+              res.on('data', (chunk: Buffer) => {
+                data += chunk.toString()
+              })
+              res.on('end', () => {
+                if (res.statusCode === 200) {
+                  _mainProcessPort.postMessage({
+                    logLevel: 'info',
+                    message: 'Program uploaded successfully to runtime.',
+                  })
+                  try {
+                    const response = JSON.parse(data) as { CompilationStatus?: string }
+                    _mainProcessPort.postMessage({
+                      logLevel: 'info',
+                      message: `Runtime compilation started: ${response.CompilationStatus || 'COMPILING'}`,
+                    })
+                  } catch (_parseError) {
+                    _mainProcessPort.postMessage({
+                      logLevel: 'warning',
+                      message: 'Could not parse runtime response',
+                    })
+                  }
+
+                  const pollCompilationStatus = async () => {
+                    let lastLogCount = 0
+                    let shouldContinuePolling = true
+                    const startTime = Date.now()
+                    const timeout = CompilerModule.COMPILATION_STATUS_TIMEOUT_MS
+                    const pollInterval = CompilerModule.COMPILATION_STATUS_POLL_INTERVAL_MS
+
+                    while (shouldContinuePolling) {
+                      if (Date.now() - startTime > timeout) {
+                        _mainProcessPort.postMessage({
+                          logLevel: 'error',
+                          message: 'Compilation status polling timed out after 5 minutes.',
+                        })
+                        shouldContinuePolling = false
+                        continue
+                      }
+
+                      await new Promise((resolve) => setTimeout(resolve, pollInterval))
+
+                      try {
+                        const result = await mainProcessBridge.makeRuntimeApiRequest<{
+                          status: string
+                          logs: string[]
+                          exit_code: number | null
+                        }>(runtimeIpAddress, runtimeJwtToken, '/api/compilation-status', (data: string) => {
+                          return JSON.parse(data) as { status: string; logs: string[]; exit_code: number | null }
+                        })
+
+                        if (!result.success) {
+                          _mainProcessPort.postMessage({
+                            logLevel: 'error',
+                            message: `Error polling compilation status: ${result.error}`,
+                          })
+                          shouldContinuePolling = false
+                          continue
+                        }
+
+                        const { status, logs, exit_code } = result.data!
+
+                        if (logs.length > lastLogCount) {
+                          const newLogs = logs.slice(lastLogCount)
+                          newLogs.forEach((log) => {
+                            const { level, cleanedMessage } = this.parseLogLevel(log)
+                            _mainProcessPort.postMessage({
+                              logLevel: level,
+                              message: cleanedMessage,
+                            })
+                          })
+                          lastLogCount = logs.length
+                        }
+
+                        if (status === 'SUCCESS') {
+                          _mainProcessPort.postMessage({
+                            logLevel: 'info',
+                            message: `Compilation completed successfully (exit code: ${exit_code ?? 0}).`,
+                          })
+                          shouldContinuePolling = false
+                        } else if (status === 'FAILED') {
+                          _mainProcessPort.postMessage({
+                            logLevel: 'error',
+                            message: `Compilation failed (exit code: ${exit_code ?? 1}).`,
+                          })
+                          shouldContinuePolling = false
+                        }
+                      } catch (pollError) {
+                        _mainProcessPort.postMessage({
+                          logLevel: 'error',
+                          message: `Error polling compilation status: ${pollError instanceof Error ? pollError.message : String(pollError)}`,
+                        })
+                        shouldContinuePolling = false
+                      }
+                    }
+                  }
+
+                  pollCompilationStatus()
+                    .then(async () => {
+                      if (runtimeIpAddress && runtimeJwtToken) {
+                        try {
+                          const statusResult = await mainProcessBridge.makeRuntimeApiRequest<string>(
+                            runtimeIpAddress,
+                            runtimeJwtToken,
+                            '/api/status',
+                            (data: string) => {
+                              const response = JSON.parse(data) as { status: string }
+                              return response.status
+                            },
+                          )
+
+                          if (statusResult.success && statusResult.data) {
+                            const status = parsePlcStatus(statusResult.data)
+                            if (status) {
+                              _mainProcessPort.postMessage({
+                                plcStatus: status,
+                              })
+                            }
+                          }
+                        } catch (_statusError) {
+                          // Silently ignore status check errors - this is a best-effort update
+                        }
+                      }
+
+                      _mainProcessPort.postMessage({
+                        message:
+                          '-------------------------------------------------------------------------------------------------------------\n',
+                      })
+                      _mainProcessPort.close()
+                    })
+                    .catch((error) => {
+                      _mainProcessPort.postMessage({
+                        logLevel: 'error',
+                        message: `Unexpected error in compilation polling: ${getErrorMessage(error)}`,
+                      })
+                      _mainProcessPort.postMessage({
+                        message:
+                          '-------------------------------------------------------------------------------------------------------------\n',
+                      })
+                      _mainProcessPort.close()
+                    })
+
+                  resolve()
+                } else {
+                  _mainProcessPort.postMessage({
+                    logLevel: 'error',
+                    message: `Upload failed: ${data || 'HTTP ' + res.statusCode}`,
+                  })
+                  reject(new Error(`Upload failed with status ${res.statusCode}`))
+                }
+              })
+            },
+          )
+          req.setTimeout(300000, () => {
+            req.destroy()
+            _mainProcessPort.postMessage({
+              logLevel: 'error',
+              message: 'Upload request timed out after 5 minutes.',
+            })
+            reject(new Error('Upload timeout'))
+          })
+          req.on('error', (error: Error) => {
+            _mainProcessPort.postMessage({
+              logLevel: 'error',
+              message: `Upload error: ${error.message}`,
+            })
+            reject(error)
+          })
+          req.write(body)
+          req.end()
+        })
+      } catch (error) {
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: `Failed to upload to runtime: ${getErrorMessage(error)}`,
+        })
+        _mainProcessPort.postMessage({
+          message:
+            '-------------------------------------------------------------------------------------------------------------\n',
+        })
+        _mainProcessPort.close()
+      }
+      return
+    }
+
+    // Step 7: Handle patch files
+    try {
+      await this.handlePatchGeneratedFiles(compilationPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 8: Handle core installation
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Handling core installation...' })
+    try {
+      await this.handleCoreInstallation(boardCore, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+    // Step 9: Handle library installation
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Handling library installation...' })
+    try {
+      await this.handleLibraryInstallation((data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 10: Handle defines.h file generation
+    try {
+      if (buildMD5Hash === null) {
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: 'Build MD5 hash is null, cannot generate defines.h file.',
+        })
+        _mainProcessPort.close()
+        return
+      }
+      await this.handleGenerateDefinitionsFile({
+        projectPath: normalizedProjectPath,
+        boardTarget,
+        buildMD5Hash,
+        boardRuntime,
+        _handleOutputData: (data, logLevel) => {
+          _mainProcessPort.postMessage({ logLevel, message: data })
+        },
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+    }
+
+    // Step 11: Generate Arduino CPP file
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Generating Arduino CPP file...' })
+    try {
+      await this.handleGenerateArduinoCppFile(normalizedProjectPath, boardTarget)
+      _mainProcessPort.postMessage({ logLevel: 'info', message: 'Arduino CPP file generated successfully.' })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 12: Compile Arduino Program
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Compiling Arduino program...' })
+    try {
+      await this.handleCompileArduinoProgram({
+        boardTarget,
+        boardHalsContent: halsContent[boardTarget],
+        compilationPath,
+        handleOutputData: (data, logLevel) => {
+          _mainProcessPort.postMessage({ logLevel, message: data })
+        },
+      })
+      _mainProcessPort.postMessage({ logLevel: 'info', message: 'Arduino program compiled successfully.' })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Step 13: Upload program to board or load into simulator
+    if (boardRuntime === 'simulator') {
+      // For simulator targets, send the HEX firmware path back to the renderer.
+      // Derive the build sub-directory from the platform FQBN (e.g. "arduino:avr:mega" → "arduino.avr.mega")
+      // so it stays in sync with the hals.json entry.
+      const fqbnSubDir = halsContent[boardTarget]['platform'].replaceAll(':', '.')
+      const hexPath = join(compilationPath, 'examples', 'Baremetal', 'build', fqbnSubDir, 'Baremetal.ino.hex')
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: 'Compilation successful. Loading firmware into simulator...',
+      })
+      _mainProcessPort.postMessage({
+        simulatorFirmwarePath: hexPath,
+        closePort: true,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    if (!compileOnly) {
+      _mainProcessPort.postMessage({ logLevel: 'info', message: 'Uploading program to board...' })
+      try {
+        await this.handleUploadProgram({
+          projectPath: normalizedProjectPath,
+          arduinoPlatform: halsContent[boardTarget]['platform'],
+          compilationPath,
+          handleOutputData: (data, logLevel) => {
+            _mainProcessPort.postMessage({ logLevel, message: data })
+          },
+        })
+      } catch (error) {
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+        })
+        _mainProcessPort.close()
+        return
+      }
+    }
+
+    // -- Final message --
+    _mainProcessPort.postMessage({
+      message:
+        '-------------------------------------------------------------------------------------------------------------\n',
+    })
+
+    // INFO: This step is under development.
+    setTimeout(() => {
+      _mainProcessPort.close()
+    }, 25)
+  }
+
+  async compileForDebugger(
+    args: Array<string | null | PLCProjectData>,
+    _mainProcessPort: MessagePortMain,
+  ): Promise<void> {
+    _mainProcessPort.start()
+
+    _mainProcessPort.postMessage({ logLevel: 'info', message: 'Starting debug compilation process...' })
+
+    const [projectPath, boardTarget, projectData] = args as [string, string, PLCProjectData]
+
+    const boardRuntime = await this.#getBoardRuntime(boardTarget)
+    const normalizedProjectPath = projectPath.replace('project.json', '')
+    const compilationPath = join(normalizedProjectPath, 'build', boardTarget)
+    const sourceTargetFolderPath = join(compilationPath, 'src')
+
+    _mainProcessPort.postMessage({
+      logLevel: 'info',
+      message: `Compiling for debugger - project: ${projectPath}, board: ${boardTarget}`,
+    })
+
+    try {
+      const iec2cCheckResult = await this.checkIec2cAvailability()
+      _mainProcessPort.postMessage({
+        message: `IEC2C available at version ${iec2cCheckResult.data}`,
+      })
+    } catch (_error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `${String(_error)}\nStopping debug compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    try {
+      await this.createBasicDirectories(normalizedProjectPath, boardTarget)
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: 'Directories for compilation source files created.',
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `${getErrorMessage(error)}\nStopping debug compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    try {
+      const generateXMLResult = await this.handleGenerateXMLfromJSON(sourceTargetFolderPath, projectData)
+      _mainProcessPort.postMessage({
+        logLevel: 'info',
+        message: `Generated XML from JSON at: ${generateXMLResult.data?.xmlPath as string}`,
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error generating XML from JSON: ${error as string}\nStopping debug compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    const generatedXMLFilePath = join(sourceTargetFolderPath, 'plc.xml')
+    try {
+      await this.handleTranspileXMLtoST(generatedXMLFilePath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error transpiling XML to ST: ${error as string}\nStopping debug compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    try {
+      await this.copyStaticFiles(compilationPath, boardRuntime)
+      _mainProcessPort.postMessage({ logLevel: 'info', message: 'Static files copied successfully.' })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: `Error copying static files: ${error as string}\nStopping debug compilation process.`,
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    const generatedSTFilePath = join(sourceTargetFolderPath, 'program.st')
+    try {
+      await this.handleTranspileSTtoC(generatedSTFilePath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping debug compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    try {
+      await this.handleGenerateDebugFiles(sourceTargetFolderPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping debug compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    try {
+      await this.handleGenerateGlueVars(sourceTargetFolderPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping debug compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Generate C/C++ blocks header file
+    try {
+      await this.handleGenerateCBlocksHeader(projectData, sourceTargetFolderPath, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping debug compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    // Generate C/C++ blocks code file
+    try {
+      await this.handleGenerateCBlocksCode(projectData, compilationPath, boardRuntime, (data, logLevel) => {
+        _mainProcessPort.postMessage({ logLevel, message: data })
+      })
+    } catch (error) {
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error),
+      })
+      _mainProcessPort.postMessage({
+        logLevel: 'error',
+        message: 'Stopping debug compilation process.',
+      })
+      _mainProcessPort.close()
+      return
+    }
+
+    _mainProcessPort.postMessage({
+      logLevel: 'info',
+      message: 'Debug compilation completed successfully.',
+    })
+    _mainProcessPort.postMessage({
+      message:
+        '-------------------------------------------------------------------------------------------------------------\n',
+    })
+    setTimeout(() => {
+      _mainProcessPort.close()
+    }, 25)
+  }
+}
+export { CompilerModule }
diff --git a/src/main/modules/compiler/compiler-types.ts b/src/backend/editor/compiler/compiler-types.ts
similarity index 100%
rename from src/main/modules/compiler/compiler-types.ts
rename to src/backend/editor/compiler/compiler-types.ts
diff --git a/src/main/modules/compiler/index.ts b/src/backend/editor/compiler/index.ts
similarity index 100%
rename from src/main/modules/compiler/index.ts
rename to src/backend/editor/compiler/index.ts
diff --git a/src/main/modules/compiler/utils/formatters.ts b/src/backend/editor/compiler/utils/formatters.ts
similarity index 100%
rename from src/main/modules/compiler/utils/formatters.ts
rename to src/backend/editor/compiler/utils/formatters.ts
diff --git a/src/main/contracts/dtos/index.ts b/src/backend/editor/contracts/dtos/index.ts
similarity index 100%
rename from src/main/contracts/dtos/index.ts
rename to src/backend/editor/contracts/dtos/index.ts
diff --git a/src/main/contracts/dtos/services/base-response.dto.ts b/src/backend/editor/contracts/dtos/services/base-response.dto.ts
similarity index 100%
rename from src/main/contracts/dtos/services/base-response.dto.ts
rename to src/backend/editor/contracts/dtos/services/base-response.dto.ts
diff --git a/src/main/contracts/dtos/services/project/create-project.dto.ts b/src/backend/editor/contracts/dtos/services/project/create-project.dto.ts
similarity index 100%
rename from src/main/contracts/dtos/services/project/create-project.dto.ts
rename to src/backend/editor/contracts/dtos/services/project/create-project.dto.ts
diff --git a/src/main/contracts/dtos/services/project/open-project.dto.ts b/src/backend/editor/contracts/dtos/services/project/open-project.dto.ts
similarity index 100%
rename from src/main/contracts/dtos/services/project/open-project.dto.ts
rename to src/backend/editor/contracts/dtos/services/project/open-project.dto.ts
diff --git a/src/main/contracts/dtos/services/project/save-project.dto.ts b/src/backend/editor/contracts/dtos/services/project/save-project.dto.ts
similarity index 100%
rename from src/main/contracts/dtos/services/project/save-project.dto.ts
rename to src/backend/editor/contracts/dtos/services/project/save-project.dto.ts
diff --git a/src/main/contracts/dtos/theme.dto.ts b/src/backend/editor/contracts/dtos/theme.dto.ts
similarity index 100%
rename from src/main/contracts/dtos/theme.dto.ts
rename to src/backend/editor/contracts/dtos/theme.dto.ts
diff --git a/src/backend/editor/contracts/types/child-window.ts b/src/backend/editor/contracts/types/child-window.ts
new file mode 100644
index 000000000..990cc61d7
--- /dev/null
+++ b/src/backend/editor/contracts/types/child-window.ts
@@ -0,0 +1,43 @@
+import { z } from 'zod'
+
+import { CONSTANTS } from '../../../utils'
+
+const { paths } = CONSTANTS as { paths: Record<string, string> }
+
+export const ChildWindowSchema = z.object({
+  parentWindow: z.any().optional(),
+  path: z.string().refine((theme) => Object.values(paths).includes(theme)),
+  hideMenuBar: z.boolean().optional(),
+  width: z.number().optional(),
+  height: z.number().optional(),
+  x: z.number().optional(),
+  y: z.number().optional(),
+  center: z.boolean().optional(),
+  minWidth: z.number().optional(),
+  minHeight: z.number().optional(),
+  maxWidth: z.number().optional(),
+  maxHeight: z.number().optional(),
+  resizable: z.boolean().optional(),
+  movable: z.boolean().optional(),
+  minimizable: z.boolean().optional(),
+  maximizable: z.boolean().optional(),
+  closable: z.boolean().optional(),
+  focusable: z.boolean().optional(),
+  alwaysOnTop: z.boolean().optional(),
+  fullscreen: z.boolean().optional(),
+  fullscreenable: z.boolean().optional(),
+  simpleFullscreen: z.boolean().optional(),
+  skipTaskbar: z.boolean().optional(),
+  title: z.string().optional(),
+  frame: z.boolean().optional(),
+  modal: z.boolean().optional(),
+  autoHideMenuBar: z.boolean().optional(),
+  backgroundColor: z.string().optional(),
+  hasShadow: z.boolean().optional(),
+  opacity: z.number().optional(),
+  transparent: z.boolean().optional(),
+  type: z.string().optional(),
+  titleBarStyle: z.enum(['default', 'hidden', 'hiddenInset', 'customButtonsOnHover']).optional(),
+})
+
+export type ChildWindowProps = z.infer<typeof ChildWindowSchema>
diff --git a/src/backend/editor/contracts/types/modules/ipc/main.ts b/src/backend/editor/contracts/types/modules/ipc/main.ts
new file mode 100644
index 000000000..59e982ce4
--- /dev/null
+++ b/src/backend/editor/contracts/types/modules/ipc/main.ts
@@ -0,0 +1,30 @@
+import { BrowserWindow, IpcMain } from 'electron/main'
+
+import MenuBuilder from '../../../../../../main/menu'
+import { CompilerModule } from '../../../../compiler'
+import { HardwareModule } from '../../../../hardware'
+import { PouService, ProjectService } from '../../../../services'
+import { TStoreType } from '../store'
+
+export type MainIpcModule = {
+  ipcMain: IpcMain
+  mainWindow: InstanceType<typeof BrowserWindow> | null
+  projectService: InstanceType<typeof ProjectService>
+  store: TStoreType
+  setupMainIpcListener: () => void
+  mainIpcEventHandlers: {
+    handleUpdateTheme: () => void
+    createPou: () => void
+  }
+}
+
+export type MainIpcModuleConstructor = {
+  ipcMain: IpcMain
+  mainWindow: InstanceType<typeof BrowserWindow> | null
+  pouService: InstanceType<typeof PouService>
+  projectService: InstanceType<typeof ProjectService>
+  store: TStoreType
+  menuBuilder: InstanceType<typeof MenuBuilder>
+  compilerModule: InstanceType<typeof CompilerModule>
+  hardwareModule: InstanceType<typeof HardwareModule>
+}
diff --git a/src/main/contracts/types/modules/ipc/toast.ts b/src/backend/editor/contracts/types/modules/ipc/toast.ts
similarity index 100%
rename from src/main/contracts/types/modules/ipc/toast.ts
rename to src/backend/editor/contracts/types/modules/ipc/toast.ts
diff --git a/src/main/contracts/types/modules/store.ts b/src/backend/editor/contracts/types/modules/store.ts
similarity index 100%
rename from src/main/contracts/types/modules/store.ts
rename to src/backend/editor/contracts/types/modules/store.ts
diff --git a/src/main/contracts/types/services/project.service.d.ts b/src/backend/editor/contracts/types/services/project.service.d.ts
similarity index 100%
rename from src/main/contracts/types/services/project.service.d.ts
rename to src/backend/editor/contracts/types/services/project.service.d.ts
diff --git a/src/main/contracts/types/services/response.d.ts b/src/backend/editor/contracts/types/services/response.d.ts
similarity index 100%
rename from src/main/contracts/types/services/response.d.ts
rename to src/backend/editor/contracts/types/services/response.d.ts
diff --git a/src/main/contracts/types/theme.ts b/src/backend/editor/contracts/types/theme.ts
similarity index 100%
rename from src/main/contracts/types/theme.ts
rename to src/backend/editor/contracts/types/theme.ts
diff --git a/src/main/contracts/types/toast.ts b/src/backend/editor/contracts/types/toast.ts
similarity index 100%
rename from src/main/contracts/types/toast.ts
rename to src/backend/editor/contracts/types/toast.ts
diff --git a/src/main/contracts/validations/index.ts b/src/backend/editor/contracts/validations/index.ts
similarity index 100%
rename from src/main/contracts/validations/index.ts
rename to src/backend/editor/contracts/validations/index.ts
diff --git a/src/main/contracts/validations/store-validation.ts b/src/backend/editor/contracts/validations/store-validation.ts
similarity index 100%
rename from src/main/contracts/validations/store-validation.ts
rename to src/backend/editor/contracts/validations/store-validation.ts
diff --git a/src/backend/editor/contracts/validations/theme-validation.ts b/src/backend/editor/contracts/validations/theme-validation.ts
new file mode 100644
index 000000000..b1958ef23
--- /dev/null
+++ b/src/backend/editor/contracts/validations/theme-validation.ts
@@ -0,0 +1,11 @@
+import { z } from 'zod'
+
+import { CONSTANTS } from '../../../utils'
+
+const {
+  theme: { variants },
+} = CONSTANTS as { theme: { variants: Record<string, string> } }
+
+const ThemeSchema = z.string().refine((theme) => Object.values(variants).includes(theme))
+
+export default ThemeSchema
diff --git a/src/main/modules/hardware/hardware-module.ts b/src/backend/editor/hardware/hardware-module.ts
similarity index 100%
rename from src/main/modules/hardware/hardware-module.ts
rename to src/backend/editor/hardware/hardware-module.ts
diff --git a/src/main/modules/hardware/hardware-types.ts b/src/backend/editor/hardware/hardware-types.ts
similarity index 100%
rename from src/main/modules/hardware/hardware-types.ts
rename to src/backend/editor/hardware/hardware-types.ts
diff --git a/src/main/modules/hardware/index.ts b/src/backend/editor/hardware/index.ts
similarity index 100%
rename from src/main/modules/hardware/index.ts
rename to src/backend/editor/hardware/index.ts
diff --git a/src/backend/editor/modbus/modbus-client.ts b/src/backend/editor/modbus/modbus-client.ts
new file mode 100644
index 000000000..f794da4ae
--- /dev/null
+++ b/src/backend/editor/modbus/modbus-client.ts
@@ -0,0 +1,327 @@
+import { getErrorMessage } from '@root/utils/get-error-message'
+import { Socket } from 'net'
+
+export enum ModbusFunctionCode {
+  DEBUG_INFO = 0x41,
+  DEBUG_SET = 0x42,
+  DEBUG_GET = 0x43,
+  DEBUG_GET_LIST = 0x44,
+  DEBUG_GET_MD5 = 0x45,
+}
+
+export enum ModbusDebugResponse {
+  SUCCESS = 0x7e,
+  ERROR_OUT_OF_BOUNDS = 0x81,
+  ERROR_OUT_OF_MEMORY = 0x82,
+}
+
+interface ModbusTcpClientOptions {
+  host: string
+  port: number
+  timeout: number
+}
+
+export class ModbusTcpClient {
+  private host: string
+  private port: number
+  private timeout: number
+  private socket: Socket | null = null
+  private transactionId: number = 0
+  private sendRequestMutex: Promise<void> = Promise.resolve()
+
+  constructor(options: ModbusTcpClientOptions) {
+    this.host = options.host
+    this.port = options.port
+    this.timeout = options.timeout
+  }
+
+  private incrementTransactionId(): number {
+    this.transactionId = (this.transactionId + 1) % 65536
+    return this.transactionId
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.socket = new Socket()
+
+      const timeoutHandle = setTimeout(() => {
+        this.socket?.destroy()
+        reject(new Error('Connection timeout'))
+      }, this.timeout)
+
+      this.socket.connect(this.port, this.host, () => {
+        clearTimeout(timeoutHandle)
+        resolve()
+      })
+
+      this.socket.on('error', (error) => {
+        clearTimeout(timeoutHandle)
+        reject(error)
+      })
+    })
+  }
+
+  disconnect(): void {
+    if (this.socket) {
+      this.socket.destroy()
+      this.socket = null
+    }
+  }
+
+  private sendTcpRequestImpl(request: Buffer): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error('Not connected to target'))
+        return
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        this.socket?.removeListener('data', onData)
+        this.socket?.removeListener('error', onError)
+        reject(new Error('Request timeout'))
+      }, this.timeout)
+
+      const onData = (data: Buffer) => {
+        clearTimeout(timeoutHandle)
+        this.socket?.removeListener('data', onData)
+        this.socket?.removeListener('error', onError)
+        resolve(data)
+      }
+
+      const onError = (error: Error) => {
+        clearTimeout(timeoutHandle)
+        this.socket?.removeListener('data', onData)
+        this.socket?.removeListener('error', onError)
+        reject(error)
+      }
+
+      this.socket.once('data', onData)
+      this.socket.once('error', onError)
+      this.socket.write(request as unknown as Uint8Array)
+    })
+  }
+
+  private sendTcpRequest(request: Buffer): Promise<Buffer> {
+    return new Promise<Buffer>((resolve, reject) => {
+      this.sendRequestMutex = this.sendRequestMutex.then(
+        () => this.sendTcpRequestImpl(request).then(resolve, reject),
+        () => this.sendTcpRequestImpl(request).then(resolve, reject),
+      )
+    })
+  }
+
+  async getMd5Hash(): Promise<string> {
+    if (!this.socket) {
+      throw new Error('Not connected to target')
+    }
+
+    const transactionId = this.incrementTransactionId()
+    const protocolId = 0x0000
+    const unitId = 0x00
+    const functionCode = ModbusFunctionCode.DEBUG_GET_MD5
+    const endiannessCheck = 0xdead
+
+    const request = Buffer.alloc(12)
+    request.writeUInt16BE(transactionId, 0)
+    request.writeUInt16BE(protocolId, 2)
+    request.writeUInt16BE(6, 4)
+    request.writeUInt8(unitId, 6)
+    request.writeUInt8(functionCode, 7)
+    request.writeUInt16BE(endiannessCheck, 8)
+    request.writeUInt8(0, 10)
+    request.writeUInt8(0, 11)
+
+    const data = await this.sendTcpRequest(request)
+
+    if (data.length < 9) {
+      throw new Error('Invalid response: too short')
+    }
+
+    const responseTransactionId = data.readUInt16BE(0)
+    const responseFunctionCode = data.readUInt8(7)
+    const statusCode = data.readUInt8(8)
+
+    if (responseTransactionId !== transactionId) {
+      throw new Error('Transaction ID mismatch')
+    }
+
+    if (responseFunctionCode !== (ModbusFunctionCode.DEBUG_GET_MD5 as number)) {
+      throw new Error('Function code mismatch')
+    }
+
+    if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+      throw new Error(`Target returned error code: 0x${statusCode.toString(16)}`)
+    }
+
+    const md5String = data.slice(9).toString('utf-8').trim()
+    return md5String
+  }
+
+  async getVariablesList(variableIndexes: number[]): Promise<{
+    success: boolean
+    tick?: number
+    lastIndex?: number
+    data?: Buffer
+    error?: string
+  }> {
+    if (!this.socket) {
+      return { success: false, error: 'Not connected to target' }
+    }
+
+    const transactionId = this.incrementTransactionId()
+    const protocolId = 0x0000
+    const unitId = 0x00
+    const functionCode = ModbusFunctionCode.DEBUG_GET_LIST
+    const numIndexes = variableIndexes.length
+
+    const pduLength = 4 + 2 * numIndexes
+    const request = Buffer.alloc(6 + pduLength)
+
+    request.writeUInt16BE(transactionId, 0)
+    request.writeUInt16BE(protocolId, 2)
+    request.writeUInt16BE(pduLength, 4)
+    request.writeUInt8(unitId, 6)
+    request.writeUInt8(functionCode, 7)
+    request.writeUInt16BE(numIndexes, 8)
+
+    for (let i = 0; i < numIndexes; i++) {
+      request.writeUInt16BE(variableIndexes[i], 10 + i * 2)
+    }
+
+    try {
+      const data = await this.sendTcpRequest(request)
+
+      if (data.length < 9) {
+        return { success: false, error: `Invalid response: too short (${data.length} bytes, need at least 9)` }
+      }
+
+      const responseTransactionId = data.readUInt16BE(0)
+      const responseFunctionCode = data.readUInt8(7)
+      const statusCode = data.readUInt8(8)
+
+      if (responseTransactionId !== transactionId) {
+        return { success: false, error: 'Transaction ID mismatch' }
+      }
+
+      if (responseFunctionCode !== (ModbusFunctionCode.DEBUG_GET_LIST as number)) {
+        return { success: false, error: 'Function code mismatch' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_BOUNDS' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_MEMORY' }
+      }
+
+      if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+        return { success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` }
+      }
+
+      if (data.length < 17) {
+        return {
+          success: false,
+          error: `Incomplete success response (${data.length} bytes, expected at least 17)`,
+        }
+      }
+
+      const lastIndex = data.readUInt16BE(9)
+      const tick = data.readUInt32BE(11)
+      const responseSize = data.readUInt16BE(15)
+
+      if (data.length < 17 + responseSize) {
+        return {
+          success: false,
+          error: `Incomplete variable data (expected ${responseSize} bytes, got ${data.length - 17})`,
+        }
+      }
+
+      const variableData = data.slice(17, 17 + responseSize)
+
+      return {
+        success: true,
+        tick,
+        lastIndex,
+        data: variableData,
+      }
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) }
+    }
+  }
+
+  async setVariable(
+    variableIndex: number,
+    force: boolean,
+    valueBuffer?: Buffer,
+  ): Promise<{
+    success: boolean
+    error?: string
+  }> {
+    if (!this.socket) {
+      return { success: false, error: 'Not connected to target' }
+    }
+
+    const transactionId = this.incrementTransactionId()
+    const protocolId = 0x0000
+    const unitId = 0x00
+    const functionCode = ModbusFunctionCode.DEBUG_SET
+
+    const dataLength = force && valueBuffer ? valueBuffer.length : 1
+    const pduLength = 7 + dataLength
+    const request = Buffer.alloc(6 + pduLength)
+
+    request.writeUInt16BE(transactionId, 0)
+    request.writeUInt16BE(protocolId, 2)
+    request.writeUInt16BE(pduLength, 4)
+    request.writeUInt8(unitId, 6)
+    request.writeUInt8(functionCode, 7)
+    request.writeUInt16BE(variableIndex, 8)
+    request.writeUInt8(force ? 1 : 0, 10)
+    request.writeUInt16BE(dataLength, 11)
+
+    if (force && valueBuffer) {
+      for (let i = 0; i < valueBuffer.length; i++) {
+        request.writeUInt8(valueBuffer[i], 13 + i)
+      }
+    } else {
+      request.writeUInt8(0, 13)
+    }
+
+    try {
+      const data = await this.sendTcpRequest(request)
+
+      if (data.length < 9) {
+        return { success: false, error: `Invalid response: too short (${data.length} bytes, need at least 9)` }
+      }
+
+      const responseTransactionId = data.readUInt16BE(0)
+      const responseFunctionCode = data.readUInt8(7)
+      const statusCode = data.readUInt8(8)
+
+      if (responseTransactionId !== transactionId) {
+        return { success: false, error: 'Transaction ID mismatch' }
+      }
+
+      if (responseFunctionCode !== (ModbusFunctionCode.DEBUG_SET as number)) {
+        return { success: false, error: 'Function code mismatch' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_BOUNDS' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_MEMORY' }
+      }
+
+      if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+        return { success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` }
+      }
+
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) }
+    }
+  }
+}
diff --git a/src/backend/editor/modbus/modbus-rtu-client.ts b/src/backend/editor/modbus/modbus-rtu-client.ts
new file mode 100644
index 000000000..f419af835
--- /dev/null
+++ b/src/backend/editor/modbus/modbus-rtu-client.ts
@@ -0,0 +1,433 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - serialport types are not available at build time but will be at runtime
+import { getErrorMessage } from '@root/utils/get-error-message'
+import { SerialPort } from 'serialport'
+
+import { ModbusDebugResponse, ModbusFunctionCode } from './modbus-client'
+
+interface ModbusRtuClientOptions {
+  port: string
+  baudRate: number
+  slaveId: number
+  timeout: number
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  serialPort?: any // Pre-built serial port (e.g. VirtualSerialPort for simulator)
+}
+
+const ARDUINO_BOOTLOADER_DELAY_MS = 2500
+const MD5_REQUEST_MAX_RETRIES = 3
+const MD5_REQUEST_RETRY_DELAY_MS = 500
+
+const FRAME_COMPLETE_TIMEOUT_MS = 10
+
+export class ModbusRtuClient {
+  private port: string
+  private baudRate: number
+  private slaveId: number
+  private timeout: number
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private serialPort: any = null
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private injectedSerialPort: any = null
+
+  private static readonly CRC_HI_TABLE = [
+    0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80,
+    0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1,
+    0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01,
+    0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40,
+    0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81,
+    0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
+    0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00,
+    0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+    0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80,
+    0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
+    0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01,
+    0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+    0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80,
+    0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+  ]
+
+  private static readonly CRC_LO_TABLE = [
+    0x00, 0xc0, 0xc1, 0x01, 0xc3, 0x03, 0x02, 0xc2, 0xc6, 0x06, 0x07, 0xc7, 0x05, 0xc5, 0xc4, 0x04, 0xcc, 0x0c, 0x0d,
+    0xcd, 0x0f, 0xcf, 0xce, 0x0e, 0x0a, 0xca, 0xcb, 0x0b, 0xc9, 0x09, 0x08, 0xc8, 0xd8, 0x18, 0x19, 0xd9, 0x1b, 0xdb,
+    0xda, 0x1a, 0x1e, 0xde, 0xdf, 0x1f, 0xdd, 0x1d, 0x1c, 0xdc, 0x14, 0xd4, 0xd5, 0x15, 0xd7, 0x17, 0x16, 0xd6, 0xd2,
+    0x12, 0x13, 0xd3, 0x11, 0xd1, 0xd0, 0x10, 0xf0, 0x30, 0x31, 0xf1, 0x33, 0xf3, 0xf2, 0x32, 0x36, 0xf6, 0xf7, 0x37,
+    0xf5, 0x35, 0x34, 0xf4, 0x3c, 0xfc, 0xfd, 0x3d, 0xff, 0x3f, 0x3e, 0xfe, 0xfa, 0x3a, 0x3b, 0xfb, 0x39, 0xf9, 0xf8,
+    0x38, 0x28, 0xe8, 0xe9, 0x29, 0xeb, 0x2b, 0x2a, 0xea, 0xee, 0x2e, 0x2f, 0xef, 0x2d, 0xed, 0xec, 0x2c, 0xe4, 0x24,
+    0x25, 0xe5, 0x27, 0xe7, 0xe6, 0x26, 0x22, 0xe2, 0xe3, 0x23, 0xe1, 0x21, 0x20, 0xe0, 0xa0, 0x60, 0x61, 0xa1, 0x63,
+    0xa3, 0xa2, 0x62, 0x66, 0xa6, 0xa7, 0x67, 0xa5, 0x65, 0x64, 0xa4, 0x6c, 0xac, 0xad, 0x6d, 0xaf, 0x6f, 0x6e, 0xae,
+    0xaa, 0x6a, 0x6b, 0xab, 0x69, 0xa9, 0xa8, 0x68, 0x78, 0xb8, 0xb9, 0x79, 0xbb, 0x7b, 0x7a, 0xba, 0xbe, 0x7e, 0x7f,
+    0xbf, 0x7d, 0xbd, 0xbc, 0x7c, 0xb4, 0x74, 0x75, 0xb5, 0x77, 0xb7, 0xb6, 0x76, 0x72, 0xb2, 0xb3, 0x73, 0xb1, 0x71,
+    0x70, 0xb0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9c,
+    0x5c, 0x5d, 0x9d, 0x5f, 0x9f, 0x9e, 0x5e, 0x5a, 0x9a, 0x9b, 0x5b, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
+    0x4b, 0x8b, 0x8a, 0x4a, 0x4e, 0x8e, 0x8f, 0x4f, 0x8d, 0x4d, 0x4c, 0x8c, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46,
+    0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40,
+  ]
+
+  constructor(options: ModbusRtuClientOptions) {
+    this.port = options.port
+    this.baudRate = options.baudRate
+    this.slaveId = options.slaveId
+    this.timeout = options.timeout
+    this.injectedSerialPort = options.serialPort ?? null
+  }
+
+  private calculateCrc(buffer: Buffer): number {
+    let crcHi = 0xff
+    let crcLo = 0xff
+
+    for (let i = 0; i < buffer.length; i++) {
+      const index = crcHi ^ buffer[i]
+      crcHi = crcLo ^ ModbusRtuClient.CRC_HI_TABLE[index]
+      crcLo = ModbusRtuClient.CRC_LO_TABLE[index]
+    }
+
+    return (crcHi << 8) | crcLo
+  }
+
+  private assembleRequest(functionCode: number, data: Buffer): Buffer {
+    const frameWithoutCrc = Buffer.alloc(2 + data.length)
+    frameWithoutCrc.writeUInt8(this.slaveId, 0)
+    frameWithoutCrc.writeUInt8(functionCode, 1)
+    data.copy(frameWithoutCrc as unknown as Uint8Array, 2)
+
+    const crc = this.calculateCrc(frameWithoutCrc)
+    const request = Buffer.alloc(frameWithoutCrc.length + 2)
+    frameWithoutCrc.copy(request as unknown as Uint8Array, 0)
+    request.writeUInt16BE(crc, frameWithoutCrc.length)
+
+    return request
+  }
+
+  async connect(): Promise<void> {
+    // If a pre-built serial port was provided (e.g. VirtualSerialPort), use it directly
+    if (this.injectedSerialPort) {
+      this.serialPort = this.injectedSerialPort
+      return new Promise((resolve, reject) => {
+        this.serialPort.on('open', () => resolve())
+        this.serialPort.on('error', (err: Error) => reject(err))
+        this.serialPort.open()
+      })
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        this.serialPort = new SerialPort({
+          path: this.port,
+          baudRate: this.baudRate,
+          dataBits: 8,
+          stopBits: 1,
+          parity: 'none',
+        })
+
+        this.serialPort.on('open', () => {
+          setTimeout(() => {
+            resolve()
+          }, ARDUINO_BOOTLOADER_DELAY_MS)
+        })
+
+        this.serialPort.on('error', (error: unknown) => {
+          reject(error instanceof Error ? error : new Error(getErrorMessage(error) as string))
+        })
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(getErrorMessage(error) as string))
+      }
+    })
+  }
+
+  disconnect(): void {
+    if (this.serialPort && this.serialPort.isOpen) {
+      this.serialPort.close()
+      this.serialPort = null
+    }
+  }
+
+  private flushInputBuffer(): Promise<void> {
+    return new Promise((resolve) => {
+      if (!this.serialPort || !this.serialPort.isOpen) {
+        resolve()
+        return
+      }
+
+      this.serialPort.flush((err: Error | null) => {
+        if (err) {
+          console.warn('Warning: Failed to flush serial port:', err.message)
+        }
+        resolve()
+      })
+    })
+  }
+
+  private sendRequestMutex: Promise<void> = Promise.resolve()
+
+  private async sendRequest(request: Buffer): Promise<Buffer> {
+    return new Promise<Buffer>((resolve, reject) => {
+      this.sendRequestMutex = this.sendRequestMutex.then(
+        () => this.sendRequestImpl(request).then(resolve, reject),
+        () => this.sendRequestImpl(request).then(resolve, reject),
+      )
+    })
+  }
+
+  private async sendRequestImpl(request: Buffer): Promise<Buffer> {
+    if (!this.serialPort || !this.serialPort.isOpen) {
+      throw new Error('Serial port is not open')
+    }
+
+    await this.flushInputBuffer()
+
+    return new Promise((resolve, reject) => {
+      let responseBuffer = Buffer.alloc(0)
+      let frameCompleteTimeout: NodeJS.Timeout | null = null
+
+      // Forward-declared so the timeout handler can reference them for cleanup
+      const cleanup = () => {
+        this.serialPort?.removeListener('data', onData)
+        this.serialPort?.removeListener('error', onError)
+        if (frameCompleteTimeout) {
+          clearTimeout(frameCompleteTimeout)
+        }
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        cleanup()
+        reject(new Error('Request timeout'))
+      }, this.timeout)
+
+      const onData = (data: Buffer) => {
+        responseBuffer = Buffer.concat([responseBuffer, data] as unknown as Uint8Array[])
+
+        if (frameCompleteTimeout) {
+          clearTimeout(frameCompleteTimeout)
+        }
+
+        frameCompleteTimeout = setTimeout(() => {
+          clearTimeout(timeoutHandle)
+          cleanup()
+
+          if (responseBuffer.length < 5) {
+            reject(new Error('Response too short'))
+            return
+          }
+
+          const receivedCrc = responseBuffer.readUInt16BE(responseBuffer.length - 2)
+          const calculatedCrc = this.calculateCrc(responseBuffer.slice(0, responseBuffer.length - 2))
+
+          if (receivedCrc !== calculatedCrc) {
+            // OpenPLC debugger ignores CRC errors — mismatch is non-fatal
+          }
+
+          const responseWithoutCrc = responseBuffer.slice(0, responseBuffer.length - 2)
+          const paddedResponse = Buffer.alloc(6 + responseWithoutCrc.length)
+          paddedResponse.fill(0, 0, 6)
+          responseWithoutCrc.copy(paddedResponse as unknown as Uint8Array, 6)
+
+          resolve(paddedResponse)
+        }, FRAME_COMPLETE_TIMEOUT_MS)
+      }
+
+      const onError = (error: Error) => {
+        clearTimeout(timeoutHandle)
+        cleanup()
+        reject(error)
+      }
+
+      this.serialPort!.on('data', onData)
+      this.serialPort!.once('error', onError)
+      this.serialPort!.write(request as unknown as Uint8Array, (error: unknown) => {
+        if (error) {
+          clearTimeout(timeoutHandle)
+          cleanup()
+          const errorMessage =
+            typeof error === 'string'
+              ? error
+              : typeof error === 'object' && error !== null
+                ? JSON.stringify(error)
+                : 'Unknown error'
+          reject(error instanceof Error ? error : new Error(errorMessage))
+        }
+      })
+    })
+  }
+
+  async getMd5Hash(): Promise<string> {
+    const functionCode = ModbusFunctionCode.DEBUG_GET_MD5
+    const endiannessCheck = 0xdead
+
+    const data = Buffer.alloc(4)
+    data.writeUInt16BE(endiannessCheck, 0)
+    data.writeUInt8(0, 2)
+    data.writeUInt8(0, 3)
+
+    const request = this.assembleRequest(functionCode, data)
+
+    let lastError: Error | null = null
+    for (let attempt = 0; attempt <= MD5_REQUEST_MAX_RETRIES; attempt++) {
+      try {
+        if (attempt > 0) {
+          await new Promise((resolve) => setTimeout(resolve, MD5_REQUEST_RETRY_DELAY_MS))
+        }
+
+        const response = await this.sendRequest(request)
+
+        if (response.length < 9) {
+          throw new Error('Invalid response: too short')
+        }
+
+        const functionCodeResponse = response.readUInt8(7)
+        const statusCode = response.readUInt8(8)
+
+        if (functionCodeResponse !== (ModbusFunctionCode.DEBUG_GET_MD5 as number)) {
+          throw new Error('Function code mismatch')
+        }
+
+        if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+          throw new Error(`Target returned error code: 0x${statusCode.toString(16)}`)
+        }
+
+        const md5String = response.slice(9).toString('utf-8').trim()
+        return md5String
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(getErrorMessage(error) as string)
+        if (attempt < MD5_REQUEST_MAX_RETRIES) {
+          console.warn(`MD5 request attempt ${attempt + 1} failed: ${lastError.message}. Retrying...`)
+        }
+      }
+    }
+
+    throw Object.assign(new Error('Failed to get MD5 hash after retries'), { cause: lastError })
+  }
+
+  async getVariablesList(variableIndexes: number[]): Promise<{
+    success: boolean
+    tick?: number
+    lastIndex?: number
+    data?: Buffer
+    error?: string
+  }> {
+    try {
+      const functionCode = ModbusFunctionCode.DEBUG_GET_LIST
+      const numIndexes = variableIndexes.length
+
+      const data = Buffer.alloc(2 + 2 * numIndexes)
+      data.writeUInt16BE(numIndexes, 0)
+
+      for (let i = 0; i < numIndexes; i++) {
+        data.writeUInt16BE(variableIndexes[i], 2 + i * 2)
+      }
+
+      const request = this.assembleRequest(functionCode, data)
+      const response = await this.sendRequest(request)
+
+      if (response.length < 9) {
+        return { success: false, error: `Invalid response: too short (${response.length} bytes, need at least 9)` }
+      }
+
+      const functionCodeResponse = response.readUInt8(7)
+      const statusCode = response.readUInt8(8)
+
+      if (functionCodeResponse !== (ModbusFunctionCode.DEBUG_GET_LIST as number)) {
+        return { success: false, error: 'Function code mismatch' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_BOUNDS' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_MEMORY' }
+      }
+
+      if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+        return { success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` }
+      }
+
+      if (response.length < 17) {
+        return {
+          success: false,
+          error: `Incomplete success response (${response.length} bytes, expected at least 17)`,
+        }
+      }
+
+      const lastIndex = response.readUInt16BE(9)
+      const tick = response.readUInt32BE(11)
+      const responseSize = response.readUInt16BE(15)
+
+      if (response.length < 17 + responseSize) {
+        return {
+          success: false,
+          error: `Incomplete variable data (expected ${responseSize} bytes, got ${response.length - 17})`,
+        }
+      }
+
+      const variableData = response.slice(17, 17 + responseSize)
+
+      return {
+        success: true,
+        tick,
+        lastIndex,
+        data: variableData,
+      }
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) }
+    }
+  }
+
+  async setVariable(
+    variableIndex: number,
+    force: boolean,
+    valueBuffer?: Buffer,
+  ): Promise<{
+    success: boolean
+    error?: string
+  }> {
+    try {
+      const functionCode = ModbusFunctionCode.DEBUG_SET
+
+      const dataLength = force && valueBuffer ? valueBuffer.length : 1
+      const data = Buffer.alloc(5 + dataLength)
+
+      data.writeUInt16BE(variableIndex, 0)
+      data.writeUInt8(force ? 1 : 0, 2)
+      data.writeUInt16BE(dataLength, 3)
+
+      if (force && valueBuffer) {
+        for (let i = 0; i < valueBuffer.length; i++) {
+          data.writeUInt8(valueBuffer[i], 5 + i)
+        }
+      } else {
+        data.writeUInt8(0, 5)
+      }
+
+      const request = this.assembleRequest(functionCode, data)
+      const response = await this.sendRequest(request)
+
+      if (response.length < 9) {
+        return { success: false, error: `Invalid response: too short (${response.length} bytes, need at least 9)` }
+      }
+
+      const functionCodeResponse = response.readUInt8(7)
+      const statusCode = response.readUInt8(8)
+
+      if (functionCodeResponse !== (ModbusFunctionCode.DEBUG_SET as number)) {
+        return { success: false, error: 'Function code mismatch' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_BOUNDS' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_MEMORY' }
+      }
+
+      if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+        return { success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` }
+      }
+
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) }
+    }
+  }
+}
diff --git a/src/main/services/__tests__/user-service.test.ts b/src/backend/editor/services/__tests__/user-service.test.ts
similarity index 100%
rename from src/main/services/__tests__/user-service.test.ts
rename to src/backend/editor/services/__tests__/user-service.test.ts
diff --git a/src/main/services/index.ts b/src/backend/editor/services/index.ts
similarity index 100%
rename from src/main/services/index.ts
rename to src/backend/editor/services/index.ts
diff --git a/src/main/services/logger-service/index.ts b/src/backend/editor/services/logger-service/index.ts
similarity index 100%
rename from src/main/services/logger-service/index.ts
rename to src/backend/editor/services/logger-service/index.ts
diff --git a/src/backend/editor/services/pou-service/index.ts b/src/backend/editor/services/pou-service/index.ts
new file mode 100644
index 000000000..5aa5a17da
--- /dev/null
+++ b/src/backend/editor/services/pou-service/index.ts
@@ -0,0 +1,159 @@
+import { CreatePouFileProps, PouServiceResponse } from '@root/types/IPC/pou-service'
+import { PLCPou } from '@root/types/PLC/open-plc'
+import { getExtensionFromLanguage } from '@root/utils/PLC/pou-file-extensions'
+import { serializePouToText } from '@root/utils/PLC/pou-text-serializer'
+import { promises } from 'fs'
+import { basename, dirname, join } from 'path'
+
+import { ipcPouToFlat } from '../../utils'
+import { UserService } from '../user-service'
+
+class PouService {
+  constructor() {}
+
+  async createPouFile(props: CreatePouFileProps): Promise<PouServiceResponse> {
+    const { pou } = props
+    const flat = ipcPouToFlat(pou)
+    const extension = getExtensionFromLanguage(flat.body.language)
+    const filePath = join(dirname(props.path), `${flat.name}${extension}`)
+
+    try {
+      await promises.access(filePath)
+      return {
+        success: false,
+        error: {
+          title: 'POU Create Error',
+          description: 'A file with the target name already exists',
+          error: new Error('EEXIST'),
+        },
+      }
+    } catch {
+      // File does not exist, proceed with creation
+      // If the file does not exist, we can create it
+      // No action needed here, just continue
+    }
+
+    try {
+      await UserService.createDirectoryIfNotExists(dirname(filePath))
+      const textContent: string = serializePouToText(flat)
+      await promises.writeFile(filePath, textContent, 'utf-8')
+
+      return { success: true, data: { pou } }
+    } catch (error) {
+      console.error('Error creating POU file:', error)
+      return { success: false, error: { title: 'POU Creation Error', description: 'Failed to create POU file', error } }
+    }
+  }
+
+  async deletePouFile(filePath: string): Promise<PouServiceResponse> {
+    try {
+      await UserService.deleteFile(filePath)
+    } catch (error) {
+      console.error('Error deleting POU file:', error)
+      return { success: false, error: { title: 'POU Deletion Error', description: 'Failed to delete POU file', error } }
+    }
+    return { success: true }
+  }
+
+  async renamePouFile(data: {
+    filePath: string
+    newFileName: string
+    fileContent?: unknown
+  }): Promise<PouServiceResponse> {
+    const { filePath, newFileName, fileContent } = data
+    const safeNewFileName = basename(newFileName)
+    if (!safeNewFileName || safeNewFileName === '.' || safeNewFileName === '..') {
+      return {
+        success: false,
+        error: {
+          title: 'POU Rename Error',
+          description: 'Invalid target file name',
+          error: new Error('EINVAL'),
+        },
+      }
+    }
+
+    // Determine actual file paths by converting .json virtual paths to real language extensions
+    let actualOldFilePath = filePath
+    let actualNewFilePath = join(dirname(filePath), safeNewFileName)
+
+    const isPou =
+      typeof fileContent === 'object' && fileContent !== null && 'type' in fileContent && 'data' in fileContent
+
+    if (isPou) {
+      const flat = ipcPouToFlat(fileContent as PLCPou)
+      const extension: string = getExtensionFromLanguage(flat.body.language)
+
+      // Convert .json paths to actual language extension paths
+      if (filePath.endsWith('.json')) {
+        actualOldFilePath = filePath.replace(/\.json$/, extension)
+      }
+      if (safeNewFileName.endsWith('.json')) {
+        const newFileNameWithExtension = safeNewFileName.replace(/\.json$/, extension)
+        actualNewFilePath = join(dirname(filePath), newFileNameWithExtension)
+      }
+    }
+
+    try {
+      await promises.access(actualNewFilePath)
+      return {
+        success: false,
+        error: {
+          title: 'POU Rename Error',
+          description: 'A file with the target name already exists',
+          error: new Error('EEXIST'),
+        },
+      }
+    } catch {
+      // File does not exist, proceed with renaming
+      // No action needed here, just continue
+    }
+
+    if (fileContent && isPou) {
+      try {
+        const flat = ipcPouToFlat(fileContent as PLCPou)
+        const textContent: string = serializePouToText(flat)
+        await promises.writeFile(actualOldFilePath, textContent, 'utf-8')
+      } catch (writeError) {
+        console.error(`Error writing content before rename: ${String(writeError)}`)
+        return {
+          success: false,
+          error: {
+            title: 'File Write Error',
+            description: 'Failed to update content before rename',
+            error: writeError as Error,
+          },
+        }
+      }
+    } else if (fileContent) {
+      try {
+        await promises.writeFile(actualOldFilePath, JSON.stringify(fileContent, null, 2))
+      } catch (writeError) {
+        console.error(`Error writing content before rename: ${String(writeError)}`)
+        return {
+          success: false,
+          error: {
+            title: 'File Write Error',
+            description: 'Failed to update content before rename',
+            error: writeError as Error,
+          },
+        }
+      }
+    }
+
+    try {
+      const result = await UserService.renameFile(actualOldFilePath, actualNewFilePath)
+      if (!result.success) {
+        console.error('Error renaming POU file:', result.error)
+        return { success: false, error: result.error }
+      }
+    } catch (error) {
+      console.error('Error renaming POU file:', error)
+      return { success: false, error: { title: 'POU Rename Error', description: 'Failed to rename POU file', error } }
+    }
+
+    return { success: true, data: { filePath: actualNewFilePath } }
+  }
+}
+
+export { PouService }
diff --git a/src/main/services/project-service/data/index.ts b/src/backend/editor/services/project-service/data/index.ts
similarity index 100%
rename from src/main/services/project-service/data/index.ts
rename to src/backend/editor/services/project-service/data/index.ts
diff --git a/src/main/services/project-service/data/xml-file.ts b/src/backend/editor/services/project-service/data/xml-file.ts
similarity index 100%
rename from src/main/services/project-service/data/xml-file.ts
rename to src/backend/editor/services/project-service/data/xml-file.ts
diff --git a/src/backend/editor/services/project-service/index.ts b/src/backend/editor/services/project-service/index.ts
new file mode 100644
index 000000000..4660d5391
--- /dev/null
+++ b/src/backend/editor/services/project-service/index.ts
@@ -0,0 +1,489 @@
+import {
+  CreateProjectFileProps,
+  IProjectRecentHistoryEntry,
+  IProjectServiceResponse,
+} from '@root/types/IPC/project-service'
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { getExtensionFromLanguage } from '@root/utils/PLC/pou-file-extensions'
+import { serializePouToText } from '@root/utils/PLC/pou-text-serializer'
+import { app, BrowserWindow, dialog } from 'electron'
+import { promises } from 'fs'
+import { dirname, join, normalize } from 'path'
+
+import { PLCPou, PLCProject, PLCRemoteDevice, PLCServer } from '../../../types/PLC/open-plc'
+import { fileOrDirectoryExists, ipcPouToFlat } from '../../utils'
+import { createProjectDefaultStructure, readProjectFiles } from './utils'
+
+class ProjectService {
+  constructor(private serviceManager: InstanceType<typeof BrowserWindow>) {}
+
+  public getHistoryProjectsFilePath(): string {
+    const pathToUserDataFolder = join(app.getPath('userData'), 'User')
+    const pathToUserHistoryFolder = join(pathToUserDataFolder, 'History')
+
+    return join(pathToUserHistoryFolder, 'projects.json')
+  }
+
+  async getProjectName(projectPath: string): Promise<string> {
+    try {
+      const projectFile = await promises.readFile(projectPath, 'utf-8')
+      return ((JSON.parse(projectFile) as PLCProject).meta.name as string) || 'Unknown project'
+    } catch {
+      console.error('Error reading project file', projectPath)
+      return 'Unknown project'
+    }
+  }
+
+  async createProject(data: CreateProjectFileProps): Promise<IProjectServiceResponse> {
+    const projectDefaultDirectoriesResponse = createProjectDefaultStructure(data.path, data)
+    if (!projectDefaultDirectoriesResponse.success || !projectDefaultDirectoriesResponse.data) {
+      return {
+        success: false,
+        error: projectDefaultDirectoriesResponse.error,
+      }
+    }
+    await this.updateProjectHistory(data.path)
+    return {
+      success: true,
+      data: {
+        meta: {
+          path: data.path, // Use the directory path instead of projectPath
+        },
+        content: projectDefaultDirectoriesResponse.data.content,
+      },
+    }
+  }
+
+  async readProjectHistory(historyProjectsFilePath: string): Promise<IProjectRecentHistoryEntry[]> {
+    try {
+      const historyContent = await promises.readFile(historyProjectsFilePath, 'utf-8')
+      const content = (JSON.parse(historyContent) as IProjectRecentHistoryEntry[]) || []
+      return content.map((entry) => ({
+        ...entry,
+        path: normalize(entry.path).endsWith('/project.json')
+          ? normalize(entry.path).slice(0, -'/project.json'.length)
+          : normalize(entry.path),
+        projectFilePath: entry.projectFilePath
+          ? normalize(entry.projectFilePath).endsWith('/project.json')
+            ? normalize(entry.projectFilePath).slice(0, -'/project.json'.length)
+            : normalize(entry.projectFilePath)
+          : '',
+      }))
+    } catch (error) {
+      console.error('Error reading history file:', error)
+      return []
+    }
+  }
+
+  private async writeProjectHistory(
+    projectsFilePath: string,
+    historyData: IProjectRecentHistoryEntry[],
+  ): Promise<void> {
+    await promises.writeFile(projectsFilePath, JSON.stringify(historyData, null, 2))
+  }
+
+  async updateProjectHistory(projectPath: string): Promise<void> {
+    const historyProjectsFilePath = this.getHistoryProjectsFilePath()
+
+    const directoryPath = projectPath.endsWith('/project.json')
+      ? projectPath.slice(0, -'/project.json'.length)
+      : projectPath
+    const projectFilePath = projectPath.endsWith('/project.json') ? projectPath : join(projectPath, 'project.json')
+
+    const projectName = await this.getProjectName(projectFilePath)
+    const historyData = await this.readProjectHistory(historyProjectsFilePath)
+    const lastOpenedAt = new Date().toISOString()
+
+    const existingProjectIndex = historyData.findIndex((proj) => proj.path === directoryPath)
+    if (existingProjectIndex > -1) {
+      historyData[existingProjectIndex].name = projectName
+      historyData[existingProjectIndex].path = directoryPath
+      historyData[existingProjectIndex].projectFilePath = projectFilePath
+      historyData[existingProjectIndex].lastOpenedAt = lastOpenedAt
+    } else {
+      historyData.push({
+        name: projectName,
+        path: directoryPath,
+        projectFilePath: projectFilePath,
+        createdAt: lastOpenedAt,
+        lastOpenedAt,
+      })
+    }
+
+    historyData.sort((a, b) => new Date(b.lastOpenedAt).getTime() - new Date(a.lastOpenedAt).getTime())
+    await this.writeProjectHistory(historyProjectsFilePath, historyData)
+  }
+
+  async removeProjectFromHistory(projectPath: string): Promise<void> {
+    const historyProjectsFilePath = this.getHistoryProjectsFilePath()
+    const historyData = await this.readProjectHistory(historyProjectsFilePath)
+    const updatedHistory = historyData.filter((project) => project.path !== projectPath)
+    await this.writeProjectHistory(historyProjectsFilePath, updatedHistory)
+  }
+
+  async openProjectByPath(projectPath: string): Promise<IProjectServiceResponse> {
+    try {
+      await promises.access(projectPath)
+      const projectFiles = await readProjectFiles(projectPath)
+
+      if (!projectFiles.success || !projectFiles.data) {
+        console.error(`Error opening project at path: ${projectPath}`, projectFiles.error)
+        await this.removeProjectFromHistory(projectPath)
+
+        return {
+          success: false,
+          error: {
+            title: 'Failed to read project',
+            description: 'Could not read the project. Please check the project directory.',
+            error: projectFiles.error,
+          },
+        }
+      }
+
+      await this.updateProjectHistory(projectPath)
+
+      return {
+        success: true,
+        data: {
+          meta: {
+            path: projectPath,
+          },
+          content: projectFiles.data,
+        },
+      }
+    } catch (error) {
+      console.error(`Error opening project at path: ${projectPath}`, error)
+      await this.removeProjectFromHistory(projectPath)
+
+      return {
+        success: false,
+        error: {
+          title: 'Failed to read project',
+          description: 'Could not read the project. Please check the project directory.',
+          error: error,
+        },
+      }
+    }
+  }
+
+  async openProject(): Promise<IProjectServiceResponse> {
+    const { canceled, filePaths } = await dialog.showOpenDialog(this.serviceManager, {
+      title: 'Select a PLC project to open',
+      properties: ['openDirectory'],
+    })
+
+    if (canceled) {
+      return {
+        success: false,
+        error: {
+          title: 'Operation canceled',
+          description: 'Operation canceled by the user.',
+          error: null,
+        },
+      }
+    }
+
+    const [directoryPath] = filePaths
+
+    try {
+      await promises.access(directoryPath)
+      const projectFiles = await readProjectFiles(directoryPath)
+
+      if (!projectFiles.success || !projectFiles.data) {
+        console.error(`Error opening project at path: ${directoryPath}`, projectFiles.error)
+        await this.removeProjectFromHistory(directoryPath)
+
+        return {
+          success: false,
+          error: {
+            title: 'Failed to read project',
+            description: 'Could not read the project. Please check the project directory.',
+            error: projectFiles.error,
+          },
+        }
+      }
+
+      await this.updateProjectHistory(directoryPath)
+
+      return {
+        success: true,
+        data: {
+          meta: {
+            path: directoryPath,
+          },
+          content: projectFiles.data,
+        },
+      }
+    } catch (error) {
+      console.error(`Error accessing project directory: ${filePaths[0]}`, error)
+      await this.removeProjectFromHistory(directoryPath)
+
+      return {
+        success: false,
+        error: {
+          title: 'Failed to read project',
+          description: 'Could not read the project. Please check the project directory.',
+          error: error,
+        },
+      }
+    }
+  }
+
+  async saveProject(data: {
+    projectPath: string
+    content: {
+      projectData: PLCProject
+      pous: PLCPou[]
+      deviceConfiguration: DeviceConfiguration
+      devicePinMapping: DevicePin[]
+      servers?: PLCServer[]
+      remoteDevices?: PLCRemoteDevice[]
+    }
+  }): Promise<IProjectServiceResponse> {
+    const {
+      projectPath,
+      content: { deviceConfiguration, devicePinMapping, projectData, servers, remoteDevices },
+    } = data
+    if (!projectPath || !projectData) {
+      return {
+        success: false,
+        error: {
+          title: 'Missing parameters',
+          description: 'Missing parameters',
+          error: null,
+        },
+      }
+    }
+
+    const directoryPath = projectPath.endsWith('/project.json')
+      ? projectPath.slice(0, -'/project.json'.length)
+      : projectPath
+
+    try {
+      // Write each part to its correct file based on projectDefaultFilesMapSchema
+      await Promise.all([
+        promises.writeFile(join(directoryPath, 'project.json'), JSON.stringify(projectData, null, 2)),
+        promises.writeFile(
+          join(directoryPath, 'devices/configuration.json'),
+          JSON.stringify(deviceConfiguration, null, 2),
+        ),
+        promises.writeFile(join(directoryPath, 'devices/pin-mapping.json'), JSON.stringify(devicePinMapping, null, 2)),
+      ])
+    } catch (error) {
+      console.error(error)
+      return {
+        success: false,
+        error: {
+          title: 'Failed to save file',
+          description: 'Unable to save the project file.',
+          error,
+        },
+      }
+    }
+
+    // Save pous
+    try {
+      const savedPous = {
+        programs: data.content.pous.filter((pou) => pou.type === 'program'),
+        functions: data.content.pous.filter((pou) => pou.type === 'function'),
+        'function-blocks': data.content.pous.filter((pou) => pou.type === 'function-block'),
+      }
+
+      // Save each POU in its respective folder
+      for (const [type, pous] of Object.entries(savedPous)) {
+        const dir = join(directoryPath, 'pous', type)
+
+        if (!fileOrDirectoryExists(dir)) {
+          await promises.mkdir(dir, { recursive: true })
+        }
+
+        // Write/update each POU file
+        for (const pou of pous) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          const flat = ipcPouToFlat(pou)
+          const extension: string = getExtensionFromLanguage(flat.body.language)
+          const filePath = join(dir, `${flat.name}${extension}`)
+          const textContent: string = serializePouToText(flat)
+          await promises.writeFile(filePath, textContent, 'utf-8')
+        }
+      }
+
+      if (projectData.data.deletedPous && projectData.data.deletedPous.length > 0) {
+        for (const deletedPou of projectData.data.deletedPous) {
+          const typeDir =
+            deletedPou.type === 'function'
+              ? 'functions'
+              : deletedPou.type === 'function-block'
+                ? 'function-blocks'
+                : 'programs'
+          const extension = getExtensionFromLanguage(deletedPou.language)
+          const filePath = join(directoryPath, 'pous', typeDir, `${deletedPou.name}${extension}`)
+
+          try {
+            if (fileOrDirectoryExists(filePath)) {
+              await promises.unlink(filePath)
+            }
+          } catch (deleteError) {
+            console.error(`Error deleting POU file ${filePath}:`, deleteError)
+          }
+
+          const jsonFilePath = join(directoryPath, 'pous', typeDir, `${deletedPou.name}.json`)
+          try {
+            if (fileOrDirectoryExists(jsonFilePath)) {
+              await promises.unlink(jsonFilePath)
+            }
+          } catch (deleteError) {
+            console.error(`Error deleting legacy JSON POU file ${jsonFilePath}:`, deleteError)
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error saving POUs:', error)
+      return {
+        success: false,
+        error: {
+          title: 'Failed to save file',
+          description: 'Unable to save the project file.',
+          error,
+        },
+      }
+    }
+
+    // Save servers
+    if (
+      (servers && servers.length > 0) ||
+      (projectData.data.deletedServers && projectData.data.deletedServers.length > 0)
+    ) {
+      try {
+        const serversDir = join(directoryPath, 'devices', 'servers')
+        if (!fileOrDirectoryExists(serversDir)) {
+          await promises.mkdir(serversDir, { recursive: true })
+        }
+
+        if (servers && servers.length > 0) {
+          for (const server of servers) {
+            const serverFilePath = join(serversDir, `${server.name}.json`)
+            await promises.writeFile(serverFilePath, JSON.stringify(server, null, 2), 'utf-8')
+          }
+        }
+
+        // Handle deleted servers
+        if (projectData.data.deletedServers && projectData.data.deletedServers.length > 0) {
+          for (const deletedServer of projectData.data.deletedServers) {
+            const serverFilePath = join(serversDir, `${deletedServer.name}.json`)
+            try {
+              if (fileOrDirectoryExists(serverFilePath)) {
+                await promises.unlink(serverFilePath)
+              }
+            } catch (deleteError) {
+              console.error(`Error deleting server file ${serverFilePath}:`, deleteError)
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Error saving servers:', error)
+        return {
+          success: false,
+          error: {
+            title: 'Failed to save file',
+            description: 'Unable to save the project file.',
+            error,
+          },
+        }
+      }
+    }
+
+    // Save remote devices
+    if (
+      (remoteDevices && remoteDevices.length > 0) ||
+      (projectData.data.deletedRemoteDevices && projectData.data.deletedRemoteDevices.length > 0)
+    ) {
+      try {
+        const remoteDevicesDir = join(directoryPath, 'devices', 'remote')
+        if (!fileOrDirectoryExists(remoteDevicesDir)) {
+          await promises.mkdir(remoteDevicesDir, { recursive: true })
+        }
+
+        if (remoteDevices && remoteDevices.length > 0) {
+          for (const remoteDevice of remoteDevices) {
+            const remoteDeviceFilePath = join(remoteDevicesDir, `${remoteDevice.name}.json`)
+            await promises.writeFile(remoteDeviceFilePath, JSON.stringify(remoteDevice, null, 2), 'utf-8')
+          }
+        }
+
+        // Handle deleted remote devices
+        if (projectData.data.deletedRemoteDevices && projectData.data.deletedRemoteDevices.length > 0) {
+          for (const deletedRemoteDevice of projectData.data.deletedRemoteDevices) {
+            const remoteDeviceFilePath = join(remoteDevicesDir, `${deletedRemoteDevice.name}.json`)
+            try {
+              if (fileOrDirectoryExists(remoteDeviceFilePath)) {
+                await promises.unlink(remoteDeviceFilePath)
+              }
+            } catch (deleteError) {
+              console.error(`Error deleting remote device file ${remoteDeviceFilePath}:`, deleteError)
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Error saving remote devices:', error)
+        return {
+          success: false,
+          error: {
+            title: 'Failed to save file',
+            description: 'Unable to save the project file.',
+            error,
+          },
+        }
+      }
+    }
+
+    return {
+      success: true,
+      message: 'Your project was saved successfully',
+    }
+  }
+
+  async saveFile(filePath: string, content: unknown): Promise<IProjectServiceResponse> {
+    try {
+      if (!fileOrDirectoryExists(filePath)) {
+        const dir = dirname(filePath)
+        await promises.mkdir(dir, { recursive: true })
+      }
+
+      const isPou = typeof content === 'object' && content !== null && 'type' in content && 'data' in content
+
+      if (isPou) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const flat = ipcPouToFlat(content as PLCPou)
+
+        let actualFilePath = filePath
+        if (filePath.endsWith('.json')) {
+          const extension: string = getExtensionFromLanguage(flat.body.language)
+          actualFilePath = filePath.replace(/\.json$/, extension)
+        }
+
+        const textContent: string = serializePouToText(flat)
+        await promises.writeFile(actualFilePath, textContent, 'utf-8')
+      } else {
+        await promises.writeFile(filePath, JSON.stringify(content, null, 2))
+      }
+
+      return {
+        success: true,
+        message: 'Your project was saved successfully',
+      }
+    } catch (error) {
+      console.error('Error saving file:', error)
+      return {
+        success: false,
+        error: {
+          title: 'Failed to save file',
+          description: 'Unable to save the project file.',
+          error,
+        },
+      }
+    }
+  }
+}
+
+export { ProjectService }
diff --git a/src/backend/editor/services/project-service/utils/create-project.ts b/src/backend/editor/services/project-service/utils/create-project.ts
new file mode 100644
index 000000000..753378852
--- /dev/null
+++ b/src/backend/editor/services/project-service/utils/create-project.ts
@@ -0,0 +1,245 @@
+import {
+  CreateProjectDefaultDirectoriesResponse,
+  CreateProjectFileProps,
+  projectDefaultDirectories,
+  projectDefaultFilesMapSchema,
+} from '@root/types/IPC/project-service'
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { PLCPou, PLCProject } from '@root/types/PLC/open-plc'
+import { getDefaultSchemaValues } from '@root/utils/default-zod-schema-values'
+import { getExtensionFromLanguage } from '@root/utils/PLC/pou-file-extensions'
+import { serializePouToText } from '@root/utils/PLC/pou-text-serializer'
+import { writeFileSync } from 'fs'
+
+import { createDirectory, fileOrDirectoryExists, ipcPouToFlat } from '../../../utils'
+import { CreateJSONFile } from '../../../utils'
+
+const definePou = (language: CreateProjectFileProps['language']): PLCPou => ({
+  type: 'program',
+  data: {
+    name: 'main',
+    language: language,
+    variables: [],
+    documentation: '',
+    body: (() => {
+      switch (language) {
+        case 'ld':
+          return { language, value: { name: 'main', rungs: [] } }
+        case 'fbd':
+          return {
+            language,
+            value: {
+              name: 'main',
+              rung: {
+                comment: '',
+                edges: [],
+                nodes: [],
+              },
+            },
+          }
+        default:
+          return { language, value: '' }
+      }
+    })(),
+  },
+})
+
+const createProjectFile = (dataToCreateProjectFile: CreateProjectFileProps): PLCProject => ({
+  meta: {
+    name: dataToCreateProjectFile.name,
+    type: dataToCreateProjectFile.type,
+  },
+  data: {
+    pous: [],
+    dataTypes: [],
+    configuration: {
+      resource: {
+        tasks: [
+          {
+            name: 'task0',
+            triggering: 'Cyclic',
+            interval: dataToCreateProjectFile.time,
+            priority: 1,
+          },
+        ],
+        instances: [
+          {
+            name: 'instance0',
+            program: 'main',
+            task: 'task0',
+          },
+        ],
+        globalVariables: [],
+      },
+    },
+  },
+})
+
+const createProjectDefaultStructure = (
+  basePath: string,
+  dataToCreateProjectFile: CreateProjectFileProps,
+): CreateProjectDefaultDirectoriesResponse => {
+  const content: {
+    project: PLCProject | null
+    pous: PLCPou[]
+    deviceConfiguration: DeviceConfiguration | null
+    devicePinMapping: DevicePin[]
+  } = {
+    project: null,
+    pous: [],
+    deviceConfiguration: null,
+    devicePinMapping: [],
+  }
+
+  /**
+   * Create the default directories in the project structure
+   */
+
+  // Create all the default directories if they do not exist
+  const directories = projectDefaultDirectories
+  for (const directory of directories) {
+    const dirPath = `${basePath}/${directory}`
+    try {
+      if (!fileOrDirectoryExists(dirPath)) createDirectory(dirPath)
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          title: 'Error creating project directories',
+          description: `Failed to create directory at ${dirPath}`,
+          error: error,
+        },
+      }
+    }
+  }
+
+  /**
+   * Create the default files in the project structure
+   */
+
+  // Create the root files
+  // These are files that are not in a subdirectory, but directly in the project root
+  // For example: project.json
+  const rootFiles = Object.entries(projectDefaultFilesMapSchema).filter(
+    ([file]) => !file.includes('/') && file.includes('.'),
+  )
+  for (const [file, _schema] of rootFiles) {
+    const filePath = basePath
+
+    switch (file) {
+      case 'project.json':
+        content.project = createProjectFile(dataToCreateProjectFile)
+        try {
+          CreateJSONFile(filePath, JSON.stringify(content.project, null, 2), file.split('.')[0])
+        } catch (error) {
+          return {
+            success: false,
+            error: {
+              title: 'Error creating project file',
+              description: `Failed to create project file at ${filePath}`,
+              error: error,
+            },
+          }
+        }
+        break
+      default:
+        break
+    }
+  }
+
+  // Create the directories and files that are in subdirectories
+  // For example: devices/configuration.json
+  const fileDirectories = Object.entries(projectDefaultFilesMapSchema).filter(
+    ([file]) => file.includes('/') && file.includes('.'),
+  )
+  for (const [file, schema] of fileDirectories) {
+    const [directory, fileName] = file.split('/')
+    const filePath = `${basePath}/${directory}`
+    const defaultValue = getDefaultSchemaValues(schema)
+
+    try {
+      switch (file) {
+        case 'devices/configuration.json':
+          content.deviceConfiguration = defaultValue as DeviceConfiguration
+          content.deviceConfiguration.communicationConfiguration.modbusRTU.rtuBaudRate = '115200'
+          try {
+            CreateJSONFile(filePath, JSON.stringify(content.deviceConfiguration, null, 2), fileName.split('.')[0])
+          } catch (error) {
+            return {
+              success: false,
+              error: {
+                title: 'Error creating device configuration file',
+                description: `Failed to create device configuration file at ${filePath}`,
+                error: error,
+              },
+            }
+          }
+          break
+        case 'devices/pin-mapping.json':
+          content.devicePinMapping = defaultValue as DevicePin[]
+          try {
+            CreateJSONFile(filePath, JSON.stringify(content.devicePinMapping, null, 2), fileName.split('.')[0])
+          } catch (error) {
+            return {
+              success: false,
+              error: {
+                title: 'Error creating device pin mapping file',
+                description: `Failed to create device pin mapping file at ${filePath}`,
+                error: error,
+              },
+            }
+          }
+          break
+        default:
+          break
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          title: 'Error creating project directories',
+          description: `Failed to create directory or file at ${filePath}`,
+          error: error,
+        },
+      }
+    }
+  }
+
+  const pou = definePou(dataToCreateProjectFile.language)
+  const pouPath = `${basePath}/pous/${pou.type}s`
+
+  try {
+    if (!fileOrDirectoryExists(pouPath)) createDirectory(pouPath)
+    const flat = ipcPouToFlat(pou)
+    const extension: string = getExtensionFromLanguage(flat.body.language)
+    const textContent: string = serializePouToText(flat)
+    const filePath = `${pouPath}/${flat.name}${extension}`
+    writeFileSync(filePath, textContent, 'utf-8')
+  } catch (error) {
+    return {
+      success: false,
+      error: {
+        title: 'Error creating POU file',
+        description: `Failed to create POU file at ${pouPath}`,
+        error: error,
+      },
+    }
+  }
+
+  content.pous.push(pou)
+
+  return {
+    success: true,
+    data: {
+      meta: { path: basePath },
+      content: content as {
+        project: PLCProject
+        pous: PLCPou[]
+        deviceConfiguration: DeviceConfiguration
+        devicePinMapping: DevicePin[]
+      },
+    },
+  }
+}
+
+export { createProjectDefaultStructure, createProjectFile }
diff --git a/src/main/services/project-service/utils/index.ts b/src/backend/editor/services/project-service/utils/index.ts
similarity index 100%
rename from src/main/services/project-service/utils/index.ts
rename to src/backend/editor/services/project-service/utils/index.ts
diff --git a/src/backend/editor/services/project-service/utils/read-project.ts b/src/backend/editor/services/project-service/utils/read-project.ts
new file mode 100644
index 000000000..ac9676d08
--- /dev/null
+++ b/src/backend/editor/services/project-service/utils/read-project.ts
@@ -0,0 +1,680 @@
+import { projectDefaultFilesMapSchema, projectPouDirectories } from '@root/types/IPC/project-service'
+import { IProjectServiceReadFilesResponse } from '@root/types/IPC/project-service/read-project'
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import {
+  PLCPou,
+  PLCPouSchema,
+  PLCProject,
+  PLCRemoteDevice,
+  PLCRemoteDeviceSchema,
+  PLCServer,
+  PLCServerSchema,
+} from '@root/types/PLC/open-plc'
+import { getDefaultSchemaValues } from '@root/utils/default-zod-schema-values'
+import { migrateProjectToNameTypeSystem, needsMigration } from '@root/utils/migrate-project-to-name-type-system'
+import { getExtensionFromLanguage } from '@root/utils/PLC/pou-file-extensions'
+import {
+  detectLanguageFromExtension,
+  parseGraphicalPouFromString,
+  parseHybridPouFromString,
+  parseTextualPouFromString,
+} from '@root/utils/PLC/pou-text-parser'
+import { serializePouToText } from '@root/utils/PLC/pou-text-serializer'
+import { promises, readdirSync, readFileSync, writeFileSync } from 'fs'
+import { basename, dirname, extname, join, sep } from 'path'
+import { ZodTypeAny } from 'zod'
+
+import { createDirectory, fileOrDirectoryExists, ipcPouToFlat } from '../../../utils'
+
+/**
+ * Checks if the given directory is a valid project directory according to the expected structure.
+ *
+ * This function verifies that the directory exists, contains only allowed files and directories,
+ * and includes a required project file (`project.json`). It returns an object indicating whether
+ * the directory is valid, and provides error details if not.
+ *
+ * @param basePath - The absolute path to the directory to check.
+ * @returns An object with a `success` boolean and, if unsuccessful, an `error` object containing
+ *          a title, description, and the underlying error.
+ *
+ * @remarks
+ * The validation logic in the for loop is a work in progress (WIP). In the future, only
+ * `projectDefaultFilesMapSchema` will be used for validation.
+ */
+function checkIfDirectoryIsAValidProjectDirectory(basePath: string): {
+  success: boolean
+  error?: { title: string; description: string; error: Error }
+} {
+  // Check if the base path exists and is a directory
+  if (!fileOrDirectoryExists(basePath)) {
+    return {
+      success: false,
+      error: {
+        title: 'Directory not found',
+        description: 'The selected directory does not exist.',
+        error: new Error('Directory does not exist'),
+      },
+    }
+  }
+
+  const entries = readdirSync(basePath, { withFileTypes: true, recursive: false })
+  let hasProjectFile = false
+
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name === 'project.json') {
+      hasProjectFile = true
+      break
+    }
+  }
+
+  return {
+    success: hasProjectFile,
+    error: hasProjectFile
+      ? undefined
+      : {
+          title: 'Invalid project',
+          description: 'The selected directory is not a valid OpenPLC project.',
+          error: new Error('project.json not found in directory'),
+        },
+  }
+}
+
+function safeParseProjectFile<K extends Extract<keyof typeof projectDefaultFilesMapSchema, string>>(
+  fileName: K,
+  data: unknown,
+  schema?: ZodTypeAny,
+) {
+  if (!(fileName in projectDefaultFilesMapSchema) && !schema) {
+    throw new Error(`File ${fileName} is not a valid project file or schema is not provided.`)
+  }
+
+  const fileSchema = projectDefaultFilesMapSchema[fileName] ?? schema
+  const result = fileSchema.safeParse(data)
+
+  /**
+   * TODO: Handle the case where the file does not match the expected schema
+   * This could be due to a corrupted file or an unsupported version.
+   * For now, we throw an error, but in the future, we might want to
+   * handle this more gracefully, perhaps by returning a default value or
+   * logging a warning instead of throwing an error.
+   */
+  if (!result.success) {
+    throw new Error(`Failed to parse ${fileName}: ${result.error.message}`)
+  }
+
+  return result.data
+}
+
+function readAndParseFile(filePath: string, fileName: string, schema: ZodTypeAny) {
+  let file: string | undefined
+  // File does not exist, create with default value from schema
+  if (!fileOrDirectoryExists(filePath)) {
+    const dir = dirname(filePath)
+
+    // Ensure the directory exists
+    if (!fileOrDirectoryExists(dir)) {
+      createDirectory(dir)
+    }
+
+    // Create the file with default values from the schema
+    const defaultValue = getDefaultSchemaValues(schema)
+    writeFileSync(filePath, JSON.stringify(defaultValue, null, 2), 'utf-8')
+    file = JSON.stringify(defaultValue)
+  }
+
+  // File exists, read and parse
+  else {
+    file = readFileSync(filePath, 'utf-8')
+
+    // If the file is empty, create it with default values
+    if (!file) {
+      const defaultValue = getDefaultSchemaValues(schema)
+      writeFileSync(filePath, JSON.stringify(defaultValue, null, 2), 'utf-8')
+      file = JSON.stringify(defaultValue)
+    }
+  }
+  return safeParseProjectFile(fileName as keyof typeof projectDefaultFilesMapSchema, JSON.parse(file), schema)
+}
+
+/**
+ * Valid POU file extensions (text-based and JSON for backward compatibility)
+ */
+const VALID_POU_EXTENSIONS = ['.st', '.il', '.ld', '.fbd', '.py', '.cpp', '.json']
+
+/**
+ * Helper function to detect POU type from the file path
+ * @param filePath - The file path containing the POU type directory
+ * @returns The POU type (program, function, function-block)
+ * @throws Error if POU type cannot be determined
+ */
+function detectPouTypeFromPath(filePath: string): string {
+  const normalizedPath = filePath.split(sep).join('/')
+
+  if (normalizedPath.includes('/programs/')) {
+    return 'program'
+  } else if (normalizedPath.includes('/function-blocks/')) {
+    return 'function-block'
+  } else if (normalizedPath.includes('/functions/')) {
+    return 'function'
+  }
+  throw new Error(`Cannot determine POU type from path: ${filePath}`)
+}
+
+/**
+ * Helper function to find the last END_VAR in the content
+ * @param content - The content to search
+ * @param startIndex - The index to start searching from
+ * @returns The index after the last END_VAR, or -1 if not found
+ */
+function findLastEndVarIndex(content: string, startIndex: number): number {
+  let lastEndVarIndex = -1
+  const regex = /\bEND_VAR\b/gi
+  regex.lastIndex = startIndex
+
+  let match: RegExpExecArray | null
+  while ((match = regex.exec(content)) !== null) {
+    lastEndVarIndex = match.index + match[0].length
+  }
+
+  return lastEndVarIndex
+}
+
+/**
+ * Fallback extraction when parsing fails - extracts raw variables block and body
+ * @param content - The file content
+ * @param language - The language code
+ * @param pouType - The POU type
+ * @param pouName - The POU name (from filename)
+ * @returns A partial PLCPou with empty variables array but preserved variablesText
+ */
+function createFallbackPou(content: string, language: string, pouType: string, pouName: string): PLCPou {
+  const docMatch = content.match(/^\s*\(\*\s*(.*?)\s*\*\)\s*\n/s)
+  const documentation = docMatch ? docMatch[1].trim() : ''
+  const remainingContent = docMatch ? content.slice(docMatch[0].length) : content
+
+  const varStartIndex = remainingContent.search(
+    /\b(VAR_INPUT|VAR_OUTPUT|VAR_IN_OUT|VAR_EXTERNAL|VAR_TEMP|VAR_GLOBAL|VAR)\b/i,
+  )
+
+  let variablesText = 'VAR\nEND_VAR' // Default if no variables section found
+  let bodyStartIndex = 0
+
+  const pouTypeKeywords = {
+    program: 'PROGRAM',
+    function: 'FUNCTION',
+    'function-block': 'FUNCTION_BLOCK',
+  }
+  const typeKeyword = pouTypeKeywords[pouType as keyof typeof pouTypeKeywords]
+  const declarationRegex = new RegExp(`^\\s*(${typeKeyword})\\s+(\\w+)(?:\\s*:\\s*(\\w+))?`, 'i')
+  const declarationMatch = remainingContent.match(declarationRegex)
+
+  if (declarationMatch) {
+    bodyStartIndex = declarationMatch[0].length
+  }
+
+  if (varStartIndex !== -1) {
+    const varSectionStart = varStartIndex
+    const lastEndVarIndex = findLastEndVarIndex(remainingContent, varSectionStart)
+
+    if (lastEndVarIndex !== -1) {
+      variablesText = remainingContent.slice(varSectionStart, lastEndVarIndex)
+      bodyStartIndex = lastEndVarIndex
+    }
+  }
+
+  let bodyValue: unknown
+
+  if (language === 'st' || language === 'il' || language === 'python' || language === 'cpp') {
+    const endKeywords = {
+      program: 'END_PROGRAM',
+      function: 'END_FUNCTION',
+      'function-block': 'END_FUNCTION_BLOCK',
+    }
+    const endKeyword = endKeywords[pouType as keyof typeof endKeywords]
+    const endKeywordRegex = new RegExp(`\\b${endKeyword}\\b`, 'i')
+    const endMatch = remainingContent.slice(bodyStartIndex).search(endKeywordRegex)
+
+    if (endMatch !== -1) {
+      bodyValue = remainingContent.slice(bodyStartIndex, bodyStartIndex + endMatch).trim()
+    } else {
+      bodyValue = remainingContent.slice(bodyStartIndex).trim()
+    }
+  } else if (language === 'ld' || language === 'fbd') {
+    const endKeywords = {
+      program: 'END_PROGRAM',
+      function: 'END_FUNCTION',
+      'function-block': 'END_FUNCTION_BLOCK',
+    }
+    const endKeyword = endKeywords[pouType as keyof typeof endKeywords]
+    const endKeywordRegex = new RegExp(`\\b${endKeyword}\\b`, 'i')
+    const endMatch = remainingContent.slice(bodyStartIndex).search(endKeywordRegex)
+
+    const bodyContent =
+      endMatch !== -1
+        ? remainingContent.slice(bodyStartIndex, bodyStartIndex + endMatch).trim()
+        : remainingContent.slice(bodyStartIndex).trim()
+
+    try {
+      bodyValue = JSON.parse(bodyContent)
+    } catch {
+      bodyValue = {
+        nodes: [],
+        edges: [],
+        viewport: { x: 0, y: 0, zoom: 1 },
+      }
+    }
+  } else {
+    bodyValue = ''
+  }
+
+  const commonData = {
+    name: pouName,
+    variables: [],
+    documentation,
+    variablesText,
+  }
+
+  if (pouType === 'function') {
+    return {
+      type: 'function',
+      data: {
+        ...commonData,
+        language: language as 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd',
+        returnType: 'BOOL',
+        body: {
+          language: language as 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd',
+          value: bodyValue,
+        },
+      },
+    } as PLCPou
+  } else if (pouType === 'function-block') {
+    return {
+      type: 'function-block',
+      data: {
+        ...commonData,
+        language: language as 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd',
+        body: {
+          language: language as 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd',
+          value: bodyValue,
+        },
+      },
+    } as PLCPou
+  } else {
+    return {
+      type: 'program',
+      data: {
+        ...commonData,
+        language: language as 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd',
+        body: {
+          language: language as 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd',
+          value: bodyValue,
+        },
+      },
+    } as PLCPou
+  }
+}
+
+/**
+ * Parse a POU file (either JSON or text-based format)
+ * @param filePath - The path to the POU file
+ * @param fileName - The name of the file (for error messages)
+ * @returns Parsed PLCPou object
+ * @throws Error if parsing fails
+ */
+function readAndParsePouFile(filePath: string, fileName: string): PLCPou {
+  const fileExtension = extname(filePath)
+  const fileContent = readFileSync(filePath, 'utf-8')
+
+  if (fileExtension === '.json') {
+    const parsedJson = JSON.parse(fileContent)
+    const result = PLCPouSchema.safeParse(parsedJson)
+    if (!result.success) {
+      throw new Error(`Failed to parse JSON POU file ${fileName}: ${result.error.message}`)
+    }
+    return result.data
+  }
+
+  try {
+    const pouType = detectPouTypeFromPath(filePath)
+    const language = detectLanguageFromExtension(filePath)
+
+    let pou: PLCPou
+
+    if (language === 'st' || language === 'il') {
+      pou = parseTextualPouFromString(fileContent, language, pouType)
+    } else if (language === 'python' || language === 'cpp') {
+      pou = parseHybridPouFromString(fileContent, language, pouType)
+    } else if (language === 'ld' || language === 'fbd') {
+      pou = parseGraphicalPouFromString(fileContent, language, pouType)
+    } else {
+      throw new Error(`Unsupported language: ${language}`)
+    }
+
+    // The text parser returns the port format ({name, pouType, interface, body})
+    // but the rest of the main process pipeline expects the old discriminated-union
+    // format ({type, data: {name, variables, body, documentation}}).
+    // Convert to old format for compatibility.
+    const portPou = pou as unknown as {
+      name: string
+      pouType: string
+      interface?: { returnType?: string; variables: unknown[] }
+      body: { language: string; value: unknown }
+      documentation?: string
+    }
+    const oldFormatPou = {
+      type: portPou.pouType,
+      data: {
+        language: language as 'st' | 'il' | 'ld' | 'fbd' | 'python' | 'cpp',
+        name: portPou.name,
+        variables: portPou.interface?.variables ?? [],
+        ...(portPou.pouType === 'function' ? { returnType: portPou.interface?.returnType ?? '' } : {}),
+        body: portPou.body,
+        documentation: portPou.documentation ?? '',
+      },
+    } as PLCPou
+
+    return oldFormatPou
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse POU file ${fileName}: ${error.message}`)
+    }
+    throw new Error(`Failed to parse POU file ${fileName}: Unknown error`)
+  }
+}
+
+/**
+ * This function reads a directory recursively and parses POU files according to their format.
+ * Supports both text-based formats (.st, .il, .ld, .fbd, .py, .cpp) and JSON format (backward compatibility).
+ * When both text-based and JSON files exist for the same POU, the text-based file is preferred.
+ */
+function readDirectoryRecursive(
+  baseDir: string,
+  baseFileName: string,
+  projectFiles: Record<string, unknown>,
+  pouNameMap: Map<string, { key: string; isTextBased: boolean }>,
+) {
+  const entries = readdirSync(baseDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const entryPath = join(baseDir, entry.name)
+    const entryKey = join(baseFileName, entry.name)
+
+    if (entry.isFile()) {
+      const fileExtension = extname(entry.name)
+
+      if (!VALID_POU_EXTENSIONS.includes(fileExtension)) {
+        continue
+      }
+
+      const pouName = basename(entry.name, fileExtension)
+      const isTextBased = fileExtension !== '.json'
+      const existingEntry = pouNameMap.get(pouName)
+
+      if (existingEntry) {
+        if (isTextBased && !existingEntry.isTextBased) {
+          delete projectFiles[existingEntry.key]
+          try {
+            projectFiles[entryKey] = readAndParsePouFile(entryPath, entryKey)
+            pouNameMap.set(pouName, { key: entryKey, isTextBased })
+          } catch {
+            try {
+              const fileContent = readFileSync(entryPath, 'utf-8')
+              const pouType = detectPouTypeFromPath(entryPath)
+              const language: string = detectLanguageFromExtension(entryPath)
+              const fallbackPou = createFallbackPou(fileContent, language, pouType, pouName)
+              projectFiles[entryKey] = fallbackPou
+              pouNameMap.set(pouName, { key: entryKey, isTextBased })
+            } catch {
+              // Intentionally skip POUs that cannot be parsed and also fail fallback creation
+            }
+          }
+        }
+      } else {
+        try {
+          projectFiles[entryKey] = readAndParsePouFile(entryPath, entryKey)
+          pouNameMap.set(pouName, { key: entryKey, isTextBased })
+        } catch {
+          try {
+            const fileContent = readFileSync(entryPath, 'utf-8')
+            const pouType = detectPouTypeFromPath(entryPath)
+            const language: string = detectLanguageFromExtension(entryPath)
+            const fallbackPou = createFallbackPou(fileContent, language, pouType, pouName)
+            projectFiles[entryKey] = fallbackPou
+            pouNameMap.set(pouName, { key: entryKey, isTextBased })
+          } catch {
+            // Intentionally skip POUs that cannot be parsed and also fail fallback creation
+          }
+        }
+      }
+    } else if (entry.isDirectory()) {
+      readDirectoryRecursive(entryPath, entryKey, projectFiles, pouNameMap)
+    }
+  }
+}
+
+export async function readProjectFiles(basePath: string): Promise<IProjectServiceReadFilesResponse> {
+  const isValidProjectDirectory = checkIfDirectoryIsAValidProjectDirectory(basePath)
+  if (!isValidProjectDirectory.success) {
+    return isValidProjectDirectory
+  }
+
+  const projectFiles: Record<string, unknown> = {}
+  const pouFiles: Record<string, unknown> = {}
+
+  /**
+   * Read the default project files from the project directory.
+   * This includes the project.json, devices/configuration.json, and devices/pin-mapping.json files.
+   * If any of these files do not exist, they will be created with default values from the schema.
+   * If any of the files cannot be read or parsed, use default values and log a warning.
+   */
+  for (const fileName of Object.keys(projectDefaultFilesMapSchema) as (keyof typeof projectDefaultFilesMapSchema)[]) {
+    const schema = projectDefaultFilesMapSchema[fileName]
+    const filePath = join(basePath, fileName)
+    try {
+      projectFiles[fileName] = readAndParseFile(filePath, fileName, schema)
+    } catch {
+      projectFiles[fileName] = getDefaultSchemaValues(schema)
+    }
+  }
+
+  /**
+   * Read pou files from the project directory.
+   * Use a map to track POUs by name and prefer text-based files over JSON.
+   */
+  const pouNameMap = new Map<string, { key: string; isTextBased: boolean }>()
+  for (const pouDirectory of projectPouDirectories) {
+    const pouDirPath = join(basePath, pouDirectory)
+    if (fileOrDirectoryExists(pouDirPath)) {
+      readDirectoryRecursive(pouDirPath, pouDirectory, pouFiles, pouNameMap)
+    }
+  }
+
+  if (projectFiles['project.json']) {
+    const project = projectFiles['project.json'] as PLCProject
+    if (project.data.pous && project.data.pous.length > 0) {
+      const migrationResults = await Promise.allSettled(
+        project.data.pous.map(async (pou) => {
+          const flat = ipcPouToFlat(pou)
+          const pouType = pou.type.toLowerCase() + 's'
+          const extension: string = getExtensionFromLanguage(flat.body.language)
+          const pouFilePath = join(basePath, 'pous', pouType, `${flat.name}${extension}`)
+
+          try {
+            if (!fileOrDirectoryExists(pouFilePath)) {
+              await promises.mkdir(dirname(pouFilePath), { recursive: true })
+              const textContent: string = serializePouToText(flat)
+              await promises.writeFile(pouFilePath, textContent, 'utf-8')
+            }
+            pouFiles[join('pous', pouType, `${flat.name}${extension}`)] = pou
+            return { success: true, pouName: flat.name }
+          } catch (error: unknown) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+            return { success: false, pouName: pou.data.name, error: errorMessage }
+          }
+        }),
+      )
+
+      const successfulMigrations = migrationResults.filter((r) => r.status === 'fulfilled' && r.value.success)
+
+      if (successfulMigrations.length === project.data.pous.length) {
+        try {
+          project.data.pous = []
+          await promises.writeFile(join(basePath, 'project.json'), JSON.stringify(project, null, 2), 'utf-8')
+        } catch {
+          // Intentionally continue if clearing POUs array fails to allow partial migration
+        }
+      }
+    }
+  }
+
+  /**
+   * Ensure POU names are set correctly.
+   * For text-based formats, the name is already extracted from the file content by the parser.
+   * For JSON files (backward compatibility), extract from filename if not already set.
+   */
+  Object.keys(pouFiles).forEach((key) => {
+    const pouFile = pouFiles[key] as PLCPou
+    if (!pouFile.data.name) {
+      const fileExtension = extname(key)
+      const pouName = basename(key, fileExtension)
+      if (pouName) {
+        pouFile.data.name = pouName
+        pouFiles[key] = pouFile
+      }
+    }
+  })
+
+  /**
+   * Read server config files from the devices/servers directory.
+   * Each server is stored as an individual JSON file.
+   */
+  const serverFiles: PLCServer[] = []
+  const serversDir = join(basePath, 'devices', 'servers')
+  if (fileOrDirectoryExists(serversDir)) {
+    const serverEntries = readdirSync(serversDir, { withFileTypes: true })
+    for (const entry of serverEntries) {
+      if (entry.isFile() && extname(entry.name) === '.json') {
+        const serverFilePath = join(serversDir, entry.name)
+        try {
+          const serverContent = readFileSync(serverFilePath, 'utf-8')
+          const parsedServer = JSON.parse(serverContent)
+          const result = PLCServerSchema.safeParse(parsedServer)
+          if (result.success) {
+            serverFiles.push(result.data)
+          }
+        } catch {
+          // Skip invalid server files
+        }
+      }
+    }
+  }
+
+  /**
+   * Read remote device config files from the devices/remote directory.
+   * Each remote device is stored as an individual JSON file.
+   */
+  const remoteDeviceFiles: PLCRemoteDevice[] = []
+  const remoteDevicesDir = join(basePath, 'devices', 'remote')
+  if (fileOrDirectoryExists(remoteDevicesDir)) {
+    const remoteDeviceEntries = readdirSync(remoteDevicesDir, { withFileTypes: true })
+    for (const entry of remoteDeviceEntries) {
+      if (entry.isFile() && extname(entry.name) === '.json') {
+        const remoteDeviceFilePath = join(remoteDevicesDir, entry.name)
+        try {
+          const remoteDeviceContent = readFileSync(remoteDeviceFilePath, 'utf-8')
+          const parsedRemoteDevice = JSON.parse(remoteDeviceContent)
+          const result = PLCRemoteDeviceSchema.safeParse(parsedRemoteDevice)
+          if (result.success) {
+            remoteDeviceFiles.push(result.data)
+          }
+        } catch {
+          // Skip invalid remote device files
+        }
+      }
+    }
+  }
+
+  const returnData: IProjectServiceReadFilesResponse['data'] = {
+    project: projectFiles['project.json'] as PLCProject,
+    pous: Object.values(pouFiles).map((pou) => pou as PLCPou),
+    deviceConfiguration: projectFiles['devices/configuration.json'] as DeviceConfiguration,
+    devicePinMapping: projectFiles['devices/pin-mapping.json'] as DevicePin[],
+    servers: serverFiles,
+    remoteDevices: remoteDeviceFiles,
+  }
+
+  // Check if project needs migration from ID-based to name+type-based system
+  if (needsMigration(returnData.project.data)) {
+    console.log('Project needs migration from ID-based to name+type-based system')
+    const { migratedProject, report } = migrateProjectToNameTypeSystem(returnData.project.data)
+
+    if (report.success) {
+      console.log(`Migration successful: ${report.variablesMigrated} variables migrated`)
+
+      returnData.project.data = migratedProject
+
+      returnData.pous = returnData.pous.map((pou) => {
+        const migratedPou = migratedProject.pous.find((p) => p.data.name === pou.data.name)
+        if (migratedPou) {
+          return { ...pou, data: migratedPou.data } as PLCPou
+        }
+        return pou
+      })
+
+      // Create a backup of the original project before saving migrated version
+      const backupPath = join(basePath, 'project.backup.json')
+      if (!fileOrDirectoryExists(backupPath)) {
+        try {
+          await promises.writeFile(backupPath, JSON.stringify(projectFiles['project.json'], null, 2), 'utf-8')
+          console.log(`Backup created at: ${backupPath}`)
+        } catch (error) {
+          console.error('Failed to create backup:', error)
+          return {
+            success: false,
+            message: 'Failed to create backup before migration',
+            error: {
+              title: 'Backup Creation Failed',
+              description:
+                'Could not create a backup of the original project before migration. Migration aborted to prevent data loss.',
+              error: error,
+            },
+          }
+        }
+      }
+
+      try {
+        await promises.writeFile(join(basePath, 'project.json'), JSON.stringify(returnData.project, null, 2), 'utf-8')
+        console.log('Migrated project saved successfully')
+
+        for (const pou of returnData.pous) {
+          const pouType = pou.type.toLowerCase() + 's'
+          const pouFilePath = join(basePath, 'pous', pouType, `${pou.data.name}.json`)
+          await promises.writeFile(pouFilePath, JSON.stringify(pou, null, 2), 'utf-8')
+        }
+        console.log('Migrated POUs saved successfully')
+      } catch (error) {
+        console.error('Failed to save migrated project:', error)
+        return {
+          success: false,
+          message: 'Failed to save migrated project',
+          error: {
+            title: 'Migration Save Failed',
+            description: 'Migration completed but failed to save the migrated project files.',
+            error: error,
+          },
+        }
+      }
+    } else {
+      console.error('Migration failed:', report.errors)
+      if (report.unresolvedReferences.length > 0) {
+        console.error('Unresolved references:', report.unresolvedReferences)
+      }
+    }
+  }
+
+  return {
+    success: true,
+    message: 'Project files read successfully',
+    data: returnData,
+  }
+}
diff --git a/src/main/services/user-service/data/arduino.ts b/src/backend/editor/services/user-service/data/arduino.ts
similarity index 100%
rename from src/main/services/user-service/data/arduino.ts
rename to src/backend/editor/services/user-service/data/arduino.ts
diff --git a/src/main/services/user-service/data/history.ts b/src/backend/editor/services/user-service/data/history.ts
similarity index 100%
rename from src/main/services/user-service/data/history.ts
rename to src/backend/editor/services/user-service/data/history.ts
diff --git a/src/main/services/user-service/data/settings.ts b/src/backend/editor/services/user-service/data/settings.ts
similarity index 100%
rename from src/main/services/user-service/data/settings.ts
rename to src/backend/editor/services/user-service/data/settings.ts
diff --git a/src/backend/editor/services/user-service/index.ts b/src/backend/editor/services/user-service/index.ts
new file mode 100644
index 000000000..17fcf74f4
--- /dev/null
+++ b/src/backend/editor/services/user-service/index.ts
@@ -0,0 +1,255 @@
+import { getErrorMessage } from '@root/utils/get-error-message'
+import { exec } from 'child_process'
+import { app } from 'electron'
+import { access, constants, mkdir, rename, rm, writeFile } from 'fs/promises'
+import { basename, join } from 'path'
+import { promisify } from 'util'
+
+import { ARDUINO_DATA } from './data/arduino'
+import { HISTORY_DATA } from './data/history'
+import { SETTINGS_DATA } from './data/settings'
+import type { ArduinoListOutput } from './user-service-types'
+
+/**
+ * UserService class responsible for user settings and history management.
+ * This class is a singleton and should be instantiated only once during the application lifecycle.
+ * For now it is used as a static class, although it isn't recommended to use static classes in TypeScript.
+ * This approach is taken to avoid the need for a singleton instance and to leave room for future changes in the class structure.
+ */
+class UserService {
+  constructor() {
+    void this.#initializeUserSettingsAndHistory()
+  }
+
+  /**
+   * Static methods and properties.
+   */
+
+  static DEFAULT_SETTINGS = SETTINGS_DATA
+
+  static DEFAULT_HISTORY = HISTORY_DATA
+
+  static ARDUINO_FILE_CONTENT = ARDUINO_DATA
+
+  static async createDirectoryIfNotExists(path: string): Promise<void> {
+    /**
+     * The access() method checks the existence of the file or directory at the specified path.
+     * If the file or directory exists, the method resolves successfully.
+     */
+    try {
+      await access(path, constants.F_OK)
+    } catch {
+      try {
+        await mkdir(path, { recursive: true })
+      } catch (err) {
+        // If the error is due to the directory already existing, log a warning and continue.
+        if (err instanceof Error && err.message.includes('EEXIST')) {
+          console.warn(`Directory already exists at ${path}.\nSkipping creation.`)
+        } else if (err instanceof Error) {
+          console.error(`Error creating directory at ${path}: ${getErrorMessage(err)}`)
+        } else {
+          console.error(`Error creating directory at ${path}: ${getErrorMessage(err)}`)
+        }
+      }
+    }
+  }
+
+  static async createJSONFileIfNotExists(filePath: string, data: object): Promise<void> {
+    try {
+      await writeFile(filePath, JSON.stringify(data, null, 2), { flag: 'wx' })
+    } catch (err) {
+      // If the error is due to the file already existing, log a warning and continue.
+      if (err instanceof Error && (err as NodeJS.ErrnoException).code === 'EEXIST') {
+        console.warn(`File already exists at ${filePath}.\nSkipping creation.`)
+        return
+      } else if (err instanceof Error) {
+        console.error(`Error creating file at ${filePath}: ${getErrorMessage(err)}`)
+        throw new Error(`Failed to create file at ${filePath}: ${getErrorMessage(err)}`)
+      } else {
+        console.error(`Error creating file at ${filePath}: ${getErrorMessage(err)}`)
+        throw new Error(`Failed to create file at ${filePath}: ${getErrorMessage(err)}`)
+      }
+    }
+  }
+
+  static async deleteFile(filePath: string): Promise<void> {
+    try {
+      await rm(filePath, { recursive: true, force: true })
+    } catch (err) {
+      console.error(`Error deleting file at ${filePath}: ${getErrorMessage(err)}`)
+      throw new Error(`Failed to delete file at ${filePath}: ${getErrorMessage(err)}`)
+    }
+  }
+
+  static async renameFile(
+    oldFilePath: string,
+    newFilePath: string,
+  ): Promise<{
+    success: boolean
+    error?: {
+      title: string
+      description: string
+      error: Error
+    }
+    data?: { filePath: string }
+  }> {
+    const newFileName = basename(newFilePath)
+    try {
+      await rename(oldFilePath, newFilePath)
+      return { success: true, data: { filePath: newFilePath } }
+    } catch (err) {
+      console.error(`Error renaming file at ${oldFilePath} to ${newFileName}: ${getErrorMessage(err)}`)
+      return {
+        success: false,
+        error: { title: 'File Rename Error', description: 'Failed to rename file', error: err as Error },
+      }
+    }
+  }
+
+  /**
+   * -----------------------------------------------------------------------
+   */
+
+  /**
+   * Checks if the user base settings folder exists and creates it if it doesn't.
+   * Also creates a user settings file with default values if it doesn't exist.
+   *
+   * @returns {Promise<void>} Resolves when the user base settings folder and file are ready.
+   */
+  async #checkIfUserBaseSettingsExists(): Promise<void> {
+    const pathToUserDataFolder = join(app.getPath('userData'), 'User')
+    const pathToUserDataFile = join(pathToUserDataFolder, 'settings.json')
+
+    await UserService.createDirectoryIfNotExists(pathToUserDataFolder)
+    await UserService.createJSONFileIfNotExists(pathToUserDataFile, UserService.DEFAULT_SETTINGS)
+  }
+
+  async #checkIfLogFolderExists(): Promise<void> {
+    const pathToLogFolder = join(app.getPath('userData'), 'logs')
+    await UserService.createDirectoryIfNotExists(pathToLogFolder)
+  }
+
+  /**
+   * Checks if the user history folder exists and creates it if it doesn't.
+   * Also creates a user history file with default values if it doesn't exist.
+   *
+   * @returns {Promise<void>} Resolves when the user history folder and file are ready.
+   */
+  async #checkIfUserHistoryFolderExists(): Promise<void> {
+    const pathToUserHistoryFolder = join(app.getPath('userData'), 'User', 'History')
+    const pathToUserProjectInfoFile = join(pathToUserHistoryFolder, 'projects.json')
+    const pathToUserLibraryInfoFile = join(pathToUserHistoryFolder, 'libraries.json')
+
+    await UserService.createDirectoryIfNotExists(pathToUserHistoryFolder)
+    await UserService.createJSONFileIfNotExists(pathToUserProjectInfoFile, UserService.DEFAULT_HISTORY.projects)
+    await UserService.createJSONFileIfNotExists(pathToUserLibraryInfoFile, UserService.DEFAULT_HISTORY.libraries)
+  }
+
+  /**
+   * Checks if the Arduino CLI configuration file exists and creates it if it doesn't.
+   */
+  async #checkIfArduinoCliConfigExists(): Promise<void> {
+    const pathToArduinoCliConfig = join(app.getPath('userData'), 'User', 'arduino-cli.yaml')
+    try {
+      await writeFile(pathToArduinoCliConfig, UserService.ARDUINO_FILE_CONTENT, { flag: 'wx' })
+    } catch (err) {
+      // If the error is due to the file already existing, log a warning and continue.
+      if (err instanceof Error && err.message.includes('EEXIST')) {
+        console.warn(`File already exists at ${pathToArduinoCliConfig}.\nSkipping creation.`)
+      } else if (err instanceof Error) {
+        console.error(`Error creating Arduino CLI config at ${pathToArduinoCliConfig}: ${getErrorMessage(err)}`)
+      } else {
+        console.error(`Error creating Arduino CLI config at ${pathToArduinoCliConfig}: ${getErrorMessage(err)}`)
+      }
+    }
+  }
+
+  async #executeArduinoCliCommand(command: string): Promise<{ stderr: string; stdout: string }> {
+    const developmentMode = process.env.NODE_ENV === 'development'
+    const executeCommand = promisify(exec)
+
+    const platformSpecificBinaryPath = join(process.platform, process.arch)
+
+    let binaryPath = join(
+      developmentMode ? process.cwd() : process.resourcesPath,
+      developmentMode ? 'resources' : '',
+      'bin',
+      developmentMode ? platformSpecificBinaryPath : '',
+      'arduino-cli',
+    )
+
+    if (process.platform === 'win32') {
+      binaryPath = `${binaryPath}.exe`
+    }
+
+    return executeCommand(`"${binaryPath}" ${command}`)
+  }
+
+  /**
+   * Checks if the Core List file exists and creates it if it doesn't.
+   * TODO: This function must be refactored.
+   * - Must validate if this implementation for the core list file is correct.
+   */
+
+  async #checkIfArduinoCoreControlFileExists(): Promise<void> {
+    const pathToRuntimeFolder = join(app.getPath('userData'), 'User', 'Runtime')
+    const pathToArduinoCoreControlFile = join(pathToRuntimeFolder, 'arduino-core-control.json')
+
+    const { stderr, stdout } = await this.#executeArduinoCliCommand('core list --json')
+    if (stderr) {
+      console.error(`Error listing cores: ${String(stderr)}`)
+      return
+    }
+
+    const coreListOutput = JSON.parse(stdout) as ArduinoListOutput['core']
+
+    const installedCoresFromListOutput = coreListOutput.platforms.map((core) => ({
+      [core.id]: core.installed_version,
+    }))
+
+    await UserService.createDirectoryIfNotExists(pathToRuntimeFolder)
+    await writeFile(pathToArduinoCoreControlFile, JSON.stringify(installedCoresFromListOutput, null, 2), { flag: 'w' })
+
+    // This is a legacy file that is no longer used, should be removed in the next major release!!!
+    const pathToLegacyHals = join(pathToRuntimeFolder, 'hals.json')
+    await rm(pathToLegacyHals, { recursive: true, force: true })
+  }
+
+  async #checkIfArduinoLibraryControlFileExists() {
+    const pathToRuntimeFolder = join(app.getPath('userData'), 'User', 'Runtime')
+    const pathToArduinoLibraryControlFile = join(pathToRuntimeFolder, 'arduino-library-control.json')
+
+    const { stderr, stdout } = await this.#executeArduinoCliCommand('lib list --json')
+    if (stderr) {
+      console.error(`Error listing libraries: ${String(stderr)}`)
+      return
+    }
+
+    const libraryListOutput = JSON.parse(stdout) as ArduinoListOutput['library']
+
+    const installedLibrariesFromListOutput = libraryListOutput.installed_libraries.map(({ library }) => ({
+      [library.name]: library.version,
+    }))
+
+    await UserService.createDirectoryIfNotExists(pathToRuntimeFolder)
+    await writeFile(pathToArduinoLibraryControlFile, JSON.stringify(installedLibrariesFromListOutput, null, 2), {
+      flag: 'w',
+    })
+  }
+  /**
+   * Initializes user settings and history by checking the relevant folders and files.
+   * This method should be called during the application startup process.
+   *
+   * @returns {Promise<void>} Resolves when all setup checks are complete.
+   */
+  async #initializeUserSettingsAndHistory(): Promise<void> {
+    await this.#checkIfUserBaseSettingsExists()
+    await this.#checkIfLogFolderExists()
+    await this.#checkIfUserHistoryFolderExists()
+    await this.#checkIfArduinoCliConfigExists()
+    await this.#checkIfArduinoCoreControlFileExists()
+    await this.#checkIfArduinoLibraryControlFileExists()
+  }
+}
+
+export { UserService }
diff --git a/src/main/services/user-service/user-service-types.ts b/src/backend/editor/services/user-service/user-service-types.ts
similarity index 100%
rename from src/main/services/user-service/user-service-types.ts
rename to src/backend/editor/services/user-service/user-service-types.ts
diff --git a/src/main/utils/create-directory.ts b/src/backend/editor/utils/create-directory.ts
similarity index 100%
rename from src/main/utils/create-directory.ts
rename to src/backend/editor/utils/create-directory.ts
diff --git a/src/main/utils/file-or-directory-exists.ts b/src/backend/editor/utils/file-or-directory-exists.ts
similarity index 100%
rename from src/main/utils/file-or-directory-exists.ts
rename to src/backend/editor/utils/file-or-directory-exists.ts
diff --git a/src/backend/editor/utils/index.ts b/src/backend/editor/utils/index.ts
new file mode 100644
index 000000000..52f6ab326
--- /dev/null
+++ b/src/backend/editor/utils/index.ts
@@ -0,0 +1,7 @@
+export * from './create-directory'
+export * from './file-or-directory-exists'
+export * from './ipc-pou-to-flat'
+export * from './json-manager'
+export * from './path-picker'
+export * from './resolve-html-path'
+export * from './xml-manager'
diff --git a/src/backend/editor/utils/ipc-pou-to-flat.ts b/src/backend/editor/utils/ipc-pou-to-flat.ts
new file mode 100644
index 000000000..dc02067ad
--- /dev/null
+++ b/src/backend/editor/utils/ipc-pou-to-flat.ts
@@ -0,0 +1,20 @@
+import type { PLCPou as FlatPou } from '@root/middleware/shared/ports/types'
+import type { PLCPou as IpcPou } from '@root/types/PLC/open-plc'
+
+/**
+ * Convert the editor backend's nested IPC POU format to the flat port POU
+ * format expected by shared utilities (e.g. serializePouToText).
+ */
+export function ipcPouToFlat(pou: IpcPou): FlatPou & { variablesText?: string } {
+  return {
+    name: pou.data.name,
+    pouType: pou.type as FlatPou['pouType'],
+    interface: {
+      returnType: 'returnType' in pou.data ? (pou.data as { returnType?: string }).returnType : undefined,
+      variables: pou.data.variables as FlatPou['interface']['variables'],
+    },
+    body: pou.data.body as FlatPou['body'],
+    documentation: pou.data.documentation,
+    variablesText: 'variablesText' in pou.data ? pou.data.variablesText : undefined,
+  }
+}
diff --git a/src/main/utils/is-empty-dir.ts b/src/backend/editor/utils/is-empty-dir.ts
similarity index 100%
rename from src/main/utils/is-empty-dir.ts
rename to src/backend/editor/utils/is-empty-dir.ts
diff --git a/src/main/utils/json-manager.ts b/src/backend/editor/utils/json-manager.ts
similarity index 100%
rename from src/main/utils/json-manager.ts
rename to src/backend/editor/utils/json-manager.ts
diff --git a/src/backend/editor/utils/path-picker.ts b/src/backend/editor/utils/path-picker.ts
new file mode 100644
index 000000000..0222c88b8
--- /dev/null
+++ b/src/backend/editor/utils/path-picker.ts
@@ -0,0 +1,40 @@
+import { BrowserWindow, dialog } from 'electron'
+
+import { isEmptyDir } from './is-empty-dir'
+
+type GetProjectPathProps = InstanceType<typeof BrowserWindow>
+
+const getProjectPath = async (serviceManager: GetProjectPathProps) => {
+  const { canceled, filePaths } = await dialog.showOpenDialog(serviceManager, {
+    title: 'Choose an empty directory for new project',
+    properties: ['openDirectory', 'createDirectory'],
+  })
+  if (canceled) {
+    return {
+      success: false,
+      error: {
+        title: 'Operation canceled',
+        description: 'Operation canceled by the user.',
+      },
+    }
+  }
+
+  const [filePath] = filePaths
+
+  if (!(await isEmptyDir(filePath))) {
+    return {
+      success: false,
+      error: {
+        title: 'Directory is not empty',
+        description: 'The selected directory is not empty. Please choose an empty directory for a new project.',
+      },
+    }
+  }
+
+  return {
+    success: true,
+    path: filePath,
+  }
+}
+
+export { getProjectPath }
diff --git a/src/main/utils/resolve-html-path.ts b/src/backend/editor/utils/resolve-html-path.ts
similarity index 100%
rename from src/main/utils/resolve-html-path.ts
rename to src/backend/editor/utils/resolve-html-path.ts
diff --git a/src/utils/runtime-https-config.ts b/src/backend/editor/utils/runtime-https-config.ts
similarity index 100%
rename from src/utils/runtime-https-config.ts
rename to src/backend/editor/utils/runtime-https-config.ts
diff --git a/src/main/utils/xml-manager.ts b/src/backend/editor/utils/xml-manager.ts
similarity index 100%
rename from src/main/utils/xml-manager.ts
rename to src/backend/editor/utils/xml-manager.ts
diff --git a/src/backend/editor/websocket/websocket-debug-client.ts b/src/backend/editor/websocket/websocket-debug-client.ts
new file mode 100644
index 000000000..a808d4f59
--- /dev/null
+++ b/src/backend/editor/websocket/websocket-debug-client.ts
@@ -0,0 +1,363 @@
+import { getErrorMessage } from '@root/utils/get-error-message'
+import { io, Socket } from 'socket.io-client'
+
+import { ModbusDebugResponse, ModbusFunctionCode } from '../modbus/modbus-client'
+
+interface WebSocketDebugClientOptions {
+  host: string
+  port: number
+  token: string
+  rejectUnauthorized?: boolean
+}
+
+export class WebSocketDebugClient {
+  private host: string
+  private port: number
+  private token: string
+  private socket: Socket | null = null
+  private rejectUnauthorized: boolean
+
+  constructor(options: WebSocketDebugClientOptions) {
+    this.host = options.host
+    this.port = options.port
+    this.token = options.token
+    this.rejectUnauthorized = options.rejectUnauthorized ?? false
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const url = `https://${this.host}:${this.port}/api/debug`
+
+      this.socket = io(url, {
+        transports: ['websocket'],
+        auth: {
+          token: this.token,
+        },
+        rejectUnauthorized: this.rejectUnauthorized,
+        reconnection: false,
+        timeout: 5000,
+      })
+
+      const timeoutHandle = setTimeout(() => {
+        this.socket?.disconnect()
+        reject(new Error('Connection timeout'))
+      }, 5000)
+
+      this.socket.on('connect_error', (error: Error) => {
+        clearTimeout(timeoutHandle)
+        reject(error)
+      })
+
+      this.socket.io.on('error', (error: Error) => {
+        clearTimeout(timeoutHandle)
+        reject(error)
+      })
+
+      this.socket.on('connected', (data: { status: string }) => {
+        clearTimeout(timeoutHandle)
+        if (data.status === 'ok') {
+          resolve()
+        } else {
+          reject(new Error('Connection failed: invalid status'))
+        }
+      })
+    })
+  }
+
+  disconnect(): void {
+    if (this.socket) {
+      this.socket.disconnect()
+      this.socket = null
+    }
+  }
+
+  private bufferToHexString(buffer: Buffer): string {
+    return Array.from(buffer)
+      .map((byte) => byte.toString(16).toUpperCase().padStart(2, '0'))
+      .join(' ')
+  }
+
+  private hexStringToBuffer(hexString: string): Buffer {
+    const bytes = hexString.split(' ').map((byte) => parseInt(byte, 16))
+    return Buffer.from(bytes)
+  }
+
+  async getMd5Hash(): Promise<string> {
+    if (!this.socket) {
+      throw new Error('Not connected to target')
+    }
+
+    const functionCode = ModbusFunctionCode.DEBUG_GET_MD5
+    const endiannessCheck = 0xdead
+
+    const request = Buffer.alloc(5)
+    request.writeUInt8(functionCode, 0)
+    request.writeUInt16BE(endiannessCheck, 1)
+    request.writeUInt8(0, 3)
+    request.writeUInt8(0, 4)
+
+    const commandHex = this.bufferToHexString(request)
+
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        reject(new Error('Request timeout'))
+      }, 5000)
+
+      const responseHandler = (response: { success: boolean; data?: string; error?: string }) => {
+        clearTimeout(timeoutHandle)
+        this.socket?.off('debug_response', responseHandler)
+
+        if (!response.success) {
+          reject(new Error(response.error || 'Unknown error'))
+          return
+        }
+
+        if (!response.data) {
+          reject(new Error('No data in response'))
+          return
+        }
+
+        try {
+          const responseBuffer = this.hexStringToBuffer(response.data)
+
+          if (responseBuffer.length < 2) {
+            reject(new Error('Invalid response: too short'))
+            return
+          }
+
+          const responseFunctionCode = responseBuffer.readUInt8(0)
+          const statusCode = responseBuffer.readUInt8(1)
+
+          if (responseFunctionCode !== (ModbusFunctionCode.DEBUG_GET_MD5 as number)) {
+            reject(new Error('Function code mismatch'))
+            return
+          }
+
+          if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+            reject(new Error(`Target returned error code: 0x${statusCode.toString(16)}`))
+            return
+          }
+
+          const md5String = responseBuffer.slice(2).toString('utf-8').trim()
+          resolve(md5String)
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error(getErrorMessage(error) as string))
+        }
+      }
+
+      this.socket!.on('debug_response', responseHandler)
+      this.socket!.emit('debug_command', { command: commandHex })
+    })
+  }
+
+  async getVariablesList(variableIndexes: number[]): Promise<{
+    success: boolean
+    tick?: number
+    lastIndex?: number
+    data?: Buffer
+    error?: string
+  }> {
+    if (!this.socket) {
+      return { success: false, error: 'Not connected to target' }
+    }
+
+    const functionCode = ModbusFunctionCode.DEBUG_GET_LIST
+    const numIndexes = variableIndexes.length
+
+    const request = Buffer.alloc(3 + 2 * numIndexes)
+    request.writeUInt8(functionCode, 0)
+    request.writeUInt16BE(numIndexes, 1)
+
+    for (let i = 0; i < numIndexes; i++) {
+      request.writeUInt16BE(variableIndexes[i], 3 + i * 2)
+    }
+
+    const commandHex = this.bufferToHexString(request)
+
+    return new Promise((resolve) => {
+      const timeoutHandle = setTimeout(() => {
+        resolve({ success: false, error: 'Request timeout' })
+      }, 5000)
+
+      const responseHandler = (response: { success: boolean; data?: string; error?: string }) => {
+        clearTimeout(timeoutHandle)
+        this.socket?.off('debug_response', responseHandler)
+
+        if (!response.success) {
+          resolve({ success: false, error: response.error || 'Unknown error' })
+          return
+        }
+
+        if (!response.data) {
+          resolve({ success: false, error: 'No data in response' })
+          return
+        }
+
+        try {
+          const responseBuffer = this.hexStringToBuffer(response.data)
+
+          if (responseBuffer.length < 2) {
+            resolve({
+              success: false,
+              error: `Invalid response: too short (${responseBuffer.length} bytes, need at least 2)`,
+            })
+            return
+          }
+
+          const responseFunctionCode = responseBuffer.readUInt8(0)
+          const statusCode = responseBuffer.readUInt8(1)
+
+          if (responseFunctionCode !== (ModbusFunctionCode.DEBUG_GET_LIST as number)) {
+            resolve({ success: false, error: 'Function code mismatch' })
+            return
+          }
+
+          if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+            resolve({ success: false, error: 'ERROR_OUT_OF_BOUNDS' })
+            return
+          }
+
+          if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+            resolve({ success: false, error: 'ERROR_OUT_OF_MEMORY' })
+            return
+          }
+
+          if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+            resolve({ success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` })
+            return
+          }
+
+          if (responseBuffer.length < 10) {
+            resolve({
+              success: false,
+              error: `Incomplete success response (${responseBuffer.length} bytes, expected at least 10)`,
+            })
+            return
+          }
+
+          const lastIndex = responseBuffer.readUInt16BE(2)
+          const tick = responseBuffer.readUInt32BE(4)
+          const responseSize = responseBuffer.readUInt16BE(8)
+
+          if (responseBuffer.length < 10 + responseSize) {
+            resolve({
+              success: false,
+              error: `Incomplete variable data (expected ${responseSize} bytes, got ${responseBuffer.length - 10})`,
+            })
+            return
+          }
+
+          const variableData = responseBuffer.slice(10, 10 + responseSize)
+
+          resolve({
+            success: true,
+            tick,
+            lastIndex,
+            data: variableData,
+          })
+        } catch (error) {
+          resolve({ success: false, error: getErrorMessage(error) })
+        }
+      }
+
+      this.socket!.on('debug_response', responseHandler)
+      this.socket!.emit('debug_command', { command: commandHex })
+    })
+  }
+
+  async setVariable(
+    variableIndex: number,
+    force: boolean,
+    valueBuffer?: Buffer,
+  ): Promise<{
+    success: boolean
+    error?: string
+  }> {
+    if (!this.socket) {
+      return { success: false, error: 'Not connected to target' }
+    }
+
+    const functionCode = ModbusFunctionCode.DEBUG_SET
+
+    const dataLength = force && valueBuffer ? valueBuffer.length : 1
+    const request = Buffer.alloc(6 + dataLength)
+
+    request.writeUInt8(functionCode, 0)
+    request.writeUInt16BE(variableIndex, 1)
+    request.writeUInt8(force ? 1 : 0, 3)
+    request.writeUInt16BE(dataLength, 4)
+
+    if (force && valueBuffer) {
+      for (let i = 0; i < valueBuffer.length; i++) {
+        request.writeUInt8(valueBuffer[i], 6 + i)
+      }
+    } else {
+      request.writeUInt8(0, 6)
+    }
+
+    const commandHex = this.bufferToHexString(request)
+
+    return new Promise((resolve) => {
+      const timeoutHandle = setTimeout(() => {
+        resolve({ success: false, error: 'Request timeout' })
+      }, 5000)
+
+      const responseHandler = (response: { success: boolean; data?: string; error?: string }) => {
+        clearTimeout(timeoutHandle)
+        this.socket?.off('debug_response', responseHandler)
+
+        if (!response.success) {
+          resolve({ success: false, error: response.error || 'Unknown error' })
+          return
+        }
+
+        if (!response.data) {
+          resolve({ success: false, error: 'No data in response' })
+          return
+        }
+
+        try {
+          const responseBuffer = this.hexStringToBuffer(response.data)
+
+          if (responseBuffer.length < 2) {
+            resolve({
+              success: false,
+              error: `Invalid response: too short (${responseBuffer.length} bytes, need at least 2)`,
+            })
+            return
+          }
+
+          const responseFunctionCode = responseBuffer.readUInt8(0)
+          const statusCode = responseBuffer.readUInt8(1)
+
+          if (responseFunctionCode !== (ModbusFunctionCode.DEBUG_SET as number)) {
+            resolve({ success: false, error: 'Function code mismatch' })
+            return
+          }
+
+          if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+            resolve({ success: false, error: 'ERROR_OUT_OF_BOUNDS' })
+            return
+          }
+
+          if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+            resolve({ success: false, error: 'ERROR_OUT_OF_MEMORY' })
+            return
+          }
+
+          if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+            resolve({ success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` })
+            return
+          }
+
+          resolve({ success: true })
+        } catch (error) {
+          resolve({ success: false, error: getErrorMessage(error) })
+        }
+      }
+
+      this.socket!.on('debug_response', responseHandler)
+      this.socket!.emit('debug_command', { command: commandHex })
+    })
+  }
+}
diff --git a/src/shared/data/mock/examples.json b/src/backend/shared-data/mock/examples.json
similarity index 100%
rename from src/shared/data/mock/examples.json
rename to src/backend/shared-data/mock/examples.json
diff --git a/src2/backend/shared-data/mock/object-to-create-project.ts b/src/backend/shared-data/mock/object-to-create-project.ts
similarity index 95%
rename from src2/backend/shared-data/mock/object-to-create-project.ts
rename to src/backend/shared-data/mock/object-to-create-project.ts
index 343f854cc..2b5cf83c2 100644
--- a/src2/backend/shared-data/mock/object-to-create-project.ts
+++ b/src/backend/shared-data/mock/object-to-create-project.ts
@@ -1,4 +1,4 @@
-import { formatDate } from '../../../utils'
+import { formatDate } from '../../../frontend/utils/format-date'
 
 const xmlProjectAsObject = {
   project: {
diff --git a/src/shared/data/mock/projects-data.json b/src/backend/shared-data/mock/projects-data.json
similarity index 100%
rename from src/shared/data/mock/projects-data.json
rename to src/backend/shared-data/mock/projects-data.json
diff --git a/src2/backend/shared/__tests__/validate-variable-type.test.ts b/src/backend/shared/__tests__/validate-variable-type.test.ts
similarity index 96%
rename from src2/backend/shared/__tests__/validate-variable-type.test.ts
rename to src/backend/shared/__tests__/validate-variable-type.test.ts
index c231c30ae..f9b6fe152 100644
--- a/src2/backend/shared/__tests__/validate-variable-type.test.ts
+++ b/src/backend/shared/__tests__/validate-variable-type.test.ts
@@ -1,4 +1,4 @@
-import { validateVariableType, getVariableRestrictionType } from '../validate-variable-type'
+import { getVariableRestrictionType, validateVariableType } from '../validate-variable-type'
 
 describe('validateVariableType', () => {
   it('returns valid for exact type match', () => {
@@ -91,6 +91,6 @@ describe('getVariableRestrictionType', () => {
     const result = getVariableRestrictionType('ANY_STRING')
     expect(result.definition).toBe('base-type')
     expect(Array.isArray(result.values)).toBe(true)
-    expect((result.values as string[])).toContain('string')
+    expect(result.values as string[]).toContain('string')
   })
 })
diff --git a/src/backend/shared/debug/index.ts b/src/backend/shared/debug/index.ts
new file mode 100644
index 000000000..8cc69ef57
--- /dev/null
+++ b/src/backend/shared/debug/index.ts
@@ -0,0 +1,2 @@
+export { ModbusRtuTransport } from './modbus-rtu-transport'
+export type { DebugConnectionType, DebugSetResult, DebugTransport, DebugTransportResult } from './types'
diff --git a/src2/frontend/services/debug/transports/modbus-rtu-transport.ts b/src/backend/shared/debug/modbus-rtu-transport.ts
similarity index 88%
rename from src2/frontend/services/debug/transports/modbus-rtu-transport.ts
rename to src/backend/shared/debug/modbus-rtu-transport.ts
index 677d10f37..180ee4c43 100644
--- a/src2/frontend/services/debug/transports/modbus-rtu-transport.ts
+++ b/src/backend/shared/debug/modbus-rtu-transport.ts
@@ -9,9 +9,9 @@
  * VirtualSerialPort + ModbusRtuClient pair (MainProcessBridge lines 894-909).
  */
 
-import type { DebugTransport, DebugTransportResult, DebugSetResult } from '../types'
-import { simulatorService } from '../../simulator'
-import { hexToBytes, bytesToHex } from '../../../utils/hex'
+import { bytesToHex, hexToBytes } from '../../../frontend/utils/hex'
+import { simulatorService } from '../simulator'
+import type { DebugSetResult, DebugTransport, DebugTransportResult } from './types'
 
 export class ModbusRtuTransport implements DebugTransport {
   async connect(): Promise<void> {
diff --git a/src2/frontend/services/debug/types.ts b/src/backend/shared/debug/types.ts
similarity index 91%
rename from src2/frontend/services/debug/types.ts
rename to src/backend/shared/debug/types.ts
index a2f910a9f..f09ece949 100644
--- a/src2/frontend/services/debug/types.ts
+++ b/src/backend/shared/debug/types.ts
@@ -5,7 +5,7 @@
  * Mirrors the implicit interface from openplc-editor where ModbusTcpClient,
  * ModbusRtuClient, and WebSocketDebugClient all implement the same methods.
  *
- * openplc-web transports: ModbusRtuTransport (simulator), WebRTCTransport, HttpTransport.
+ * openplc-web transports: ModbusRtuTransport (simulator), ModbusDataChannelTransport (WebRTC), HttpTransport.
  */
 
 export type DebugConnectionType = 'webrtc' | 'http' | 'simulator'
diff --git a/src/backend/shared/simulator/index.ts b/src/backend/shared/simulator/index.ts
new file mode 100644
index 000000000..2fb040b7e
--- /dev/null
+++ b/src/backend/shared/simulator/index.ts
@@ -0,0 +1,6 @@
+export { simulatorService } from './simulator-service'
+export { SimulatorModule } from './simulator-module'
+export { VirtualSerialPort } from './virtual-serial-port'
+export { ModbusRtuClient } from './modbus-rtu-client'
+export type { SerialPortLike } from './modbus-rtu-client'
+export { ModbusFunctionCode, ModbusDebugResponse } from './modbus-types'
diff --git a/src/backend/shared/simulator/modbus-rtu-client.ts b/src/backend/shared/simulator/modbus-rtu-client.ts
new file mode 100644
index 000000000..6632ec8c8
--- /dev/null
+++ b/src/backend/shared/simulator/modbus-rtu-client.ts
@@ -0,0 +1,444 @@
+import { ModbusDebugResponse, ModbusFunctionCode } from './modbus-types'
+
+export interface SerialPortLike {
+  isOpen: boolean
+  open(): void
+  close(): void
+  write(data: Uint8Array, callback?: (err?: Error | null) => void): void
+  flush(callback?: (err?: Error | null) => void): void
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event: string, listener: (...args: any[]) => void): void
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  once(event: string, listener: (...args: any[]) => void): void
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  removeListener(event: string, listener: (...args: any[]) => void): void
+  removeAllListeners(event?: string): void
+}
+
+interface ModbusRtuClientOptions {
+  slaveId: number
+  timeout: number
+  serialPort: SerialPortLike
+}
+
+const MD5_REQUEST_MAX_RETRIES = 3
+const MD5_REQUEST_RETRY_DELAY_MS = 500
+
+const FRAME_COMPLETE_TIMEOUT_MS = 10
+
+// ---------------------------------------------------------------------------
+// Uint8Array helpers (replacing Node.js Buffer)
+// ---------------------------------------------------------------------------
+
+function allocBytes(size: number): Uint8Array {
+  return new Uint8Array(size)
+}
+
+function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
+  const result = new Uint8Array(a.length + b.length)
+  result.set(a, 0)
+  result.set(b, a.length)
+  return result
+}
+
+function readUint8(buf: Uint8Array, offset: number): number {
+  return buf[offset]
+}
+
+function writeUint8(buf: Uint8Array, offset: number, value: number): void {
+  buf[offset] = value
+}
+
+function readUint16BE(buf: Uint8Array, offset: number): number {
+  return (buf[offset] << 8) | buf[offset + 1]
+}
+
+function writeUint16BE(buf: Uint8Array, offset: number, value: number): void {
+  buf[offset] = (value >>> 8) & 0xff
+  buf[offset + 1] = value & 0xff
+}
+
+function readUint32BE(buf: Uint8Array, offset: number): number {
+  return ((buf[offset] << 24) | (buf[offset + 1] << 16) | (buf[offset + 2] << 8) | buf[offset + 3]) >>> 0
+}
+
+// ---------------------------------------------------------------------------
+// Modbus RTU Client (web-compatible)
+// ---------------------------------------------------------------------------
+
+export class ModbusRtuClient {
+  private slaveId: number
+  private timeout: number
+  private serialPort: SerialPortLike | null = null
+  private injectedSerialPort: SerialPortLike
+
+  private static readonly CRC_HI_TABLE = [
+    0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80,
+    0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1,
+    0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01,
+    0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40,
+    0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81,
+    0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
+    0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00,
+    0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
+    0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80,
+    0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
+    0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01,
+    0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
+    0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80,
+    0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
+  ]
+
+  private static readonly CRC_LO_TABLE = [
+    0x00, 0xc0, 0xc1, 0x01, 0xc3, 0x03, 0x02, 0xc2, 0xc6, 0x06, 0x07, 0xc7, 0x05, 0xc5, 0xc4, 0x04, 0xcc, 0x0c, 0x0d,
+    0xcd, 0x0f, 0xcf, 0xce, 0x0e, 0x0a, 0xca, 0xcb, 0x0b, 0xc9, 0x09, 0x08, 0xc8, 0xd8, 0x18, 0x19, 0xd9, 0x1b, 0xdb,
+    0xda, 0x1a, 0x1e, 0xde, 0xdf, 0x1f, 0xdd, 0x1d, 0x1c, 0xdc, 0x14, 0xd4, 0xd5, 0x15, 0xd7, 0x17, 0x16, 0xd6, 0xd2,
+    0x12, 0x13, 0xd3, 0x11, 0xd1, 0xd0, 0x10, 0xf0, 0x30, 0x31, 0xf1, 0x33, 0xf3, 0xf2, 0x32, 0x36, 0xf6, 0xf7, 0x37,
+    0xf5, 0x35, 0x34, 0xf4, 0x3c, 0xfc, 0xfd, 0x3d, 0xff, 0x3f, 0x3e, 0xfe, 0xfa, 0x3a, 0x3b, 0xfb, 0x39, 0xf9, 0xf8,
+    0x38, 0x28, 0xe8, 0xe9, 0x29, 0xeb, 0x2b, 0x2a, 0xea, 0xee, 0x2e, 0x2f, 0xef, 0x2d, 0xed, 0xec, 0x2c, 0xe4, 0x24,
+    0x25, 0xe5, 0x27, 0xe7, 0xe6, 0x26, 0x22, 0xe2, 0xe3, 0x23, 0xe1, 0x21, 0x20, 0xe0, 0xa0, 0x60, 0x61, 0xa1, 0x63,
+    0xa3, 0xa2, 0x62, 0x66, 0xa6, 0xa7, 0x67, 0xa5, 0x65, 0x64, 0xa4, 0x6c, 0xac, 0xad, 0x6d, 0xaf, 0x6f, 0x6e, 0xae,
+    0xaa, 0x6a, 0x6b, 0xab, 0x69, 0xa9, 0xa8, 0x68, 0x78, 0xb8, 0xb9, 0x79, 0xbb, 0x7b, 0x7a, 0xba, 0xbe, 0x7e, 0x7f,
+    0xbf, 0x7d, 0xbd, 0xbc, 0x7c, 0xb4, 0x74, 0x75, 0xb5, 0x77, 0xb7, 0xb6, 0x76, 0x72, 0xb2, 0xb3, 0x73, 0xb1, 0x71,
+    0x70, 0xb0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9c,
+    0x5c, 0x5d, 0x9d, 0x5f, 0x9f, 0x9e, 0x5e, 0x5a, 0x9a, 0x9b, 0x5b, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
+    0x4b, 0x8b, 0x8a, 0x4a, 0x4e, 0x8e, 0x8f, 0x4f, 0x8d, 0x4d, 0x4c, 0x8c, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46,
+    0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40,
+  ]
+
+  constructor(options: ModbusRtuClientOptions) {
+    this.slaveId = options.slaveId
+    this.timeout = options.timeout
+    this.injectedSerialPort = options.serialPort
+  }
+
+  private calculateCrc(buffer: Uint8Array): number {
+    let crcHi = 0xff
+    let crcLo = 0xff
+
+    for (let i = 0; i < buffer.length; i++) {
+      const index = crcHi ^ buffer[i]
+      crcHi = crcLo ^ ModbusRtuClient.CRC_HI_TABLE[index]
+      crcLo = ModbusRtuClient.CRC_LO_TABLE[index]
+    }
+
+    return (crcHi << 8) | crcLo
+  }
+
+  private assembleRequest(functionCode: number, data: Uint8Array): Uint8Array {
+    const frameWithoutCrc = allocBytes(2 + data.length)
+    writeUint8(frameWithoutCrc, 0, this.slaveId)
+    writeUint8(frameWithoutCrc, 1, functionCode)
+    frameWithoutCrc.set(data, 2)
+
+    const crc = this.calculateCrc(frameWithoutCrc)
+    const request = allocBytes(frameWithoutCrc.length + 2)
+    request.set(frameWithoutCrc, 0)
+    writeUint16BE(request, frameWithoutCrc.length, crc)
+
+    return request
+  }
+
+  async connect(): Promise<void> {
+    this.serialPort = this.injectedSerialPort
+    return new Promise((resolve, reject) => {
+      this.serialPort!.once('open', () => {
+        // Wait for firmware to complete setup() and initialize the USART.
+        // Matches ARDUINO_BOOTLOADER_DELAY_MS in the editor's ModbusRtuClient.
+        setTimeout(() => {
+          resolve()
+        }, 2500)
+      })
+      this.serialPort!.once('error', (err: unknown) => reject(err instanceof Error ? err : new Error(String(err))))
+      this.serialPort!.open()
+    })
+  }
+
+  disconnect(): void {
+    if (this.serialPort && this.serialPort.isOpen) {
+      this.serialPort.close()
+      this.serialPort = null
+    }
+  }
+
+  private flushInputBuffer(): Promise<void> {
+    return new Promise((resolve) => {
+      if (!this.serialPort || !this.serialPort.isOpen) {
+        resolve()
+        return
+      }
+
+      this.serialPort.flush((err?: Error | null) => {
+        if (err) {
+          console.warn('Warning: Failed to flush serial port:', err.message)
+        }
+        resolve()
+      })
+    })
+  }
+
+  private sendRequestMutex: Promise<void> = Promise.resolve()
+
+  private async sendRequest(request: Uint8Array): Promise<Uint8Array> {
+    return new Promise<Uint8Array>((resolve, reject) => {
+      this.sendRequestMutex = this.sendRequestMutex.then(
+        () => this.sendRequestImpl(request).then(resolve, reject),
+        () => this.sendRequestImpl(request).then(resolve, reject),
+      )
+    })
+  }
+
+  private async sendRequestImpl(request: Uint8Array): Promise<Uint8Array> {
+    if (!this.serialPort || !this.serialPort.isOpen) {
+      throw new Error('Serial port is not open')
+    }
+
+    await this.flushInputBuffer()
+
+    return new Promise((resolve, reject) => {
+      let responseBuffer = allocBytes(0)
+      let frameCompleteTimeout: ReturnType<typeof setTimeout> | null = null
+
+      const cleanup = () => {
+        this.serialPort?.removeListener('data', onData)
+        this.serialPort?.removeListener('error', onError)
+        if (frameCompleteTimeout) {
+          clearTimeout(frameCompleteTimeout)
+        }
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        cleanup()
+        reject(new Error('Request timeout'))
+      }, this.timeout)
+
+      const onData = (data: Uint8Array) => {
+        responseBuffer = concatBytes(responseBuffer, data)
+
+        if (frameCompleteTimeout) {
+          clearTimeout(frameCompleteTimeout)
+        }
+
+        frameCompleteTimeout = setTimeout(() => {
+          clearTimeout(timeoutHandle)
+          cleanup()
+
+          if (responseBuffer.length < 5) {
+            reject(new Error('Response too short'))
+            return
+          }
+
+          const receivedCrc = readUint16BE(responseBuffer, responseBuffer.length - 2)
+          const calculatedCrc = this.calculateCrc(responseBuffer.slice(0, responseBuffer.length - 2))
+
+          if (receivedCrc !== calculatedCrc) {
+            // OpenPLC debugger ignores CRC errors -- mismatch is non-fatal
+          }
+
+          const responseWithoutCrc = responseBuffer.slice(0, responseBuffer.length - 2)
+          const paddedResponse = allocBytes(6 + responseWithoutCrc.length)
+          // First 6 bytes are zeros (padding for TCP header compatibility)
+          paddedResponse.set(responseWithoutCrc, 6)
+
+          resolve(paddedResponse)
+        }, FRAME_COMPLETE_TIMEOUT_MS)
+      }
+
+      const onError = (error: unknown) => {
+        clearTimeout(timeoutHandle)
+        cleanup()
+        reject(error instanceof Error ? error : new Error(String(error)))
+      }
+
+      this.serialPort!.on('data', onData)
+      this.serialPort!.once('error', onError)
+      this.serialPort!.write(request, (error?: Error | null) => {
+        if (error) {
+          clearTimeout(timeoutHandle)
+          cleanup()
+          reject(error)
+        }
+      })
+    })
+  }
+
+  async getMd5Hash(): Promise<string> {
+    const functionCode = ModbusFunctionCode.DEBUG_GET_MD5
+    const endiannessCheck = 0xdead
+
+    const data = allocBytes(4)
+    writeUint16BE(data, 0, endiannessCheck)
+    writeUint8(data, 2, 0)
+    writeUint8(data, 3, 0)
+
+    const request = this.assembleRequest(functionCode, data)
+
+    let lastError: Error | null = null
+    for (let attempt = 0; attempt <= MD5_REQUEST_MAX_RETRIES; attempt++) {
+      try {
+        if (attempt > 0) {
+          await new Promise((resolve) => setTimeout(resolve, MD5_REQUEST_RETRY_DELAY_MS))
+        }
+
+        const response = await this.sendRequest(request)
+
+        if (response.length < 9) {
+          throw new Error('Invalid response: too short')
+        }
+
+        const functionCodeResponse = readUint8(response, 7)
+        const statusCode = readUint8(response, 8)
+
+        if (functionCodeResponse !== (ModbusFunctionCode.DEBUG_GET_MD5 as number)) {
+          throw new Error('Function code mismatch')
+        }
+
+        if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+          throw new Error(`Target returned error code: 0x${statusCode.toString(16)}`)
+        }
+
+        const md5Bytes = response.slice(9)
+        const md5String = new TextDecoder().decode(md5Bytes).trim()
+        return md5String
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error))
+        if (attempt < MD5_REQUEST_MAX_RETRIES) {
+          console.warn(`MD5 request attempt ${attempt + 1} failed: ${lastError.message}. Retrying...`)
+        }
+      }
+    }
+
+    throw Object.assign(new Error('Failed to get MD5 hash after retries'), { cause: lastError })
+  }
+
+  async getVariablesList(variableIndexes: number[]): Promise<{
+    success: boolean
+    tick?: number
+    lastIndex?: number
+    data?: Uint8Array
+    error?: string
+  }> {
+    try {
+      const functionCode = ModbusFunctionCode.DEBUG_GET_LIST
+      const numIndexes = variableIndexes.length
+
+      const data = allocBytes(2 + 2 * numIndexes)
+      writeUint16BE(data, 0, numIndexes)
+
+      for (let i = 0; i < numIndexes; i++) {
+        writeUint16BE(data, 2 + i * 2, variableIndexes[i])
+      }
+
+      const request = this.assembleRequest(functionCode, data)
+      const response = await this.sendRequest(request)
+
+      if (response.length < 9) {
+        return { success: false, error: `Invalid response: too short (${response.length} bytes, need at least 9)` }
+      }
+
+      const functionCodeResponse = readUint8(response, 7)
+      const statusCode = readUint8(response, 8)
+
+      if (functionCodeResponse !== (ModbusFunctionCode.DEBUG_GET_LIST as number)) {
+        return { success: false, error: 'Function code mismatch' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_BOUNDS' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_MEMORY' }
+      }
+
+      if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+        return { success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` }
+      }
+
+      if (response.length < 17) {
+        return {
+          success: false,
+          error: `Incomplete success response (${response.length} bytes, expected at least 17)`,
+        }
+      }
+
+      const lastIndex = readUint16BE(response, 9)
+      const tick = readUint32BE(response, 11)
+      const responseSize = readUint16BE(response, 15)
+
+      if (response.length < 17 + responseSize) {
+        return {
+          success: false,
+          error: `Incomplete variable data (expected ${responseSize} bytes, got ${response.length - 17})`,
+        }
+      }
+
+      const variableData = response.slice(17, 17 + responseSize)
+
+      return {
+        success: true,
+        tick,
+        lastIndex,
+        data: variableData,
+      }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  async setVariable(
+    variableIndex: number,
+    force: boolean,
+    valueBuffer?: Uint8Array,
+  ): Promise<{
+    success: boolean
+    error?: string
+  }> {
+    try {
+      const functionCode = ModbusFunctionCode.DEBUG_SET
+
+      const dataLength = force && valueBuffer ? valueBuffer.length : 1
+      const data = allocBytes(5 + dataLength)
+
+      writeUint16BE(data, 0, variableIndex)
+      writeUint8(data, 2, force ? 1 : 0)
+      writeUint16BE(data, 3, dataLength)
+
+      if (force && valueBuffer) {
+        data.set(valueBuffer, 5)
+      } else {
+        writeUint8(data, 5, 0)
+      }
+
+      const request = this.assembleRequest(functionCode, data)
+      const response = await this.sendRequest(request)
+
+      if (response.length < 9) {
+        return { success: false, error: `Invalid response: too short (${response.length} bytes, need at least 9)` }
+      }
+
+      const functionCodeResponse = readUint8(response, 7)
+      const statusCode = readUint8(response, 8)
+
+      if (functionCodeResponse !== (ModbusFunctionCode.DEBUG_SET as number)) {
+        return { success: false, error: 'Function code mismatch' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_BOUNDS as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_BOUNDS' }
+      }
+
+      if (statusCode === (ModbusDebugResponse.ERROR_OUT_OF_MEMORY as number)) {
+        return { success: false, error: 'ERROR_OUT_OF_MEMORY' }
+      }
+
+      if (statusCode !== (ModbusDebugResponse.SUCCESS as number)) {
+        return { success: false, error: `Unknown error code: 0x${statusCode.toString(16)}` }
+      }
+
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  }
+}
diff --git a/src/backend/shared/simulator/modbus-types.ts b/src/backend/shared/simulator/modbus-types.ts
new file mode 100644
index 000000000..a2ac377f6
--- /dev/null
+++ b/src/backend/shared/simulator/modbus-types.ts
@@ -0,0 +1,13 @@
+export enum ModbusFunctionCode {
+  DEBUG_INFO = 0x41,
+  DEBUG_SET = 0x42,
+  DEBUG_GET = 0x43,
+  DEBUG_GET_LIST = 0x44,
+  DEBUG_GET_MD5 = 0x45,
+}
+
+export enum ModbusDebugResponse {
+  SUCCESS = 0x7e,
+  ERROR_OUT_OF_BOUNDS = 0x81,
+  ERROR_OUT_OF_MEMORY = 0x82,
+}
diff --git a/src/backend/shared/simulator/simulator-module.ts b/src/backend/shared/simulator/simulator-module.ts
new file mode 100644
index 000000000..80894882d
--- /dev/null
+++ b/src/backend/shared/simulator/simulator-module.ts
@@ -0,0 +1,325 @@
+import {
+  AVRClock,
+  avrInstruction,
+  AVRTimer,
+  AVRUSART,
+  clockConfig,
+  CPU,
+  timer0Config,
+  timer1Config,
+  timer2Config,
+  usart0Config,
+} from 'avr8js'
+
+// ATmega2560 specs
+const CPU_FREQ_HZ = 16_000_000
+const FLASH_SIZE_BYTES = 256 * 1024
+// Expanded SRAM: fill the entire 16-bit address space (64 KB).
+// The CPU constructor adds 0x100 internally for registers + standard I/O (0x00-0xFF).
+// We supply 0xFF00 (65280) to cover extended I/O (0x100-0x1FF) plus usable SRAM
+// (0x200-0xFFFF = 65024 bytes ~ 63.5 KB). This is the maximum addressable with
+// AVR's 16-bit data pointers. The linker flags in hals.json tell avr-gcc about
+// the expanded space so it actually uses it.
+const SRAM_BYTES = 0xff00
+
+// SLEEP opcode -- the firmware inserts `__asm volatile("sleep")` at the end
+// of each loop() iteration. We detect it before execution and fast-forward
+// the clock to the next timer event, avoiding millions of idle cycles.
+const SLEEP_OPCODE = 0x9588
+
+// Nanoseconds per CPU cycle at 16 MHz
+const CYCLE_NS = 1e9 / CPU_FREQ_HZ // 62.5 ns
+
+// Maximum real (non-skipped) instructions per batch. SLEEP fast-forwards
+// don't count against this budget, so idle periods are essentially free.
+const MAX_REAL_INSTRUCTIONS = 100_000
+
+// Maximum simulated time per batch (in CPU cycles). Prevents runaway
+// batches when the firmware is mostly idle (SLEEP fast-forwards could
+// cover seconds of sim time without hitting the instruction limit).
+const MAX_SIM_CYCLES_PER_BATCH = CPU_FREQ_HZ / 10 // 100ms
+
+// ---------------------------------------------------------------------------
+// ATmega2560 peripheral configs -- register addresses are identical to the
+// ATmega328p defaults exported by avr8js, only the interrupt vector addresses
+// differ because ATmega2560 has more interrupt sources.
+// Vector addresses are word addresses matching the datasheet.
+// ---------------------------------------------------------------------------
+
+// ATmega2560 vector addresses (word addresses).
+// IMPORTANT: ATmega2560 has TIMER1_COMPC at vector 19 (word 0x26) which
+// ATmega328p lacks. This shifts Timer1 OVF and all subsequent vectors by 2
+// compared to a naive mapping from the ATmega328p table.
+// Vectors verified against avr-objdump of compiled firmware.
+const mega2560Timer0Config = {
+  ...timer0Config,
+  compAInterrupt: 0x2a, // vector 21
+  compBInterrupt: 0x2c, // vector 22
+  ovfInterrupt: 0x2e, // vector 23
+}
+
+const mega2560Timer1Config = {
+  ...timer1Config,
+  captureInterrupt: 0x20, // vector 16
+  compAInterrupt: 0x22, // vector 17
+  compBInterrupt: 0x24, // vector 18
+  // Note: TIMER1_COMPC at vector 19 (0x26) not modeled by avr8js
+  ovfInterrupt: 0x28, // vector 20
+}
+
+const mega2560Timer2Config = {
+  ...timer2Config,
+  compAInterrupt: 0x1a, // vector 13
+  compBInterrupt: 0x1c, // vector 14
+  ovfInterrupt: 0x1e, // vector 15
+}
+
+const mega2560Usart0Config = {
+  ...usart0Config,
+  rxCompleteInterrupt: 0x32, // vector 25
+  dataRegisterEmptyInterrupt: 0x34, // vector 26
+  txCompleteInterrupt: 0x36, // vector 27
+}
+
+// ---------------------------------------------------------------------------
+// Intel HEX parser
+// ---------------------------------------------------------------------------
+
+/**
+ * Parses an Intel HEX string into a Uint16Array suitable for the AVR CPU.
+ * Supports record types 00 (data), 01 (EOF), 02 (extended segment address),
+ * and 04 (extended linear address) for flash sizes >64 KB.
+ */
+function parseIntelHex(hex: string, flashSizeBytes: number): Uint16Array {
+  const flash = new Uint8Array(flashSizeBytes)
+  let extendedAddress = 0
+
+  for (const rawLine of hex.split('\n')) {
+    const line = rawLine.trim()
+    if (!line.startsWith(':')) continue
+
+    const byteCount = parseInt(line.substring(1, 3), 16)
+    const address = parseInt(line.substring(3, 7), 16)
+    const recordType = parseInt(line.substring(7, 9), 16)
+
+    if (recordType === 0x00) {
+      // Data record
+      const fullAddress = extendedAddress + address
+      for (let i = 0; i < byteCount; i++) {
+        const byte = parseInt(line.substring(9 + i * 2, 11 + i * 2), 16)
+        if (fullAddress + i < flashSizeBytes) {
+          flash[fullAddress + i] = byte
+        }
+      }
+    } else if (recordType === 0x01) {
+      // End of file
+      break
+    } else if (recordType === 0x02) {
+      // Extended segment address (address << 4)
+      extendedAddress = parseInt(line.substring(9, 13), 16) << 4
+    } else if (recordType === 0x04) {
+      // Extended linear address (upper 16 bits)
+      extendedAddress = parseInt(line.substring(9, 13), 16) << 16
+    }
+  }
+
+  // Convert byte array to 16-bit little-endian words for the AVR CPU
+  const words = new Uint16Array(flashSizeBytes / 2)
+  for (let i = 0; i < flashSizeBytes; i += 2) {
+    words[i / 2] = flash[i] | (flash[i + 1] << 8)
+  }
+  return words
+}
+
+// ---------------------------------------------------------------------------
+// Simulator module
+// ---------------------------------------------------------------------------
+
+/**
+ * Manages the avr8js ATmega2560 emulator lifecycle in the browser.
+ *
+ * The firmware is compiled with SIMULATOR_MODE which inserts a SLEEP
+ * instruction at the end of each loop() iteration. When the CPU hits SLEEP,
+ * the execution loop fast-forwards the clock to the next timer event
+ * (typically Timer0 overflow at ~1 ms), avoiding millions of wasted
+ * busy-wait instruction cycles and allowing the simulation to run at
+ * near real-time speed.
+ */
+export class SimulatorModule {
+  private cpu: CPU | null = null
+  private running = false
+  private timerHandle: ReturnType<typeof setTimeout> | null = null
+
+  // Peripherals (kept alive so they process register read/write hooks)
+  private timer0: AVRTimer | null = null
+  private timer1: AVRTimer | null = null
+  private timer2: AVRTimer | null = null
+  private usart0: AVRUSART | null = null
+  private clock: AVRClock | null = null
+
+  // RX byte queue -- avr8js USART accepts one byte at a time (returns false
+  // while rxBusy). Incoming bytes are queued and drained after the firmware
+  // reads UDR (via the read hook), ensuring the RXC ISR processes each byte
+  // before the next one overwrites rxByte.
+  private rxQueue: number[] = []
+
+  // Wall-clock pacing
+  private wallStartMs = 0
+  private simStartCycles = 0
+
+  /** Callback fired for each byte transmitted by the emulated USART0 */
+  onUartByte: ((byte: number) => void) | null = null
+
+  /**
+   * Loads Intel HEX firmware content and starts the emulated ATmega2560.
+   * Stops any currently running emulation first.
+   *
+   * @param hexContent - Raw Intel HEX string (caller is responsible for reading the file)
+   */
+  loadAndRun(hexContent: string): void {
+    this.stop()
+
+    const progMem = parseIntelHex(hexContent, FLASH_SIZE_BYTES)
+
+    this.cpu = new CPU(progMem, SRAM_BYTES)
+
+    // Instantiate peripherals -- they register read/write hooks on the CPU
+    this.timer0 = new AVRTimer(this.cpu, mega2560Timer0Config)
+    this.timer1 = new AVRTimer(this.cpu, mega2560Timer1Config)
+    this.timer2 = new AVRTimer(this.cpu, mega2560Timer2Config)
+    this.usart0 = new AVRUSART(this.cpu, mega2560Usart0Config, CPU_FREQ_HZ)
+    this.clock = new AVRClock(this.cpu, CPU_FREQ_HZ, clockConfig)
+
+    // Wrap the UDR read hook so that after the firmware reads a received byte,
+    // the next queued byte is fed into the USART. This ensures the RXC ISR
+    // has consumed the current byte before the next one arrives, preventing
+    // rxByte from being silently overwritten when interrupts are disabled
+    // (e.g. while the CPU is inside another ISR like Timer0).
+    const udrAddr = mega2560Usart0Config.UDR
+    const originalUdrReadHook = this.cpu.readHooks[udrAddr]
+    this.cpu.readHooks[udrAddr] = (addr: number) => {
+      const result = originalUdrReadHook?.(addr)
+      this.drainRxQueue()
+      return result
+    }
+
+    // Wire USART0 TX to the Modbus RTU bridge callback
+    this.usart0.onByteTransmit = (byte: number) => {
+      this.onUartByte?.(byte)
+    }
+
+    // Begin execution
+    this.running = true
+    this.wallStartMs = performance.now()
+    this.simStartCycles = 0
+    this.executeBatch()
+  }
+
+  /**
+   * Runs a batch of CPU instructions, then reschedules.
+   *
+   * When the CPU hits a SLEEP opcode, the loop fast-forwards the clock to
+   * the next scheduled timer event instead of stepping through idle cycles.
+   * SLEEP fast-forwards don't count against the instruction budget, so idle
+   * periods between scan cycles are essentially free.
+   *
+   * After each batch, compares simulated time against wall time:
+   * - If sim is ahead: schedules next batch with setTimeout(delay) to
+   *   let wall time catch up, keeping timers accurate.
+   * - If sim is behind or on time: schedules with setTimeout(0).
+   */
+  private executeBatch = (): void => {
+    if (!this.running || !this.cpu) return
+
+    this.timerHandle = null
+    const { cpu } = this
+
+    // Kick-start the RX delivery chain if bytes are queued.
+    if (this.rxQueue.length > 0 && this.usart0) {
+      const byte = this.rxQueue[0]
+      if (this.usart0.writeByte(byte)) {
+        this.rxQueue.shift()
+      }
+    }
+
+    const simCycleCap = cpu.cycles + MAX_SIM_CYCLES_PER_BATCH
+    let realCount = 0
+
+    while (this.running && realCount < MAX_REAL_INSTRUCTIONS && cpu.cycles < simCycleCap) {
+      if (cpu.progMem[cpu.pc] === SLEEP_OPCODE) {
+        // Execute the SLEEP instruction (advances PC, adds 1 cycle)
+        avrInstruction(cpu)
+        // Fast-forward to next scheduled clock event.
+        // NOTE: nextClockEvent is private in avr8js -- pinned to 0.20.0 in package.json.
+        // If upgrading avr8js, verify this field still exists and has a `cycles` property.
+        const nextEvent = (cpu as unknown as { nextClockEvent: { cycles: number } | null }).nextClockEvent
+        if (nextEvent && nextEvent.cycles > cpu.cycles) {
+          cpu.cycles = nextEvent.cycles
+        }
+        cpu.tick()
+      } else {
+        avrInstruction(cpu)
+        cpu.tick()
+        realCount++
+      }
+    }
+
+    if (this.running) {
+      // Pace simulation to wall time
+      const simElapsedMs = ((cpu.cycles - this.simStartCycles) * CYCLE_NS) / 1e6
+      const wallElapsedMs = performance.now() - this.wallStartMs
+      const aheadMs = simElapsedMs - wallElapsedMs
+      this.timerHandle = setTimeout(this.executeBatch, aheadMs > 1 ? Math.floor(aheadMs) : 0)
+    }
+  }
+
+  /** Send a byte to the emulated USART0 RX (host -> device) */
+  feedByte(byte: number): void {
+    this.rxQueue.push(byte)
+    if (this.rxQueue.length === 1 && this.usart0) {
+      const accepted = this.usart0.writeByte(byte)
+      if (accepted) {
+        this.rxQueue.shift()
+      }
+    }
+  }
+
+  /**
+   * Tries to deliver the next queued byte to the USART. Called after the
+   * firmware reads UDR (via the read hook). This pacing ensures the RXC ISR
+   * processes each byte before the next one arrives, avoiding data loss
+   * from rxByte overwrites.
+   */
+  private drainRxQueue(): void {
+    if (!this.usart0 || this.rxQueue.length === 0) return
+    const byte = this.rxQueue[0]
+    if (this.usart0.writeByte(byte)) {
+      this.rxQueue.shift()
+    }
+  }
+
+  /** Stop the emulator and release resources */
+  stop(): void {
+    this.running = false
+    if (this.timerHandle !== null) {
+      clearTimeout(this.timerHandle)
+      this.timerHandle = null
+    }
+    if (this.usart0) {
+      this.usart0.onByteTransmit = null
+      this.usart0 = null
+    }
+    this.rxQueue = []
+    this.cpu = null
+    this.timer0 = null
+    this.timer1 = null
+    this.timer2 = null
+    this.clock = null
+    this.onUartByte = null
+  }
+
+  /** Check if the emulator is currently running */
+  isRunning(): boolean {
+    return this.running
+  }
+}
diff --git a/src2/frontend/services/simulator/simulator-service.ts b/src/backend/shared/simulator/simulator-service.ts
similarity index 95%
rename from src2/frontend/services/simulator/simulator-service.ts
rename to src/backend/shared/simulator/simulator-service.ts
index 2b0620940..27d3aadf0 100644
--- a/src2/frontend/services/simulator/simulator-service.ts
+++ b/src/backend/shared/simulator/simulator-service.ts
@@ -94,11 +94,7 @@ class SimulatorServiceFacade {
   /**
    * Force or release a variable in the simulator.
    */
-  async setVariable(
-    index: number,
-    force: boolean,
-    valueHex?: string,
-  ): Promise<{ success: boolean; error?: string }> {
+  async setVariable(index: number, force: boolean, valueHex?: string): Promise<{ success: boolean; error?: string }> {
     if (!this.port) return { success: false, error: 'SimulatorPort not registered' }
     return this.port.setDebugVariable(index, force, valueHex)
   }
diff --git a/src/backend/shared/simulator/virtual-serial-port.ts b/src/backend/shared/simulator/virtual-serial-port.ts
new file mode 100644
index 000000000..a7f353509
--- /dev/null
+++ b/src/backend/shared/simulator/virtual-serial-port.ts
@@ -0,0 +1,87 @@
+import { SimulatorModule } from './simulator-module'
+
+/**
+ * A virtual serial port that mimics the `serialport` npm package's event-based API.
+ * Routes bytes through SimulatorModule's UART bridge, allowing the existing
+ * ModbusRtuClient to communicate with the avr8js emulator unchanged.
+ *
+ * Uses manual listener arrays instead of Node.js EventEmitter for browser compatibility.
+ */
+export class VirtualSerialPort {
+  public isOpen = false
+  private simulator: SimulatorModule
+
+  private dataListeners: ((data: Uint8Array) => void)[] = []
+  private openListeners: (() => void)[] = []
+  private errorListeners: ((err: Error) => void)[] = []
+
+  constructor(simulator: SimulatorModule) {
+    this.simulator = simulator
+  }
+
+  open(): void {
+    this.isOpen = true
+    // Wire UART RX: bytes from emulated device -> ModbusRtuClient via 'data' events
+    this.simulator.onUartByte = (byte: number) => {
+      const buf = new Uint8Array([byte])
+      for (const cb of this.dataListeners) {
+        cb(buf)
+      }
+    }
+    // Emit 'open' asynchronously (matches real SerialPort behavior)
+    queueMicrotask(() => {
+      for (const cb of this.openListeners) {
+        cb()
+      }
+    })
+  }
+
+  write(data: Uint8Array, callback?: (err?: Error | null) => void): void {
+    // Send each byte to the emulated UART TX (host -> device)
+    for (const byte of data) {
+      this.simulator.feedByte(byte)
+    }
+    callback?.(null)
+  }
+
+  flush(callback?: (err?: Error | null) => void): void {
+    // No hardware buffer to flush in virtual port
+    callback?.(null)
+  }
+
+  close(): void {
+    this.isOpen = false
+    this.simulator.onUartByte = null
+    this.removeAllListeners()
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event: string, listener: (...args: any[]) => void): void {
+    if (event === 'data') this.dataListeners.push(listener)
+    else if (event === 'open') this.openListeners.push(listener)
+    else if (event === 'error') this.errorListeners.push(listener)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  once(event: string, listener: (...args: any[]) => void): void {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const wrapper = (...args: any[]) => {
+      this.removeListener(event, wrapper)
+      listener(...args)
+    }
+    this.on(event, wrapper)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  removeListener(event: string, listener: (...args: any[]) => void): void {
+    if (event === 'data') this.dataListeners = this.dataListeners.filter((cb) => cb !== listener)
+    else if (event === 'open') this.openListeners = this.openListeners.filter((cb) => cb !== listener)
+    else if (event === 'error') this.errorListeners = this.errorListeners.filter((cb) => cb !== listener)
+  }
+
+  removeAllListeners(event?: string): void {
+    if (!event || event === 'data') this.dataListeners = []
+    if (!event || event === 'open') this.openListeners = []
+    if (!event || event === 'error') this.errorListeners = []
+  }
+}
diff --git a/src/renderer/styles/globals.css b/src/backend/styles/globals.css
similarity index 100%
rename from src/renderer/styles/globals.css
rename to src/backend/styles/globals.css
diff --git a/src/renderer/assets/folder.png b/src/frontend/assets/folder.png
similarity index 100%
rename from src/renderer/assets/folder.png
rename to src/frontend/assets/folder.png
diff --git a/src2/frontend/assets/icons/Fallback.tsx b/src/frontend/assets/icons/Fallback.tsx
similarity index 99%
rename from src2/frontend/assets/icons/Fallback.tsx
rename to src/frontend/assets/icons/Fallback.tsx
index 5658a7587..1bbdadee2 100644
--- a/src2/frontend/assets/icons/Fallback.tsx
+++ b/src/frontend/assets/icons/Fallback.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../utils/cn'
+
 type IFallBackIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src/renderer/assets/icons/Types/iconTypes.tsx b/src/frontend/assets/icons/Types/iconTypes.tsx
similarity index 100%
rename from src/renderer/assets/icons/Types/iconTypes.tsx
rename to src/frontend/assets/icons/Types/iconTypes.tsx
diff --git a/src/renderer/assets/icons/about/logo.svg b/src/frontend/assets/icons/about/logo.svg
similarity index 100%
rename from src/renderer/assets/icons/about/logo.svg
rename to src/frontend/assets/icons/about/logo.svg
diff --git a/src/renderer/assets/icons/base/left-arrow.svg b/src/frontend/assets/icons/base/left-arrow.svg
similarity index 100%
rename from src/renderer/assets/icons/base/left-arrow.svg
rename to src/frontend/assets/icons/base/left-arrow.svg
diff --git a/src/renderer/assets/icons/base/right-arrow.svg b/src/frontend/assets/icons/base/right-arrow.svg
similarity index 100%
rename from src/renderer/assets/icons/base/right-arrow.svg
rename to src/frontend/assets/icons/base/right-arrow.svg
diff --git a/src/renderer/assets/icons/flow/Coil.tsx b/src/frontend/assets/icons/flow/Coil.tsx
similarity index 100%
rename from src/renderer/assets/icons/flow/Coil.tsx
rename to src/frontend/assets/icons/flow/Coil.tsx
diff --git a/src/renderer/assets/icons/flow/Contact.tsx b/src/frontend/assets/icons/flow/Contact.tsx
similarity index 100%
rename from src/renderer/assets/icons/flow/Contact.tsx
rename to src/frontend/assets/icons/flow/Contact.tsx
diff --git a/src/renderer/assets/icons/flow/Placeholder.tsx b/src/frontend/assets/icons/flow/Placeholder.tsx
similarity index 100%
rename from src/renderer/assets/icons/flow/Placeholder.tsx
rename to src/frontend/assets/icons/flow/Placeholder.tsx
diff --git a/src2/frontend/assets/icons/interface/Arrow.tsx b/src/frontend/assets/icons/interface/Arrow.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Arrow.tsx
rename to src/frontend/assets/icons/interface/Arrow.tsx
index a2f956ea2..ef3a524a0 100644
--- a/src2/frontend/assets/icons/interface/Arrow.tsx
+++ b/src/frontend/assets/icons/interface/Arrow.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithRef, ElementType } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IArrowIconProps = ComponentPropsWithRef<'svg'> & {
   variant?: 'default' | 'primary' | 'secondary'
   direction?: 'up' | 'down' | 'left' | 'right'
diff --git a/src2/frontend/assets/icons/interface/ArrowButton.tsx b/src/frontend/assets/icons/interface/ArrowButton.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/ArrowButton.tsx
rename to src/frontend/assets/icons/interface/ArrowButton.tsx
index f83e09720..c5684b94b 100644
--- a/src2/frontend/assets/icons/interface/ArrowButton.tsx
+++ b/src/frontend/assets/icons/interface/ArrowButton.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithRef, ElementType } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IArrowButtonIconProps = ComponentPropsWithRef<'svg'> & {
   variant?: 'default' | 'primary' | 'secondary'
   direction?: 'up' | 'down' | 'left' | 'right'
diff --git a/src2/frontend/assets/icons/interface/ArrowUp.tsx b/src/frontend/assets/icons/interface/ArrowUp.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/ArrowUp.tsx
rename to src/frontend/assets/icons/interface/ArrowUp.tsx
index e2b94f931..c5c4f1f17 100644
--- a/src2/frontend/assets/icons/interface/ArrowUp.tsx
+++ b/src/frontend/assets/icons/interface/ArrowUp.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IArrowUpIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Book.tsx b/src/frontend/assets/icons/interface/Book.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Book.tsx
rename to src/frontend/assets/icons/interface/Book.tsx
index 83c99f2c4..f425300a8 100644
--- a/src2/frontend/assets/icons/interface/Book.tsx
+++ b/src/frontend/assets/icons/interface/Book.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IBookIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src/renderer/assets/icons/interface/Broom.tsx b/src/frontend/assets/icons/interface/Broom.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Broom.tsx
rename to src/frontend/assets/icons/interface/Broom.tsx
diff --git a/src2/frontend/assets/icons/interface/Close.tsx b/src/frontend/assets/icons/interface/Close.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Close.tsx
rename to src/frontend/assets/icons/interface/Close.tsx
index c2af6b036..f1af66ded 100644
--- a/src2/frontend/assets/icons/interface/Close.tsx
+++ b/src/frontend/assets/icons/interface/Close.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const CloseIcon = (props: ComponentPropsWithoutRef<'svg'>) => {
   const { className, ...rest } = props
   return (
diff --git a/src2/frontend/assets/icons/interface/CodeIcon.tsx b/src/frontend/assets/icons/interface/CodeIcon.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/CodeIcon.tsx
rename to src/frontend/assets/icons/interface/CodeIcon.tsx
index 2e1f20ebe..dcab97d35 100644
--- a/src2/frontend/assets/icons/interface/CodeIcon.tsx
+++ b/src/frontend/assets/icons/interface/CodeIcon.tsx
@@ -1,6 +1,7 @@
+import { ComponentProps } from 'react'
+
 import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-import { ComponentProps } from 'react'
 
 type IProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
diff --git a/src2/frontend/assets/icons/interface/Comment.tsx b/src/frontend/assets/icons/interface/Comment.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Comment.tsx
rename to src/frontend/assets/icons/interface/Comment.tsx
index 152ac3e88..19990fd1c 100644
--- a/src2/frontend/assets/icons/interface/Comment.tsx
+++ b/src/frontend/assets/icons/interface/Comment.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const CommentIcon = (props: ComponentPropsWithoutRef<'svg'>) => {
   const { className, ...rest } = props
   return (
diff --git a/src2/frontend/assets/icons/interface/Config.tsx b/src/frontend/assets/icons/interface/Config.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Config.tsx
rename to src/frontend/assets/icons/interface/Config.tsx
index 9b62bff75..c1e0af373 100644
--- a/src2/frontend/assets/icons/interface/Config.tsx
+++ b/src/frontend/assets/icons/interface/Config.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IConfigIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/DarkTheme.tsx b/src/frontend/assets/icons/interface/DarkTheme.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/DarkTheme.tsx
rename to src/frontend/assets/icons/interface/DarkTheme.tsx
index 49f6ac4ce..b908f9318 100644
--- a/src2/frontend/assets/icons/interface/DarkTheme.tsx
+++ b/src/frontend/assets/icons/interface/DarkTheme.tsx
@@ -1,7 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
 
 export const DarkThemeIcon = (props: IIconProps) => {
   const { className, size = 'md', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/Debugger.tsx b/src/frontend/assets/icons/interface/Debugger.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Debugger.tsx
rename to src/frontend/assets/icons/interface/Debugger.tsx
index 4183920ff..4050c9e71 100644
--- a/src2/frontend/assets/icons/interface/Debugger.tsx
+++ b/src/frontend/assets/icons/interface/Debugger.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IDebuggerIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
   variant?: 'default' | 'muted'
diff --git a/src2/frontend/assets/icons/interface/DebuggerIcon.tsx b/src/frontend/assets/icons/interface/DebuggerIcon.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/DebuggerIcon.tsx
rename to src/frontend/assets/icons/interface/DebuggerIcon.tsx
index ba59b5c21..d6dae96d5 100644
--- a/src2/frontend/assets/icons/interface/DebuggerIcon.tsx
+++ b/src/frontend/assets/icons/interface/DebuggerIcon.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IDebuggerIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/interface/DeviceTransfer.tsx b/src/frontend/assets/icons/interface/DeviceTransfer.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/DeviceTransfer.tsx
rename to src/frontend/assets/icons/interface/DeviceTransfer.tsx
index 2963f80fd..6ee813432 100644
--- a/src2/frontend/assets/icons/interface/DeviceTransfer.tsx
+++ b/src/frontend/assets/icons/interface/DeviceTransfer.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IDeviceTransferIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Download.tsx b/src/frontend/assets/icons/interface/Download.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Download.tsx
rename to src/frontend/assets/icons/interface/Download.tsx
index f8070266b..0d1f8c7d8 100644
--- a/src2/frontend/assets/icons/interface/Download.tsx
+++ b/src/frontend/assets/icons/interface/Download.tsx
@@ -1,6 +1,5 @@
-import { cn } from '../../../utils/cn'
-
 import { IconStyles } from '../../../data/constants/icon-styles'
+import { cn } from '../../../utils/cn'
 import { IIconProps } from '../Types/iconTypes'
 
 export const DownloadIcon = (props: IIconProps) => {
diff --git a/src/renderer/assets/icons/interface/DragHandle.tsx b/src/frontend/assets/icons/interface/DragHandle.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/DragHandle.tsx
rename to src/frontend/assets/icons/interface/DragHandle.tsx
diff --git a/src2/frontend/assets/icons/interface/Duplicate.tsx b/src/frontend/assets/icons/interface/Duplicate.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Duplicate.tsx
rename to src/frontend/assets/icons/interface/Duplicate.tsx
index 6c04675af..ac1b43001 100644
--- a/src2/frontend/assets/icons/interface/Duplicate.tsx
+++ b/src/frontend/assets/icons/interface/Duplicate.tsx
@@ -1,8 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
-
 
 export const DuplicateIcon = (props: IIconProps) => {
   const { className, size = 'sm', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/DuplicateIcon.tsx b/src/frontend/assets/icons/interface/DuplicateIcon.tsx
similarity index 63%
rename from src2/frontend/assets/icons/interface/DuplicateIcon.tsx
rename to src/frontend/assets/icons/interface/DuplicateIcon.tsx
index e689d1cd3..b0a1f2486 100644
--- a/src2/frontend/assets/icons/interface/DuplicateIcon.tsx
+++ b/src/frontend/assets/icons/interface/DuplicateIcon.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IDuplicateIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
@@ -22,25 +23,8 @@ export const DuplicateIcon = (props: IDuplicateIconProps) => {
       {...res}
     >
       <title>Duplicate Icon</title>
-      <rect
-        x='8'
-        y='8'
-        width='12'
-        height='12'
-        rx='2'
-        stroke={color || '#0464FB'}
-        strokeWidth='1.5'
-      />
-      <rect
-        x='4'
-        y='4'
-        width='12'
-        height='12'
-        rx='2'
-        stroke={color || '#0464FB'}
-        strokeWidth='1.5'
-        opacity='0.5'
-      />
+      <rect x='8' y='8' width='12' height='12' rx='2' stroke={color || '#0464FB'} strokeWidth='1.5' />
+      <rect x='4' y='4' width='12' height='12' rx='2' stroke={color || '#0464FB'} strokeWidth='1.5' opacity='0.5' />
     </svg>
   )
 }
diff --git a/src2/frontend/assets/icons/interface/EditButton.tsx b/src/frontend/assets/icons/interface/EditButton.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/EditButton.tsx
rename to src/frontend/assets/icons/interface/EditButton.tsx
index e13510c1a..692931755 100644
--- a/src2/frontend/assets/icons/interface/EditButton.tsx
+++ b/src/frontend/assets/icons/interface/EditButton.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithRef, forwardRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IEditButtonIconProps = ComponentPropsWithRef<'svg'> & {
   variant?: 'default' | 'primary' | 'secondary'
   direction?: 'up' | 'down' | 'left' | 'right'
diff --git a/src2/frontend/assets/icons/interface/Exit.tsx b/src/frontend/assets/icons/interface/Exit.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Exit.tsx
rename to src/frontend/assets/icons/interface/Exit.tsx
index 2a63d18a9..1c2d5de05 100644
--- a/src2/frontend/assets/icons/interface/Exit.tsx
+++ b/src/frontend/assets/icons/interface/Exit.tsx
@@ -1,7 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
 
 export const ExitIcon = (props: IIconProps) => {
   const { className, size = 'sm', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/Folder.tsx b/src/frontend/assets/icons/interface/Folder.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Folder.tsx
rename to src/frontend/assets/icons/interface/Folder.tsx
index 97ba694cf..a6d2ff97b 100644
--- a/src2/frontend/assets/icons/interface/Folder.tsx
+++ b/src/frontend/assets/icons/interface/Folder.tsx
@@ -1,5 +1,6 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
+
+import { cn } from '../../../utils/cn'
 type IFolderIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/LightTheme.tsx b/src/frontend/assets/icons/interface/LightTheme.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/LightTheme.tsx
rename to src/frontend/assets/icons/interface/LightTheme.tsx
index 5ec05cd49..c582a0d7e 100644
--- a/src2/frontend/assets/icons/interface/LightTheme.tsx
+++ b/src/frontend/assets/icons/interface/LightTheme.tsx
@@ -1,8 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
-
 
 export const LightThemeIcon = (props: IIconProps) => {
   const { className, size = 'md', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/Logo.tsx b/src/frontend/assets/icons/interface/Logo.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Logo.tsx
rename to src/frontend/assets/icons/interface/Logo.tsx
index b3f92de1a..72dcb9643 100644
--- a/src2/frontend/assets/icons/interface/Logo.tsx
+++ b/src/frontend/assets/icons/interface/Logo.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type LogoIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Magnifier.tsx b/src/frontend/assets/icons/interface/Magnifier.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Magnifier.tsx
rename to src/frontend/assets/icons/interface/Magnifier.tsx
index 5272fc511..b09b40ab7 100644
--- a/src2/frontend/assets/icons/interface/Magnifier.tsx
+++ b/src/frontend/assets/icons/interface/Magnifier.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IMagnifierIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Minus.tsx b/src/frontend/assets/icons/interface/Minus.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Minus.tsx
rename to src/frontend/assets/icons/interface/Minus.tsx
index f2986d49d..f533acc4c 100644
--- a/src2/frontend/assets/icons/interface/Minus.tsx
+++ b/src/frontend/assets/icons/interface/Minus.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IMinusIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/MoreOptions.tsx b/src/frontend/assets/icons/interface/MoreOptions.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/MoreOptions.tsx
rename to src/frontend/assets/icons/interface/MoreOptions.tsx
index 3393f6688..64f3ae98e 100644
--- a/src2/frontend/assets/icons/interface/MoreOptions.tsx
+++ b/src/frontend/assets/icons/interface/MoreOptions.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const MoreOptionsIcon = ({ className, ...rest }: ComponentPropsWithoutRef<'svg'>) => {
   return (
     <svg
diff --git a/src2/frontend/assets/icons/interface/Next.tsx b/src/frontend/assets/icons/interface/Next.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Next.tsx
rename to src/frontend/assets/icons/interface/Next.tsx
index 231d8abab..cae59eb3f 100644
--- a/src2/frontend/assets/icons/interface/Next.tsx
+++ b/src/frontend/assets/icons/interface/Next.tsx
@@ -1,7 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
 
 export default function NextIcon(props: IIconProps) {
   const { className, size = 'sm', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/Path.tsx b/src/frontend/assets/icons/interface/Path.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Path.tsx
rename to src/frontend/assets/icons/interface/Path.tsx
index 4016e9df8..711b3dcee 100644
--- a/src2/frontend/assets/icons/interface/Path.tsx
+++ b/src/frontend/assets/icons/interface/Path.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IFBDIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Pause.tsx b/src/frontend/assets/icons/interface/Pause.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Pause.tsx
rename to src/frontend/assets/icons/interface/Pause.tsx
index e3aa9e365..e752d1b8d 100644
--- a/src2/frontend/assets/icons/interface/Pause.tsx
+++ b/src/frontend/assets/icons/interface/Pause.tsx
@@ -1,8 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
-
 
 export const PauseIcon = (props: IIconProps) => {
   const { className, size = 'sm', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/Pencil.tsx b/src/frontend/assets/icons/interface/Pencil.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Pencil.tsx
rename to src/frontend/assets/icons/interface/Pencil.tsx
index ace6722d9..4338eecdc 100644
--- a/src2/frontend/assets/icons/interface/Pencil.tsx
+++ b/src/frontend/assets/icons/interface/Pencil.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IPencilIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Play.tsx b/src/frontend/assets/icons/interface/Play.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Play.tsx
rename to src/frontend/assets/icons/interface/Play.tsx
index 4c8c7cf15..c903b8447 100644
--- a/src2/frontend/assets/icons/interface/Play.tsx
+++ b/src/frontend/assets/icons/interface/Play.tsx
@@ -1,6 +1,5 @@
-import { cn } from '../../../utils/cn'
-
 import { IconStyles } from '../../../data/constants/icon-styles'
+import { cn } from '../../../utils/cn'
 import { IIconProps } from '../Types/iconTypes'
 
 export const PlayIcon = (props: IIconProps) => {
diff --git a/src2/frontend/assets/icons/interface/Plus.tsx b/src/frontend/assets/icons/interface/Plus.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Plus.tsx
rename to src/frontend/assets/icons/interface/Plus.tsx
index 43181bb0d..818909851 100644
--- a/src2/frontend/assets/icons/interface/Plus.tsx
+++ b/src/frontend/assets/icons/interface/Plus.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IPlusIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Prohibited.tsx b/src/frontend/assets/icons/interface/Prohibited.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Prohibited.tsx
rename to src/frontend/assets/icons/interface/Prohibited.tsx
index 8037b68b8..4aacc5ea0 100644
--- a/src2/frontend/assets/icons/interface/Prohibited.tsx
+++ b/src/frontend/assets/icons/interface/Prohibited.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type ProhibitedProps = ComponentPropsWithoutRef<'svg'>
 
 export const ProhibitedIcon = (props: ProhibitedProps) => {
diff --git a/src2/frontend/assets/icons/interface/Recent.tsx b/src/frontend/assets/icons/interface/Recent.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Recent.tsx
rename to src/frontend/assets/icons/interface/Recent.tsx
index 410f545bb..b38511971 100644
--- a/src2/frontend/assets/icons/interface/Recent.tsx
+++ b/src/frontend/assets/icons/interface/Recent.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IRecentIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Refresh.tsx b/src/frontend/assets/icons/interface/Refresh.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Refresh.tsx
rename to src/frontend/assets/icons/interface/Refresh.tsx
index 5f33423e3..6b9a2ebc6 100644
--- a/src2/frontend/assets/icons/interface/Refresh.tsx
+++ b/src/frontend/assets/icons/interface/Refresh.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type RefreshIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Search.tsx b/src/frontend/assets/icons/interface/Search.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Search.tsx
rename to src/frontend/assets/icons/interface/Search.tsx
index 6cfbbf211..9b2cf403f 100644
--- a/src2/frontend/assets/icons/interface/Search.tsx
+++ b/src/frontend/assets/icons/interface/Search.tsx
@@ -1,6 +1,5 @@
-import { cn } from '../../../utils/cn'
-
 import { IconStyles } from '../../../data/constants/icon-styles'
+import { cn } from '../../../utils/cn'
 import { IIconProps } from '../Types/iconTypes'
 
 export const SearchIcon = (props: IIconProps) => {
diff --git a/src2/frontend/assets/icons/interface/StickArrow.tsx b/src/frontend/assets/icons/interface/StickArrow.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/StickArrow.tsx
rename to src/frontend/assets/icons/interface/StickArrow.tsx
index f8a69ab9a..38a86e976 100644
--- a/src2/frontend/assets/icons/interface/StickArrow.tsx
+++ b/src/frontend/assets/icons/interface/StickArrow.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IStickArrowIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
   direction?: 'up' | 'down' | 'left' | 'right'
diff --git a/src2/frontend/assets/icons/interface/Stop.tsx b/src/frontend/assets/icons/interface/Stop.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Stop.tsx
rename to src/frontend/assets/icons/interface/Stop.tsx
index 540162e38..b17c7db4b 100644
--- a/src2/frontend/assets/icons/interface/Stop.tsx
+++ b/src/frontend/assets/icons/interface/Stop.tsx
@@ -1,6 +1,5 @@
-import { cn } from '../../../utils/cn'
-
 import { IconStyles } from '../../../data/constants/icon-styles'
+import { cn } from '../../../utils/cn'
 import { IIconProps } from '../Types/iconTypes'
 
 export const StopIcon = (props: IIconProps) => {
diff --git a/src2/frontend/assets/icons/interface/TableIcon.tsx b/src/frontend/assets/icons/interface/TableIcon.tsx
similarity index 100%
rename from src2/frontend/assets/icons/interface/TableIcon.tsx
rename to src/frontend/assets/icons/interface/TableIcon.tsx
index e73b1d97c..c54960d58 100644
--- a/src2/frontend/assets/icons/interface/TableIcon.tsx
+++ b/src/frontend/assets/icons/interface/TableIcon.tsx
@@ -1,7 +1,7 @@
+import { ComponentProps } from 'react'
 
 import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-import { ComponentProps } from 'react'
 
 type IProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
diff --git a/src2/frontend/assets/icons/interface/Timer.tsx b/src/frontend/assets/icons/interface/Timer.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Timer.tsx
rename to src/frontend/assets/icons/interface/Timer.tsx
index 5d381a793..ea2d879b8 100644
--- a/src2/frontend/assets/icons/interface/Timer.tsx
+++ b/src/frontend/assets/icons/interface/Timer.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IFBDIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/Transfer.tsx b/src/frontend/assets/icons/interface/Transfer.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Transfer.tsx
rename to src/frontend/assets/icons/interface/Transfer.tsx
index 10784c705..215e9f265 100644
--- a/src2/frontend/assets/icons/interface/Transfer.tsx
+++ b/src/frontend/assets/icons/interface/Transfer.tsx
@@ -1,6 +1,5 @@
-import { cn } from '../../../utils/cn'
-
 import { IconStyles } from '../../../data/constants/icon-styles'
+import { cn } from '../../../utils/cn'
 import { IIconProps } from '../Types/iconTypes'
 
 export const TransferIcon = (props: IIconProps) => {
diff --git a/src2/frontend/assets/icons/interface/TrashCan.tsx b/src/frontend/assets/icons/interface/TrashCan.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/TrashCan.tsx
rename to src/frontend/assets/icons/interface/TrashCan.tsx
index 461ded6b1..e07f42c93 100644
--- a/src2/frontend/assets/icons/interface/TrashCan.tsx
+++ b/src/frontend/assets/icons/interface/TrashCan.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type TrashCanProps = ComponentPropsWithoutRef<'svg'>
 
 export const TrashCanIcon = (props: TrashCanProps) => {
diff --git a/src2/frontend/assets/icons/interface/Video.tsx b/src/frontend/assets/icons/interface/Video.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Video.tsx
rename to src/frontend/assets/icons/interface/Video.tsx
index af31e2bcf..d77c11a5b 100644
--- a/src2/frontend/assets/icons/interface/Video.tsx
+++ b/src/frontend/assets/icons/interface/Video.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IVideoIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/interface/View.tsx b/src/frontend/assets/icons/interface/View.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/View.tsx
rename to src/frontend/assets/icons/interface/View.tsx
index f2125d77a..b32bcb90e 100644
--- a/src2/frontend/assets/icons/interface/View.tsx
+++ b/src/frontend/assets/icons/interface/View.tsx
@@ -1,7 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
 
 export default function ViewIcon(props: IIconProps) {
   const { stroke, className, size = 'sm', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/ViewHidden.tsx b/src/frontend/assets/icons/interface/ViewHidden.tsx
similarity index 87%
rename from src2/frontend/assets/icons/interface/ViewHidden.tsx
rename to src/frontend/assets/icons/interface/ViewHidden.tsx
index d2368062c..d121486ac 100644
--- a/src2/frontend/assets/icons/interface/ViewHidden.tsx
+++ b/src/frontend/assets/icons/interface/ViewHidden.tsx
@@ -1,7 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
 
 export default function ViewHiddenIcon(props: IIconProps) {
   const { stroke, className, size = 'sm', ...res } = props
@@ -23,15 +22,7 @@ export default function ViewHiddenIcon(props: IIconProps) {
         fill={stroke || '#0464FB'}
       />
       {/* Diagonal line through the eye */}
-      <line
-        x1='2'
-        y1='11'
-        x2='13'
-        y2='1'
-        stroke={stroke || '#0464FB'}
-        strokeWidth='1.5'
-        strokeLinecap='round'
-      />
+      <line x1='2' y1='11' x2='13' y2='1' stroke={stroke || '#0464FB'} strokeWidth='1.5' strokeLinecap='round' />
     </svg>
   )
 }
diff --git a/src2/frontend/assets/icons/interface/Warning.tsx b/src/frontend/assets/icons/interface/Warning.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Warning.tsx
rename to src/frontend/assets/icons/interface/Warning.tsx
index 5058c303d..fd80a0abf 100644
--- a/src2/frontend/assets/icons/interface/Warning.tsx
+++ b/src/frontend/assets/icons/interface/Warning.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithRef, ElementType } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IWarningIconProps = ComponentPropsWithRef<'svg'> & {
   variant?: 'default' | 'primary' | 'secondary'
   direction?: 'up' | 'down' | 'left' | 'right'
diff --git a/src2/frontend/assets/icons/interface/Zap.tsx b/src/frontend/assets/icons/interface/Zap.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/Zap.tsx
rename to src/frontend/assets/icons/interface/Zap.tsx
index 73a708241..5e2c06b32 100644
--- a/src2/frontend/assets/icons/interface/Zap.tsx
+++ b/src/frontend/assets/icons/interface/Zap.tsx
@@ -1,7 +1,6 @@
+import { IconStyles } from '../../../data/constants/icon-styles'
 import { cn } from '../../../utils/cn'
-
 import { IIconProps } from '../Types/iconTypes'
-import { IconStyles } from '../../../data/constants/icon-styles'
 
 export default function ZapIcon(props: IIconProps) {
   const { className, size = 'sm', ...res } = props
diff --git a/src2/frontend/assets/icons/interface/ZoomInOut.tsx b/src/frontend/assets/icons/interface/ZoomInOut.tsx
similarity index 99%
rename from src2/frontend/assets/icons/interface/ZoomInOut.tsx
rename to src/frontend/assets/icons/interface/ZoomInOut.tsx
index a8cd056a3..16dfc1c6e 100644
--- a/src2/frontend/assets/icons/interface/ZoomInOut.tsx
+++ b/src/frontend/assets/icons/interface/ZoomInOut.tsx
@@ -1,6 +1,5 @@
-import { cn } from '../../../utils/cn'
-
 import { IconStyles } from '../../../data/constants/icon-styles'
+import { cn } from '../../../utils/cn'
 import { IIconProps } from '../Types/iconTypes'
 
 export const ZoomInOut = (props: IIconProps) => {
diff --git a/src2/frontend/assets/icons/library/CloseFolder.tsx b/src/frontend/assets/icons/library/CloseFolder.tsx
similarity index 99%
rename from src2/frontend/assets/icons/library/CloseFolder.tsx
rename to src/frontend/assets/icons/library/CloseFolder.tsx
index 99b9339b1..e7343d789 100644
--- a/src2/frontend/assets/icons/library/CloseFolder.tsx
+++ b/src/frontend/assets/icons/library/CloseFolder.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type ILibraryCloseFolderIconProps = ComponentProps<'svg'> & {
   size: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/library/File.tsx b/src/frontend/assets/icons/library/File.tsx
similarity index 99%
rename from src2/frontend/assets/icons/library/File.tsx
rename to src/frontend/assets/icons/library/File.tsx
index ee402ba99..480e4c7d7 100644
--- a/src2/frontend/assets/icons/library/File.tsx
+++ b/src/frontend/assets/icons/library/File.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type ILibraryFileIconProps = ComponentProps<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/library/OpenFolder.tsx b/src/frontend/assets/icons/library/OpenFolder.tsx
similarity index 99%
rename from src2/frontend/assets/icons/library/OpenFolder.tsx
rename to src/frontend/assets/icons/library/OpenFolder.tsx
index 10c110177..6f069a945 100644
--- a/src2/frontend/assets/icons/library/OpenFolder.tsx
+++ b/src/frontend/assets/icons/library/OpenFolder.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type ILibraryOpenFolderIconProps = ComponentProps<'svg'> & {
   size: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/oplc.tsx b/src/frontend/assets/icons/oplc.tsx
similarity index 99%
rename from src2/frontend/assets/icons/oplc.tsx
rename to src/frontend/assets/icons/oplc.tsx
index 401930d24..5bfa46592 100644
--- a/src2/frontend/assets/icons/oplc.tsx
+++ b/src/frontend/assets/icons/oplc.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../utils/cn'
 
 type IOpenPLCIconProps = ComponentProps<'svg'>
diff --git a/src2/frontend/assets/icons/project/Array.tsx b/src/frontend/assets/icons/project/Array.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Array.tsx
rename to src/frontend/assets/icons/project/Array.tsx
index 241ae6867..e17f813c3 100644
--- a/src2/frontend/assets/icons/project/Array.tsx
+++ b/src/frontend/assets/icons/project/Array.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type ArrayIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Block.tsx b/src/frontend/assets/icons/project/Block.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Block.tsx
rename to src/frontend/assets/icons/project/Block.tsx
index f4f80030c..e5d71ce22 100644
--- a/src2/frontend/assets/icons/project/Block.tsx
+++ b/src/frontend/assets/icons/project/Block.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/CExt.tsx b/src/frontend/assets/icons/project/CExt.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/CExt.tsx
rename to src/frontend/assets/icons/project/CExt.tsx
index 90936aa0f..544c9dcd5 100644
--- a/src2/frontend/assets/icons/project/CExt.tsx
+++ b/src/frontend/assets/icons/project/CExt.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type ICExtIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Coil.tsx b/src/frontend/assets/icons/project/Coil.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Coil.tsx
rename to src/frontend/assets/icons/project/Coil.tsx
index 6bfc21db4..0e1efd390 100644
--- a/src2/frontend/assets/icons/project/Coil.tsx
+++ b/src/frontend/assets/icons/project/Coil.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 type ICoilIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
diff --git a/src2/frontend/assets/icons/project/Contact.tsx b/src/frontend/assets/icons/project/Contact.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Contact.tsx
rename to src/frontend/assets/icons/project/Contact.tsx
index fd68c4bc0..9246bf969 100644
--- a/src2/frontend/assets/icons/project/Contact.tsx
+++ b/src/frontend/assets/icons/project/Contact.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 type IContactIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
diff --git a/src2/frontend/assets/icons/project/Cpp.tsx b/src/frontend/assets/icons/project/Cpp.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Cpp.tsx
rename to src/frontend/assets/icons/project/Cpp.tsx
index b8ee83982..c8f9fb06e 100644
--- a/src2/frontend/assets/icons/project/Cpp.tsx
+++ b/src/frontend/assets/icons/project/Cpp.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type CppIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/DataType.tsx b/src/frontend/assets/icons/project/DataType.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/DataType.tsx
rename to src/frontend/assets/icons/project/DataType.tsx
index 2f0711c7b..02c103428 100644
--- a/src2/frontend/assets/icons/project/DataType.tsx
+++ b/src/frontend/assets/icons/project/DataType.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IDataTypeIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Device.tsx b/src/frontend/assets/icons/project/Device.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Device.tsx
rename to src/frontend/assets/icons/project/Device.tsx
index bd83078b1..9447db6ab 100644
--- a/src2/frontend/assets/icons/project/Device.tsx
+++ b/src/frontend/assets/icons/project/Device.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IDeviceIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Enum.tsx b/src/frontend/assets/icons/project/Enum.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Enum.tsx
rename to src/frontend/assets/icons/project/Enum.tsx
index 0a6e2f379..4afa0b788 100644
--- a/src2/frontend/assets/icons/project/Enum.tsx
+++ b/src/frontend/assets/icons/project/Enum.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type EnumIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/FBD.tsx b/src/frontend/assets/icons/project/FBD.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/FBD.tsx
rename to src/frontend/assets/icons/project/FBD.tsx
index 5e51b9743..75bbed2e0 100644
--- a/src2/frontend/assets/icons/project/FBD.tsx
+++ b/src/frontend/assets/icons/project/FBD.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IFBDIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Function.tsx b/src/frontend/assets/icons/project/Function.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Function.tsx
rename to src/frontend/assets/icons/project/Function.tsx
index cca5d1e55..932962025 100644
--- a/src2/frontend/assets/icons/project/Function.tsx
+++ b/src/frontend/assets/icons/project/Function.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IFunctionIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/FunctionBlock.tsx b/src/frontend/assets/icons/project/FunctionBlock.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/FunctionBlock.tsx
rename to src/frontend/assets/icons/project/FunctionBlock.tsx
index afb7eb76f..dbddd737f 100644
--- a/src2/frontend/assets/icons/project/FunctionBlock.tsx
+++ b/src/frontend/assets/icons/project/FunctionBlock.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IFunctionBlockIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/GenericDT.tsx b/src/frontend/assets/icons/project/GenericDT.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/GenericDT.tsx
rename to src/frontend/assets/icons/project/GenericDT.tsx
index ace1dde95..538ee234b 100644
--- a/src2/frontend/assets/icons/project/GenericDT.tsx
+++ b/src/frontend/assets/icons/project/GenericDT.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IGenericIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/IL.tsx b/src/frontend/assets/icons/project/IL.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/IL.tsx
rename to src/frontend/assets/icons/project/IL.tsx
index 2c529d956..ea0baa6cf 100644
--- a/src2/frontend/assets/icons/project/IL.tsx
+++ b/src/frontend/assets/icons/project/IL.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IILIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/LD.tsx b/src/frontend/assets/icons/project/LD.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/LD.tsx
rename to src/frontend/assets/icons/project/LD.tsx
index eb4bf48eb..7d6fea3c1 100644
--- a/src2/frontend/assets/icons/project/LD.tsx
+++ b/src/frontend/assets/icons/project/LD.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type ILDIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Loop.tsx b/src/frontend/assets/icons/project/Loop.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Loop.tsx
rename to src/frontend/assets/icons/project/Loop.tsx
index 2ba98f075..95a94bbd5 100644
--- a/src2/frontend/assets/icons/project/Loop.tsx
+++ b/src/frontend/assets/icons/project/Loop.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type ILoopIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Orchestrator.tsx b/src/frontend/assets/icons/project/Orchestrator.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Orchestrator.tsx
rename to src/frontend/assets/icons/project/Orchestrator.tsx
index f64e9fa22..cd253cd08 100644
--- a/src2/frontend/assets/icons/project/Orchestrator.tsx
+++ b/src/frontend/assets/icons/project/Orchestrator.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IOrchestratorIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/PLC.tsx b/src/frontend/assets/icons/project/PLC.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/PLC.tsx
rename to src/frontend/assets/icons/project/PLC.tsx
index e7684f62c..51565cad9 100644
--- a/src2/frontend/assets/icons/project/PLC.tsx
+++ b/src/frontend/assets/icons/project/PLC.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IPLCIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Program.tsx b/src/frontend/assets/icons/project/Program.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Program.tsx
rename to src/frontend/assets/icons/project/Program.tsx
index 9228b4db2..a9ed063a2 100644
--- a/src2/frontend/assets/icons/project/Program.tsx
+++ b/src/frontend/assets/icons/project/Program.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IProgramIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Python.tsx b/src/frontend/assets/icons/project/Python.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Python.tsx
rename to src/frontend/assets/icons/project/Python.tsx
index dbd2dd984..527baa62a 100644
--- a/src2/frontend/assets/icons/project/Python.tsx
+++ b/src/frontend/assets/icons/project/Python.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type PythonIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/RemoteDevice.tsx b/src/frontend/assets/icons/project/RemoteDevice.tsx
similarity index 91%
rename from src2/frontend/assets/icons/project/RemoteDevice.tsx
rename to src/frontend/assets/icons/project/RemoteDevice.tsx
index a312e7b9e..41747467b 100644
--- a/src2/frontend/assets/icons/project/RemoteDevice.tsx
+++ b/src/frontend/assets/icons/project/RemoteDevice.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IRemoteDeviceIconProps = ComponentProps<'svg'> & {
@@ -32,12 +33,7 @@ export const RemoteDeviceIcon = (props: IRemoteDeviceIconProps) => {
         fill='#B4D0FE'
       />
       <circle cx='14' cy='15' r='4' stroke='#B4D0FE' strokeWidth='1.5' fill='none' />
-      <path
-        d='M14 8V10M14 20V22M8 15H6M22 15H20'
-        stroke='#B4D0FE'
-        strokeWidth='1.5'
-        strokeLinecap='round'
-      />
+      <path d='M14 8V10M14 20V22M8 15H6M22 15H20' stroke='#B4D0FE' strokeWidth='1.5' strokeLinecap='round' />
     </svg>
   )
 }
diff --git a/src2/frontend/assets/icons/project/Resource.tsx b/src/frontend/assets/icons/project/Resource.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Resource.tsx
rename to src/frontend/assets/icons/project/Resource.tsx
index 976960b40..89faadf55 100644
--- a/src2/frontend/assets/icons/project/Resource.tsx
+++ b/src/frontend/assets/icons/project/Resource.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IResourceIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/SFC.tsx b/src/frontend/assets/icons/project/SFC.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/SFC.tsx
rename to src/frontend/assets/icons/project/SFC.tsx
index 125b1ab97..6ad4cb0c2 100644
--- a/src2/frontend/assets/icons/project/SFC.tsx
+++ b/src/frontend/assets/icons/project/SFC.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type ISFCIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/ST.tsx b/src/frontend/assets/icons/project/ST.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/ST.tsx
rename to src/frontend/assets/icons/project/ST.tsx
index 3d1974de9..637a61b50 100644
--- a/src2/frontend/assets/icons/project/ST.tsx
+++ b/src/frontend/assets/icons/project/ST.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type ISTIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Server.tsx b/src/frontend/assets/icons/project/Server.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Server.tsx
rename to src/frontend/assets/icons/project/Server.tsx
index acf06de25..57fed64a2 100644
--- a/src2/frontend/assets/icons/project/Server.tsx
+++ b/src/frontend/assets/icons/project/Server.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IServerIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/ServersFolder.tsx b/src/frontend/assets/icons/project/ServersFolder.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/ServersFolder.tsx
rename to src/frontend/assets/icons/project/ServersFolder.tsx
index 852a86a6f..29346693d 100644
--- a/src2/frontend/assets/icons/project/ServersFolder.tsx
+++ b/src/frontend/assets/icons/project/ServersFolder.tsx
@@ -1,4 +1,5 @@
 import { ComponentProps } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type IServersFolderIconProps = ComponentProps<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/Structure.tsx b/src/frontend/assets/icons/project/Structure.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/Structure.tsx
rename to src/frontend/assets/icons/project/Structure.tsx
index b551dd862..78a351bf2 100644
--- a/src2/frontend/assets/icons/project/Structure.tsx
+++ b/src/frontend/assets/icons/project/Structure.tsx
@@ -1,4 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react'
+
 import { cn } from '../../../utils/cn'
 
 type StructureIconProps = ComponentPropsWithoutRef<'svg'> & {
diff --git a/src2/frontend/assets/icons/project/fbd/Block.tsx b/src/frontend/assets/icons/project/fbd/Block.tsx
similarity index 79%
rename from src2/frontend/assets/icons/project/fbd/Block.tsx
rename to src/frontend/assets/icons/project/fbd/Block.tsx
index 89d31ee23..472cdfb52 100644
--- a/src2/frontend/assets/icons/project/fbd/Block.tsx
+++ b/src/frontend/assets/icons/project/fbd/Block.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
@@ -39,24 +40,8 @@ export default function BlockIcon(props: IBlockIconProps) {
         fill='#B4D0FE'
         fill-opacity='0.5'
       />
-      <line
-        x1='5'
-        y1='13.2955'
-        x2='9.90909'
-        y2='13.2955'
-        stroke='#B4D0FE'
-        stroke-opacity='0.5'
-        strokeWidth='1.22727'
-      />
-      <line
-        x1='5'
-        y1='16.5682'
-        x2='9.90909'
-        y2='16.5682'
-        stroke='#B4D0FE'
-        stroke-opacity='0.5'
-        strokeWidth='1.22727'
-      />
+      <line x1='5' y1='13.2955' x2='9.90909' y2='13.2955' stroke='#B4D0FE' stroke-opacity='0.5' strokeWidth='1.22727' />
+      <line x1='5' y1='16.5682' x2='9.90909' y2='16.5682' stroke='#B4D0FE' stroke-opacity='0.5' strokeWidth='1.22727' />
       <line
         x1='18.9091'
         y1='14.9318'
diff --git a/src2/frontend/assets/icons/project/fbd/Comment.tsx b/src/frontend/assets/icons/project/fbd/Comment.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/fbd/Comment.tsx
rename to src/frontend/assets/icons/project/fbd/Comment.tsx
index 26c75eaca..4d66cc344 100644
--- a/src2/frontend/assets/icons/project/fbd/Comment.tsx
+++ b/src/frontend/assets/icons/project/fbd/Comment.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type ICommentIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/project/fbd/Connector.tsx b/src/frontend/assets/icons/project/fbd/Connector.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/fbd/Connector.tsx
rename to src/frontend/assets/icons/project/fbd/Connector.tsx
index f67bfe136..2b8732dda 100644
--- a/src2/frontend/assets/icons/project/fbd/Connector.tsx
+++ b/src/frontend/assets/icons/project/fbd/Connector.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/project/fbd/Continuation.tsx b/src/frontend/assets/icons/project/fbd/Continuation.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/fbd/Continuation.tsx
rename to src/frontend/assets/icons/project/fbd/Continuation.tsx
index 428b7560b..19dc29da2 100644
--- a/src2/frontend/assets/icons/project/fbd/Continuation.tsx
+++ b/src/frontend/assets/icons/project/fbd/Continuation.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/project/fbd/VariableIn.tsx b/src/frontend/assets/icons/project/fbd/VariableIn.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/fbd/VariableIn.tsx
rename to src/frontend/assets/icons/project/fbd/VariableIn.tsx
index 92eaeceaf..d97ce93bd 100644
--- a/src2/frontend/assets/icons/project/fbd/VariableIn.tsx
+++ b/src/frontend/assets/icons/project/fbd/VariableIn.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src2/frontend/assets/icons/project/fbd/VariableInOut.tsx b/src/frontend/assets/icons/project/fbd/VariableInOut.tsx
similarity index 86%
rename from src2/frontend/assets/icons/project/fbd/VariableInOut.tsx
rename to src/frontend/assets/icons/project/fbd/VariableInOut.tsx
index d152db399..70be2cf05 100644
--- a/src2/frontend/assets/icons/project/fbd/VariableInOut.tsx
+++ b/src/frontend/assets/icons/project/fbd/VariableInOut.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
@@ -44,15 +45,7 @@ export default function VariableInOutIcon(props: IBlockIconProps) {
         stroke-opacity='0.5'
         strokeWidth='1.22727'
       />
-      <line
-        x1='4'
-        y1='13.3864'
-        x2='8.90909'
-        y2='13.3864'
-        stroke='#B4D0FE'
-        stroke-opacity='0.5'
-        strokeWidth='1.22727'
-      />
+      <line x1='4' y1='13.3864' x2='8.90909' y2='13.3864' stroke='#B4D0FE' stroke-opacity='0.5' strokeWidth='1.22727' />
     </svg>
   )
 }
diff --git a/src2/frontend/assets/icons/project/fbd/VariableOut.tsx b/src/frontend/assets/icons/project/fbd/VariableOut.tsx
similarity index 84%
rename from src2/frontend/assets/icons/project/fbd/VariableOut.tsx
rename to src/frontend/assets/icons/project/fbd/VariableOut.tsx
index 664cd6b5e..559f90ce0 100644
--- a/src2/frontend/assets/icons/project/fbd/VariableOut.tsx
+++ b/src/frontend/assets/icons/project/fbd/VariableOut.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
@@ -35,15 +36,7 @@ export default function VariableOutIcon(props: IBlockIconProps) {
         stroke='#B4D0FE'
         strokeWidth='1.22727'
       />
-      <line
-        x1='4'
-        y1='13.3864'
-        x2='8.90909'
-        y2='13.3864'
-        stroke='#B4D0FE'
-        stroke-opacity='0.5'
-        strokeWidth='1.22727'
-      />
+      <line x1='4' y1='13.3864' x2='8.90909' y2='13.3864' stroke='#B4D0FE' stroke-opacity='0.5' strokeWidth='1.22727' />
     </svg>
   )
 }
diff --git a/src/frontend/assets/icons/project/index.ts b/src/frontend/assets/icons/project/index.ts
new file mode 100644
index 000000000..97fb540ed
--- /dev/null
+++ b/src/frontend/assets/icons/project/index.ts
@@ -0,0 +1,3 @@
+export { ArrayIcon } from './Array'
+export { EnumIcon } from './Enum'
+export { StructureIcon } from './Structure'
diff --git a/src2/frontend/assets/icons/project/ladder/Block.tsx b/src/frontend/assets/icons/project/ladder/Block.tsx
similarity index 80%
rename from src2/frontend/assets/icons/project/ladder/Block.tsx
rename to src/frontend/assets/icons/project/ladder/Block.tsx
index babb5eead..b2dbc1a79 100644
--- a/src2/frontend/assets/icons/project/ladder/Block.tsx
+++ b/src/frontend/assets/icons/project/ladder/Block.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type IBlockIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
@@ -39,24 +40,8 @@ export default function BlockIcon(props: IBlockIconProps) {
         fill='#B4D0FE'
         fillOpacity='0.5'
       />
-      <line
-        x1='3'
-        y1='12.2955'
-        x2='7.90909'
-        y2='12.2955'
-        stroke='#B4D0FE'
-        strokeOpacity='0.5'
-        strokeWidth='1.22727'
-      />
-      <line
-        x1='3'
-        y1='15.5682'
-        x2='7.90909'
-        y2='15.5682'
-        stroke='#B4D0FE'
-        strokeOpacity='0.5'
-        strokeWidth='1.22727'
-      />
+      <line x1='3' y1='12.2955' x2='7.90909' y2='12.2955' stroke='#B4D0FE' strokeOpacity='0.5' strokeWidth='1.22727' />
+      <line x1='3' y1='15.5682' x2='7.90909' y2='15.5682' stroke='#B4D0FE' strokeOpacity='0.5' strokeWidth='1.22727' />
       <line
         x1='16.9091'
         y1='13.9318'
diff --git a/src/frontend/assets/icons/project/ladder/Coil.tsx b/src/frontend/assets/icons/project/ladder/Coil.tsx
new file mode 100644
index 000000000..4c4d6b550
--- /dev/null
+++ b/src/frontend/assets/icons/project/ladder/Coil.tsx
@@ -0,0 +1,41 @@
+import { ComponentPropsWithoutRef } from 'react'
+
+import { cn } from '../../../../utils/cn'
+type ICoilIconProps = ComponentPropsWithoutRef<'svg'> & {
+  size?: 'sm' | 'md' | 'lg'
+}
+const sizeClasses = {
+  sm: 'w-5 h-5',
+  md: 'w-6 h-6',
+  lg: 'w-12 h-12',
+}
+
+export default function CoilIcon(props: ICoilIconProps) {
+  const { className, size = 'sm', ...res } = props
+
+  return (
+    <svg
+      className={cn(sizeClasses[size], className)}
+      viewBox='0 0 24 24'
+      fill='none'
+      xmlns='http://www.w3.org/2000/svg'
+      {...res}
+    >
+      <path
+        opacity='0.4'
+        d='M4.66667 0H18.6667C21.244 0 23.3333 2.08934 23.3333 4.66667V18.6667C23.3333 21.244 21.244 23.3333 18.6667 23.3333H4.66667C2.08934 23.3333 0 21.244 0 18.6667V4.66667C0 2.08934 2.08934 0 4.66667 0Z'
+        fill='#B4D0FE'
+      />
+      <path
+        d='M10.9629 7C10.6587 7.37547 10.4051 7.73261 10.1854 8.06229C9.94881 8.39197 9.76289 8.7308 9.61078 9.06964C9.45867 9.41763 9.34036 9.77478 9.27275 10.1411C9.18824 10.5166 9.15444 10.9286 9.15444 11.3682C9.15444 11.8169 9.18824 12.229 9.27275 12.5953C9.34036 12.9708 9.45867 13.328 9.61078 13.6668C9.76289 14.0056 9.94881 14.3445 10.1854 14.6741C10.4051 15.0038 10.6587 15.361 10.9629 15.7273H9.66148C8.95162 15.0496 8.37698 14.3353 7.97134 13.5935C7.56571 12.8609 7.36289 12.1191 7.36289 11.3682C7.36289 10.6264 7.56571 9.88467 7.97134 9.1429C8.37698 8.40113 8.95162 7.68683 9.66148 7H10.9629Z'
+        fill='#B4D0FE'
+      />
+      <path
+        d='M13.0371 7C13.3413 7.37547 13.5949 7.73261 13.8146 8.06229C14.0512 8.39197 14.2371 8.7308 14.3892 9.06964C14.5413 9.41763 14.6596 9.77478 14.7272 10.1411C14.8118 10.5166 14.8456 10.9286 14.8456 11.3682C14.8456 11.8169 14.8118 12.229 14.7272 12.5953C14.6596 12.9708 14.5413 13.328 14.3892 13.6668C14.2371 14.0056 14.0512 14.3445 13.8146 14.6741C13.5949 15.0038 13.3413 15.361 13.0371 15.7273H14.3385C15.0484 15.0496 15.623 14.3353 16.0287 13.5935C16.4343 12.8609 16.6371 12.1191 16.6371 11.3682C16.6371 10.6264 16.4343 9.88467 16.0287 9.1429C15.623 8.40113 15.0484 7.68683 14.3385 7H13.0371Z'
+        fill='#B4D0FE'
+      />
+      <path d='M16.6371 11.3629H21.0003' stroke='#B4D0FE' strokeWidth='1.35' />
+      <path d='M3 11.3629H7.36364' stroke='#B4D0FE' strokeWidth='1.35' />
+    </svg>
+  )
+}
diff --git a/src2/frontend/assets/icons/project/ladder/Contact.tsx b/src/frontend/assets/icons/project/ladder/Contact.tsx
similarity index 99%
rename from src2/frontend/assets/icons/project/ladder/Contact.tsx
rename to src/frontend/assets/icons/project/ladder/Contact.tsx
index 03468924e..aa74edbac 100644
--- a/src2/frontend/assets/icons/project/ladder/Contact.tsx
+++ b/src/frontend/assets/icons/project/ladder/Contact.tsx
@@ -1,5 +1,6 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
+
+import { cn } from '../../../../utils/cn'
 type IContactIconProps = ComponentPropsWithoutRef<'svg'> & {
   size?: 'sm' | 'md' | 'lg'
 }
diff --git a/src/renderer/assets/icons/window-controls/Close.tsx b/src/frontend/assets/icons/window-controls/Close.tsx
similarity index 100%
rename from src/renderer/assets/icons/window-controls/Close.tsx
rename to src/frontend/assets/icons/window-controls/Close.tsx
diff --git a/src/renderer/assets/icons/window-controls/Exit-Maximize.tsx b/src/frontend/assets/icons/window-controls/Exit-Maximize.tsx
similarity index 100%
rename from src/renderer/assets/icons/window-controls/Exit-Maximize.tsx
rename to src/frontend/assets/icons/window-controls/Exit-Maximize.tsx
diff --git a/src/renderer/assets/icons/window-controls/Maximize.tsx b/src/frontend/assets/icons/window-controls/Maximize.tsx
similarity index 100%
rename from src/renderer/assets/icons/window-controls/Maximize.tsx
rename to src/frontend/assets/icons/window-controls/Maximize.tsx
diff --git a/src/renderer/assets/icons/window-controls/Minimize.tsx b/src/frontend/assets/icons/window-controls/Minimize.tsx
similarity index 100%
rename from src/renderer/assets/icons/window-controls/Minimize.tsx
rename to src/frontend/assets/icons/window-controls/Minimize.tsx
diff --git a/src/renderer/assets/images/example.png b/src/frontend/assets/images/example.png
similarity index 100%
rename from src/renderer/assets/images/example.png
rename to src/frontend/assets/images/example.png
diff --git a/src2/frontend/components/_atoms/.gitkeep b/src/frontend/components/_atoms/.gitkeep
similarity index 100%
rename from src2/frontend/components/_atoms/.gitkeep
rename to src/frontend/components/_atoms/.gitkeep
diff --git a/src2/frontend/components/_atoms/accordion/index.tsx b/src/frontend/components/_atoms/accordion/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/accordion/index.tsx
rename to src/frontend/components/_atoms/accordion/index.tsx
index aa4250430..881d50e6e 100644
--- a/src2/frontend/components/_atoms/accordion/index.tsx
+++ b/src/frontend/components/_atoms/accordion/index.tsx
@@ -1,8 +1,9 @@
 import * as AccordionPrimitive from '@radix-ui/react-accordion'
 import { ChevronDownIcon } from '@radix-ui/react-icons'
-import { cn } from '../../../utils/cn'
 import { forwardRef, useEffect, useRef, useState } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 interface AccordionItemProps {
   title: React.ReactNode
   content: React.ReactNode
diff --git a/src2/frontend/components/_atoms/buttons/activity-bar/index.tsx b/src/frontend/components/_atoms/buttons/activity-bar/index.tsx
similarity index 75%
rename from src2/frontend/components/_atoms/buttons/activity-bar/index.tsx
rename to src/frontend/components/_atoms/buttons/activity-bar/index.tsx
index e9f787eae..0e31231fd 100644
--- a/src2/frontend/components/_atoms/buttons/activity-bar/index.tsx
+++ b/src/frontend/components/_atoms/buttons/activity-bar/index.tsx
@@ -1,16 +1,18 @@
+import { ComponentPropsWithoutRef, forwardRef } from 'react'
+
 import { cn } from '../../../../utils/cn'
-import { ComponentPropsWithoutRef } from 'react'
 
 type IActivityBarButtonProps = ComponentPropsWithoutRef<'button'> & {
   'data-active'?: string
 }
 
-const ActivityBarButton = (props: IActivityBarButtonProps) => {
+const ActivityBarButton = forwardRef<HTMLButtonElement, IActivityBarButtonProps>((props, ref) => {
   const { children, className, 'data-active': dataActive, ...res } = props
   const isActive = dataActive === 'true'
 
   return (
     <button
+      ref={ref}
       type='button'
       className={cn('flex h-6 w-full cursor-pointer items-center justify-center', className)}
       {...res}
@@ -25,6 +27,7 @@ const ActivityBarButton = (props: IActivityBarButtonProps) => {
       </div>
     </button>
   )
-}
+})
+ActivityBarButton.displayName = 'ActivityBarButton'
 
 export { ActivityBarButton }
diff --git a/src2/frontend/components/_atoms/buttons/console/clear-console.tsx b/src/frontend/components/_atoms/buttons/console/clear-console.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/buttons/console/clear-console.tsx
rename to src/frontend/components/_atoms/buttons/console/clear-console.tsx
diff --git a/src2/frontend/components/_atoms/buttons/default/index.tsx b/src/frontend/components/_atoms/buttons/default/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/buttons/default/index.tsx
rename to src/frontend/components/_atoms/buttons/default/index.tsx
index 7500ecb69..32bb84f8e 100644
--- a/src2/frontend/components/_atoms/buttons/default/index.tsx
+++ b/src/frontend/components/_atoms/buttons/default/index.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithRef, ReactNode } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type ButtonProps = ComponentPropsWithRef<'button'> & {
   ghosted?: boolean
   children?: ReactNode
diff --git a/src2/frontend/components/_atoms/buttons/tables-actions/index.tsx b/src/frontend/components/_atoms/buttons/tables-actions/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/buttons/tables-actions/index.tsx
rename to src/frontend/components/_atoms/buttons/tables-actions/index.tsx
index d52184716..d02034934 100644
--- a/src2/frontend/components/_atoms/buttons/tables-actions/index.tsx
+++ b/src/frontend/components/_atoms/buttons/tables-actions/index.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef, ReactNode } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type TableActionButtonProps = ComponentPropsWithoutRef<'button'> & {
   children: ReactNode
   className?: string
diff --git a/src2/frontend/components/_atoms/buttons/window-control/index.tsx b/src/frontend/components/_atoms/buttons/window-control/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/buttons/window-control/index.tsx
rename to src/frontend/components/_atoms/buttons/window-control/index.tsx
index 49e347f9b..f49f4d25f 100644
--- a/src2/frontend/components/_atoms/buttons/window-control/index.tsx
+++ b/src/frontend/components/_atoms/buttons/window-control/index.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type WindowControlButtonProps = ComponentPropsWithRef<'button'>
 
 const WindowControlButton = (props: WindowControlButtonProps) => {
diff --git a/src/renderer/components/_atoms/card/index.tsx b/src/frontend/components/_atoms/card/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/card/index.tsx
rename to src/frontend/components/_atoms/card/index.tsx
diff --git a/src2/frontend/components/_atoms/checkbox/index.tsx b/src/frontend/components/_atoms/checkbox/index.tsx
similarity index 88%
rename from src2/frontend/components/_atoms/checkbox/index.tsx
rename to src/frontend/components/_atoms/checkbox/index.tsx
index 08937c7e6..38330435c 100644
--- a/src2/frontend/components/_atoms/checkbox/index.tsx
+++ b/src/frontend/components/_atoms/checkbox/index.tsx
@@ -1,6 +1,7 @@
 import type { CheckboxProps as PrimitiveCheckboxProps } from '@radix-ui/react-checkbox'
 import * as PrimitiveCheckbox from '@radix-ui/react-checkbox'
 import { CheckIcon } from '@radix-ui/react-icons'
+
 import { cn } from '../../../utils/cn'
 
 type CheckboxProps = PrimitiveCheckboxProps & {
@@ -25,10 +26,7 @@ const Checkbox = ({ label, disabled, checked, className, ...props }: CheckboxPro
         </PrimitiveCheckbox.Indicator>
       </PrimitiveCheckbox.Root>
       {label && (
-        <label
-          htmlFor={props.id}
-          className='text-sm font-medium text-neutral-950 hover:cursor-pointer dark:text-white'
-        >
+        <label htmlFor={props.id} className='text-sm font-medium text-neutral-950 hover:cursor-pointer dark:text-white'>
           {label}
         </label>
       )}
diff --git a/src2/frontend/components/_atoms/debug-tree-node/index.tsx b/src/frontend/components/_atoms/debug-tree-node/index.tsx
similarity index 98%
rename from src2/frontend/components/_atoms/debug-tree-node/index.tsx
rename to src/frontend/components/_atoms/debug-tree-node/index.tsx
index f089600af..9250e27b7 100644
--- a/src2/frontend/components/_atoms/debug-tree-node/index.tsx
+++ b/src/frontend/components/_atoms/debug-tree-node/index.tsx
@@ -1,8 +1,9 @@
+import { ComponentPropsWithoutRef } from 'react'
+
+import type { DebugTreeNode } from '../../../../middleware/shared/ports/types'
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import ViewIcon from '../../../assets/icons/interface/View'
 import { cn } from '../../../utils/cn'
-import { ComponentPropsWithoutRef } from 'react'
-import type { DebugTreeNode } from '../../../../middleware/shared/ports/types'
 
 type TreeNodeProps = ComponentPropsWithoutRef<'div'> & {
   node: DebugTreeNode
@@ -131,7 +132,7 @@ const TreeNode = ({
               : node.isComplex
                 ? ''
                 : getValue
-                  ? (getValue(node.compositeKey) ?? '-')
+                  ? getValue(node.compositeKey) ?? '-'
                   : '-'}
           </p>
         </div>
diff --git a/src2/frontend/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx b/src/frontend/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
rename to src/frontend/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
index b8ffb27ee..93c3fbc73 100644
--- a/src2/frontend/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
+++ b/src/frontend/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef, useEffect, useState } from 'react'
 
+import { cn } from '../../../../utils/cn'
+
 type ArrayDimensionsComponentProps = ComponentPropsWithoutRef<'div'> & {
   id: string
   initialValue: string
diff --git a/src2/frontend/components/_atoms/dimensions-modal/index.tsx b/src/frontend/components/_atoms/dimensions-modal/index.tsx
similarity index 97%
rename from src2/frontend/components/_atoms/dimensions-modal/index.tsx
rename to src/frontend/components/_atoms/dimensions-modal/index.tsx
index 03f184be0..9f6ab548d 100644
--- a/src2/frontend/components/_atoms/dimensions-modal/index.tsx
+++ b/src/frontend/components/_atoms/dimensions-modal/index.tsx
@@ -1,10 +1,16 @@
 import { MinusIcon } from '../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../assets/icons/interface/StickArrow'
-import { Button } from '../buttons/default'
-import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle, ModalTrigger, } from '../../../components/_molecules/modal'
+import {
+  Modal,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  ModalTitle,
+  ModalTrigger,
+} from '../../../components/_molecules/modal'
 import type { PLCBaseType } from '../../../utils/plc-constants'
-
+import { Button } from '../buttons/default'
 import TableActions from '../table-actions'
 import { TypeDropdownSelector } from '../type-dropdown-selector'
 import { ArrayDimensionsInput } from './array-dimensions-input'
diff --git a/src2/frontend/components/_atoms/file/index.tsx b/src/frontend/components/_atoms/file/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/file/index.tsx
rename to src/frontend/components/_atoms/file/index.tsx
index d479cc84b..2294e85b8 100644
--- a/src2/frontend/components/_atoms/file/index.tsx
+++ b/src/frontend/components/_atoms/file/index.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type IFileProps = ComponentPropsWithoutRef<'div'> & {
   projectName: string
   projectPath: string
diff --git a/src2/frontend/components/_atoms/generic-data-type-table/index.tsx b/src/frontend/components/_atoms/generic-data-type-table/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/generic-data-type-table/index.tsx
rename to src/frontend/components/_atoms/generic-data-type-table/index.tsx
index b957b0bfe..c40006d1b 100644
--- a/src2/frontend/components/_atoms/generic-data-type-table/index.tsx
+++ b/src/frontend/components/_atoms/generic-data-type-table/index.tsx
@@ -1,7 +1,8 @@
-import { Table, TableBody, TableCell, TableRow } from '../table'
 import { flexRender, Table as ReactTable } from '@tanstack/react-table'
 import React, { RefObject } from 'react'
 
+import { Table, TableBody, TableCell, TableRow } from '../table'
+
 interface GenericTableProps {
   context: 'data-type-array' | 'data-type-enumerated'
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
diff --git a/src2/frontend/components/_atoms/generic-table-inputs/generic-button-cell.tsx b/src/frontend/components/_atoms/generic-table-inputs/generic-button-cell.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/generic-table-inputs/generic-button-cell.tsx
rename to src/frontend/components/_atoms/generic-table-inputs/generic-button-cell.tsx
index e1a9a52a9..7d3e7fda8 100644
--- a/src2/frontend/components/_atoms/generic-table-inputs/generic-button-cell.tsx
+++ b/src/frontend/components/_atoms/generic-table-inputs/generic-button-cell.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import React from 'react'
 
+import { cn } from '../../../utils/cn'
+
 export const GenericButtonCell = ({
   value,
   onClick,
diff --git a/src2/frontend/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx b/src/frontend/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
rename to src/frontend/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
index 04fe29141..c346b3827 100644
--- a/src2/frontend/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
+++ b/src/frontend/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
@@ -1,9 +1,9 @@
 import * as PrimitiveDropdown from '@radix-ui/react-dropdown-menu'
+import { useEffect, useMemo, useRef, useState } from 'react'
+
 import { CloseIcon } from '../../../assets/icons/interface/Close'
 import { PlusIcon } from '../../../assets/icons/interface/Plus'
 import { cn } from '../../../utils/cn'
-import { useEffect, useMemo, useRef, useState } from 'react'
-
 import ScrollAreaComponent from '../../ui/scroll-area'
 import { InputWithRef } from '../input'
 
diff --git a/src2/frontend/components/_atoms/generic-table-inputs/generic-select-cell.tsx b/src/frontend/components/_atoms/generic-table-inputs/generic-select-cell.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/generic-table-inputs/generic-select-cell.tsx
rename to src/frontend/components/_atoms/generic-table-inputs/generic-select-cell.tsx
index 19b0284d3..b9fde763d 100644
--- a/src2/frontend/components/_atoms/generic-table-inputs/generic-select-cell.tsx
+++ b/src/frontend/components/_atoms/generic-table-inputs/generic-select-cell.tsx
@@ -1,7 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { startCase } from 'lodash'
 import { useEffect, useRef, useState } from 'react'
 
+import { cn } from '../../../utils/cn'
 import ScrollAreaComponent from '../../ui/scroll-area'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../select'
 
diff --git a/src2/frontend/components/_atoms/generic-table-inputs/generic-text-cell.tsx b/src/frontend/components/_atoms/generic-table-inputs/generic-text-cell.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/generic-table-inputs/generic-text-cell.tsx
rename to src/frontend/components/_atoms/generic-table-inputs/generic-text-cell.tsx
index 83e831e59..13eef525e 100644
--- a/src2/frontend/components/_atoms/generic-table-inputs/generic-text-cell.tsx
+++ b/src/frontend/components/_atoms/generic-table-inputs/generic-text-cell.tsx
@@ -1,8 +1,8 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
 import { useOpenPLCStore } from '../../../store'
 import { extractSearchQuery } from '../../../store/slices/search/utils'
 import { cn } from '../../../utils/cn'
-import { useCallback, useEffect, useRef, useState } from 'react'
-
 import { InputWithRef } from '../input'
 
 export const GenericTextCell = ({
diff --git a/src2/frontend/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx b/src/frontend/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
rename to src/frontend/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
index 7c0111de0..daa31ecaa 100644
--- a/src2/frontend/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
+++ b/src/frontend/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
@@ -1,4 +1,5 @@
 import * as PrimitivePopover from '@radix-ui/react-popover'
+
 import { cn } from '../../../utils/cn'
 
 export const GenericAreaTextCell = ({
diff --git a/src2/frontend/components/_atoms/generic-table/index.tsx b/src/frontend/components/_atoms/generic-table/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/generic-table/index.tsx
rename to src/frontend/components/_atoms/generic-table/index.tsx
index 4b7dd5f0a..8481c9d37 100644
--- a/src2/frontend/components/_atoms/generic-table/index.tsx
+++ b/src/frontend/components/_atoms/generic-table/index.tsx
@@ -1,5 +1,3 @@
-import type { ProjectResponse } from '../../../store/slices/project'
-import { cn } from '../../../utils/cn'
 import {
   ColumnDef,
   ColumnFiltersState,
@@ -11,6 +9,8 @@ import {
 } from '@tanstack/react-table'
 import { useEffect, useRef } from 'react'
 
+import type { ProjectResponse } from '../../../store/slices/project'
+import { cn } from '../../../utils/cn'
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '../table'
 
 type GenericTableProps<T> = {
diff --git a/src2/frontend/components/_atoms/graphical-editor/autocomplete/index.tsx b/src/frontend/components/_atoms/graphical-editor/autocomplete/index.tsx
similarity index 92%
rename from src2/frontend/components/_atoms/graphical-editor/autocomplete/index.tsx
rename to src/frontend/components/_atoms/graphical-editor/autocomplete/index.tsx
index f6e051acb..b402cc585 100644
--- a/src2/frontend/components/_atoms/graphical-editor/autocomplete/index.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/autocomplete/index.tsx
@@ -1,8 +1,9 @@
 import * as Popover from '@radix-ui/react-popover'
-import { PlusIcon } from '../../../../assets/icons/interface/Plus'
+import { ComponentPropsWithRef, forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react'
+
 import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
+import { PlusIcon } from '../../../../assets/icons/interface/Plus'
 import { cn } from '../../../../utils/cn'
-import { ComponentPropsWithRef, forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react'
 
 export type GraphicalEditorAutocompleteProps = ComponentPropsWithRef<'div'> & {
   isOpen?: boolean
@@ -82,9 +83,19 @@ export const GraphicalEditorAutocomplete = forwardRef<HTMLDivElement, GraphicalE
             }
           : undefined,
       ].filter((variable) => variable !== undefined)
-      // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [variables, searchValue])
 
+    const closeModal = () => {
+      setAutocompleteFocus(false)
+      setSelectedVariable({ positionInArray: -1, variable: { id: '', name: '' } })
+      if (setIsOpen) setIsOpen(false)
+    }
+
+    const submitAutocompletion = ({ variable }: { variable: { id: string; name: string } }) => {
+      closeModal()
+      submit({ variable })
+    }
+
     // @ts-expect-error - not all properties are used
     useImperativeHandle(ref, () => {
       return {
@@ -93,8 +104,25 @@ export const GraphicalEditorAutocomplete = forwardRef<HTMLDivElement, GraphicalE
         },
         isFocused: autocompleteFocus,
         selectedVariable: selectedVariable,
+        /**
+         * Synchronously triggers the submit action.
+         * Used by parent components to bypass the async keyPressed → keyDown useEffect chain
+         * which can cause race conditions when the autocomplete unmounts on blur.
+         */
+        triggerSubmit: () => {
+          if (selectedVariable.positionInArray === -1) {
+            const addVariableOption = selectableValues.find((item) => item.type === 'add')
+            if (addVariableOption) {
+              submitAutocompletion({ variable: addVariableOption.variable })
+            } else {
+              closeModal()
+            }
+          } else {
+            submitAutocompletion({ variable: selectedVariable.variable })
+          }
+        },
       }
-    }, [selectedVariable, popoverRef, autocompleteFocus])
+    }, [selectedVariable, selectableValues, popoverRef, autocompleteFocus, submitAutocompletion, closeModal])
 
     useEffect(() => {
       switch (keyDown) {
@@ -143,7 +171,6 @@ export const GraphicalEditorAutocomplete = forwardRef<HTMLDivElement, GraphicalE
           break
       }
       setKeyDown('')
-      // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [keyDown])
 
     useEffect(() => {
@@ -152,7 +179,6 @@ export const GraphicalEditorAutocomplete = forwardRef<HTMLDivElement, GraphicalE
 
     useEffect(() => {
       scrollWhenSelectedIsChanged()
-      // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [selectedVariable])
 
     const scrollWhenSelectedIsChanged = () => {
@@ -162,17 +188,6 @@ export const GraphicalEditorAutocomplete = forwardRef<HTMLDivElement, GraphicalE
       }
     }
 
-    const closeModal = () => {
-      setAutocompleteFocus(false)
-      setSelectedVariable({ positionInArray: -1, variable: { id: '', name: '' } })
-      if (setIsOpen) setIsOpen(false)
-    }
-
-    const submitAutocompletion = ({ variable }: { variable: { id: string; name: string } }) => {
-      closeModal()
-      submit({ variable })
-    }
-
     return (
       <Popover.Root open={isOpen ? isOpen : false}>
         <Popover.Trigger />
diff --git a/src/frontend/components/_atoms/graphical-editor/block-output-debug-badges.tsx b/src/frontend/components/_atoms/graphical-editor/block-output-debug-badges.tsx
new file mode 100644
index 000000000..e66868098
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/block-output-debug-badges.tsx
@@ -0,0 +1,79 @@
+import { useDebugCompositeKey } from '../../../hooks/use-debug-composite-key'
+import { useOpenPLCStore } from '../../../store'
+import { DebugValueBadge } from './debug-value-badge'
+
+type BlockOutputDebugBadgesProps = {
+  blockType: string
+  blockName: string
+  blockVariableName: string
+  numericId: string
+  outputVariables: Array<{ name: string; class: string; type: { definition: string; value: string } }>
+  connectorStartY: number
+  connectorOffsetY: number
+  blockWidth: number
+  /** Output names that already have a variable node connected showing its own badge. */
+  connectedOutputNames?: Set<string>
+}
+
+/**
+ * Renders debug value badges next to each output connector of a block node.
+ * Works for both function blocks (using instance-qualified names) and
+ * functions (using _TMP_ variable names). Shared between FBD and LD.
+ *
+ * Outputs that are connected to a variable node are skipped since the
+ * variable node already displays its own badge (avoids double badges).
+ */
+const BlockOutputDebugBadges = ({
+  blockType,
+  blockName,
+  blockVariableName,
+  numericId,
+  outputVariables,
+  connectorStartY,
+  connectorOffsetY,
+  blockWidth,
+  connectedOutputNames,
+}: BlockOutputDebugBadgesProps) => {
+  const {
+    workspace: { isDebuggerVisible },
+  } = useOpenPLCStore()
+  const getCompositeKey = useDebugCompositeKey()
+
+  if (!isDebuggerVisible || blockType === 'generic') {
+    return null
+  }
+
+  const outputs = outputVariables.filter((v) => v.class === 'output' || v.class === 'inOut')
+
+  return (
+    <>
+      {outputs.map((outputVar, index) => {
+        if (connectedOutputNames?.has(outputVar.name)) {
+          return null
+        }
+
+        let compositeKey: string
+        if (blockType === 'function-block') {
+          compositeKey = getCompositeKey(`${blockVariableName}.${outputVar.name}`)
+        } else {
+          compositeKey = getCompositeKey(`_TMP_${blockName.toUpperCase()}${numericId}_${outputVar.name}`)
+        }
+
+        return (
+          <div
+            key={outputVar.name}
+            className='pointer-events-none absolute'
+            style={{
+              top: connectorStartY + index * connectorOffsetY - 10,
+              left: blockWidth,
+            }}
+          >
+            <DebugValueBadge compositeKey={compositeKey} variableType={outputVar.type.value} position='right' />
+          </div>
+        )
+      })}
+    </>
+  )
+}
+
+export { BlockOutputDebugBadges }
diff --git a/src/frontend/components/_atoms/graphical-editor/debug-value-badge.tsx b/src/frontend/components/_atoms/graphical-editor/debug-value-badge.tsx
new file mode 100644
index 000000000..9afae7e22
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/debug-value-badge.tsx
@@ -0,0 +1,52 @@
+import { useOpenPLCStore } from '../../../store'
+import { cn } from '../../../utils/cn'
+
+type DebugValueBadgeProps = {
+  compositeKey: string
+  variableType: string | undefined
+  position?: 'right' | 'left' | 'below'
+}
+
+/**
+ * Displays a real-time debug value badge next to graphical editor nodes.
+ * Shows the current polled value for non-BOOL variables when the debugger is active.
+ * BOOL variables are skipped since they already have dedicated color indicators.
+ *
+ * Designed to be used by both FBD and LD variable/block nodes.
+ */
+const DebugValueBadge = ({ compositeKey, variableType, position = 'right' }: DebugValueBadgeProps) => {
+  const {
+    workspace: { debugVariableValues },
+  } = useOpenPLCStore()
+
+  if (!variableType || variableType.toUpperCase() === 'BOOL') {
+    return null
+  }
+
+  const value = debugVariableValues.get(compositeKey)
+  if (value === undefined) {
+    return null
+  }
+
+  const positionClasses: Record<string, string> = {
+    right: 'left-full ml-1 top-1/2 -translate-y-1/2',
+    left: 'right-full mr-1 top-1/2 -translate-y-1/2',
+    below: 'top-full mt-0.5 left-1/2 -translate-x-1/2',
+  }
+
+  return (
+    <div
+      className={cn(
+        'pointer-events-none absolute z-20 flex items-center whitespace-nowrap rounded px-1.5 py-0.5',
+        'bg-[#2E7D32] text-[10px] font-semibold leading-tight text-white',
+        'dark:bg-[#388E3C]',
+        positionClasses[position],
+      )}
+    >
+      {value}
+    </div>
+  )
+}
+
+export { DebugValueBadge }
+export type { DebugValueBadgeProps }
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
similarity index 95%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
index e4808426e..d3b1ebc36 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
@@ -1,14 +1,15 @@
-import { toast } from '../../../../_features/[app]/toast/use-toast'
-import { buildGenericNode } from '../../../../_molecules/graphical-editor/fbd/fbd-utils/nodes'
-import { useOpenPLCStore } from '../../../../../store'
-import { extractNumberAtEnd } from '../../../../../store/slices/project/validation/variables'
-import { PLCVariable } from '../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../utils/cn'
-import { expandArrayVariables } from '../../../../../../backend/shared/array-variable-utils'
 import { Node } from '@xyflow/react'
 import { isArray } from 'lodash'
 import { ComponentPropsWithRef, forwardRef, useMemo } from 'react'
 
+import { PLCVariable } from '../../../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '../../../../../store'
+import { extractNumberAtEnd } from '../../../../../store/slices/project/validation/variables'
+import { cn } from '../../../../../utils/cn'
+import { getLiteralType } from '../../../../../utils/keywords'
+import { expandArrayVariables } from '../../../../../utils/PLC/array-variable-utils'
+import { toast } from '../../../../_features/[app]/toast/use-toast'
+import { buildGenericNode } from '../../../../_molecules/graphical-editor/fbd/fbd-utils/nodes'
 import { GraphicalEditorAutocomplete } from '../../autocomplete'
 import { BlockVariant } from '../../types/block'
 import { getVariableRestrictionType } from '../../utils'
@@ -93,7 +94,6 @@ const FBDBlockAutoComplete = forwardRef<HTMLDivElement, FBDBlockAutoCompleteProp
             definition: undefined,
           }
       }
-      // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [pou])
 
     const expandedVariables = expandArrayVariables(variables.all)
@@ -115,12 +115,12 @@ const FBDBlockAutoComplete = forwardRef<HTMLDivElement, FBDBlockAutoCompleteProp
             return aNumber - bNumber
           })
       : block.type === 'connector' || block.type === 'continuation'
-        ? (rung?.nodes
+        ? rung?.nodes
             .filter((node) => (block.type === 'connector' ? node.type === 'continuation' : node.type === 'connector'))
             .map((node) => {
               return node.data.variable as PLCVariable
             })
-            .filter((variable) => variable.name !== '') ?? ([] as PLCVariable[]))
+            .filter((variable) => variable.name !== '') ?? ([] as PLCVariable[])
         : ([] as PLCVariable[])
 
     const submitVariableToBlock = (variable: PLCVariable) => {
@@ -194,7 +194,6 @@ const FBDBlockAutoComplete = forwardRef<HTMLDivElement, FBDBlockAutoCompleteProp
         data: {
           id: crypto.randomUUID(),
           name: variableName,
-          // @ts-expect-error - type is dynamic
           type: {
             definition: variableTypeRestriction.definition as 'base-type' | 'derived' | 'array' | 'user-data-type',
             value: variableTypeRestriction.value,
@@ -244,6 +243,12 @@ const FBDBlockAutoComplete = forwardRef<HTMLDivElement, FBDBlockAutoCompleteProp
 
     const submit = ({ variable }: { variable: { id: string; name: string } }) => {
       if (variable.id === 'add') {
+        // Check if the input is a literal value (e.g., 2.0, TRUE, 'hello')
+        // Literals should be submitted directly to the block, not created as variables
+        if (getLiteralType(valueToSearch)) {
+          submitVariableToBlock({ name: valueToSearch } as PLCVariable)
+          return
+        }
         submitAddVariable({ variableName: valueToSearch })
         return
       }
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/block.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/block.tsx
similarity index 89%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/block.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/block.tsx
index 7e8e2f0fe..76b58d56d 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/block.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/block.tsx
@@ -1,22 +1,31 @@
-import { toast } from '../../../_features/[app]/toast/use-toast'
-import { useOpenPLCStore } from '../../../../store'
-import { checkVariableNameUnit } from '../../../../store/slices/project/validation/variables'
+import { FocusEvent, useEffect, useMemo, useRef, useState } from 'react'
+import { v4 as uuidv4 } from 'uuid'
+
 import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
+import { RefreshIcon } from '../../../../assets/icons/interface/Refresh'
+import { useOpenPLCStore } from '../../../../store'
+import { checkVariableName } from '../../../../store/slices/project/validation/variables'
 import { cn } from '../../../../utils/cn'
-import { FocusEvent, useEffect, useRef, useState } from 'react'
-
-import { v4 as uuidv4 } from 'uuid'
+import { toast } from '../../../_features/[app]/toast/use-toast'
 import { HighlightedTextArea } from '../../highlighted-textarea'
 import { InputWithRef } from '../../input'
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../../tooltip'
+import { BlockOutputDebugBadges } from '../block-output-debug-badges'
 import { BlockVariant } from '../types/block'
 import { getBlockDocumentation, getVariableRestrictionType } from '../utils'
 import { buildBlockNode } from './buildNodes'
 import { CustomHandle } from './handle'
 import { BasicNodeData, BlockNodeData, BlockProps } from './utils'
-import { DEFAULT_BLOCK_CONNECTOR_Y, DEFAULT_BLOCK_CONNECTOR_Y_OFFSET, DEFAULT_BLOCK_HEIGHT, DEFAULT_BLOCK_TYPE, DEFAULT_BLOCK_WIDTH, } from './utils/constants'
+import {
+  DEFAULT_BLOCK_CONNECTOR_Y,
+  DEFAULT_BLOCK_CONNECTOR_Y_OFFSET,
+  DEFAULT_BLOCK_HEIGHT,
+  DEFAULT_BLOCK_TYPE,
+  DEFAULT_BLOCK_WIDTH,
+} from './utils/constants'
 import { getFBDPouVariablesRungNodeAndEdges } from './utils/utils'
-import { RefreshIcon } from '../../../../assets/icons/interface/Refresh'
+
+export type { BlockNode, BlockNodeData } from './utils/types'
 
 export const BlockNodeElement = <T extends object>({
   nodeId,
@@ -89,7 +98,6 @@ export const BlockNodeElement = <T extends object>({
           break
       }
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   /**
@@ -100,7 +108,6 @@ export const BlockNodeElement = <T extends object>({
       setBlockNameValue(blockName)
       return
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [data])
 
   const handleNameInputOnBlur = () => {
@@ -110,11 +117,7 @@ export const BlockNodeElement = <T extends object>({
       return
     }
 
-    const libraryBlock = libraries.system
-      // @ts-expect-error - type is dynamic
-      .flatMap((block) => block.pous)
-      // @ts-expect-error - type is dynamic
-      .find((pou) => pou.name === blockNameValue)
+    const libraryBlock = libraries.system.flatMap((block) => block.pous).find((pou) => pou.name === blockNameValue)
 
     if (!libraryBlock) {
       setBlockNameValue(validBlockNameValue)
@@ -124,7 +127,7 @@ export const BlockNodeElement = <T extends object>({
 
     if (!pou || !rung || !node) return
 
-    if (libraryBlock && pou.type === 'function' && (libraryBlock as BlockVariant).type !== 'function') {
+    if (libraryBlock && pou.pouType === 'function' && (libraryBlock as BlockVariant).type !== 'function') {
       setWrongName(true)
       toast({
         title: 'Can not add block',
@@ -344,6 +347,20 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     nodeId: id ?? '',
   })
 
+  // Outputs connected to variable nodes already show their own badge — skip those
+  const connectedOutputNames = useMemo(() => {
+    const names = new Set<string>()
+    if (!rung) return names
+    const outgoingEdges = rung.edges.filter((e) => e.source === id)
+    for (const edge of outgoingEdges) {
+      const targetNode = rung.nodes.find((n) => n.id === edge.target)
+      if (targetNode && typeof targetNode.type === 'string' && targetNode.type.includes('variable')) {
+        if (edge.sourceHandle) names.add(edge.sourceHandle)
+      }
+    }
+    return names
+  }, [rung, id])
+
   const inputVariableRef = useRef<
     HTMLTextAreaElement & {
       blur: ({ submit }: { submit?: boolean }) => void
@@ -367,10 +384,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       switch (blockType) {
         case 'function-block': {
           if (!data.variable || data.variable.name === '') {
-            const { name, number } = checkVariableNameUnit(
-              variables.all,
-              (data.variant as BlockVariant).name.toUpperCase(),
-            )
+            const { name, number } = checkVariableName(variables.all, (data.variant as BlockVariant).name.toUpperCase())
             handleSubmitBlockVariableOnTextareaBlur(`${name}${number}`, true)
             hasCreatedRef.current = true
             return
@@ -382,7 +396,6 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
           break
       }
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [data])
 
   /**
@@ -424,7 +437,6 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     }
 
     setWrongVariable(false)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pous])
 
   /**
@@ -456,9 +468,9 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     const findMatchingVariable = () =>
       variables.all.find(
         (variable) =>
-          variable.name === variableNameToSubmit &&
+          variable.name.toLowerCase() === variableNameToSubmit.toLowerCase() &&
           variable.type.definition === 'derived' &&
-          variable.type.value === blockType,
+          variable.type.value.toLowerCase() === blockType.toLowerCase(),
       )
 
     const updateNodeVariable = (variable: Partial<PLCVariable> | { name: string }) => {
@@ -477,7 +489,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     const matchingVariable = findMatchingVariable()
 
     if (variableToLink) {
-      if (variableToLink.name === variableNameToSubmit) return
+      if (variableToLink.name.toLowerCase() === variableNameToSubmit.toLowerCase()) return
 
       if (matchingVariable && matchingVariable.id !== variableToLink.id) {
         variableToLink = matchingVariable
@@ -543,11 +555,11 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     const libMatch = userLibraries.find((lib) => lib.name === variant.name && lib.type === variant.type)
     if (!libMatch) return
 
-    const libPou = pous.find((pou) => pou.data.name === libMatch.name)
+    const libPou = pous.find((pou) => pou.name === libMatch.name)
     if (!libPou) return
 
     const blockVariant = node.data.variant as BlockVariant
-    const newNodeVariables = (libPou.data.variables || []).map((variable) => {
+    const newNodeVariables = (libPou.interface?.variables ?? []).map((variable) => {
       let newType
       switch (variable.type.definition) {
         case 'array':
@@ -584,8 +596,8 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       }
     })
 
-    if (libPou.type === 'function') {
-      const variable = getVariableRestrictionType(libPou.data.returnType)
+    if (libPou.pouType === 'function') {
+      const variable = getVariableRestrictionType(libPou.interface?.returnType ?? '')
       const hasOut = newNodeVariables.some((v) => v.name === 'OUT')
       if (!hasOut)
         newNodeVariables.push({
@@ -594,7 +606,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
           class: 'output',
           type: {
             definition: variable.definition ?? 'derived',
-            value: libPou.data.returnType.toUpperCase(),
+            value: (libPou.interface?.returnType ?? '').toUpperCase(),
           },
           location: '',
           documentation: '',
@@ -608,7 +620,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
         x: node.position.x,
         y: node.position.y,
       },
-      variant: { ...libPou.data, type: blockVariant.type, variables: newNodeVariables },
+      variant: { name: libPou.name, type: blockVariant.type, variables: newNodeVariables },
       executionControl: (node.data as BlockNodeData<BlockVariant>).executionControl,
     })
     updatedNewNode.data = {
@@ -726,7 +738,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     >
       {data.hasDivergence && hoveringBlock && (
         <div
-          className='h-6 w-6 absolute right-[-12px] top-[-12px] pointer z-10 rounded-full bg-slate-600 flex justify-center items-center shadow-sm'
+          className='pointer absolute right-[-12px] top-[-12px] z-10 flex h-6 w-6 items-center justify-center rounded-full bg-slate-600 shadow-sm'
           onClick={handleUpdateDivergence}
         >
           <TooltipProvider>
@@ -787,6 +799,17 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       {data.handles.map((handle, index) => (
         <CustomHandle key={index} {...handle} />
       ))}
+      <BlockOutputDebugBadges
+        blockType={(data.variant as BlockVariant).type}
+        blockName={(data.variant as BlockVariant).name}
+        blockVariableName={data.variable?.name ?? ''}
+        numericId={data.numericId}
+        outputVariables={(data.variant as BlockVariant).variables}
+        connectorStartY={DEFAULT_BLOCK_CONNECTOR_Y}
+        connectorOffsetY={DEFAULT_BLOCK_CONNECTOR_Y_OFFSET}
+        blockWidth={width ?? DEFAULT_BLOCK_WIDTH}
+        connectedOutputNames={connectedOutputNames}
+      />
     </div>
   )
 }
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
index eaecab711..5f69f9791 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
@@ -1,15 +1,9 @@
-import type {
-  BlockBuilderProps,
-  CommentBuilderProps,
-  CommentNode,
-  ConnectionBuilderProps,
-  ConnectionNode,
-  VariableBuilderProps,
-  VariableNode,
-} from './utils/types'
+import { Position } from '@xyflow/react'
+
 import { generateNumericUUID } from '../../../../utils/generate-uuid'
-import { getBlockSize, getBlockVariantAndExecutionControl } from './utils'
 import { BlockVariant } from '../types/block'
+import { buildHandle } from './handle'
+import { getBlockSize, getBlockVariantAndExecutionControl } from './utils'
 import {
   CONNECTION_ELEMENT_HEIGHT,
   CONNECTION_ELEMENT_WIDTH,
@@ -24,8 +18,15 @@ import {
   VARIABLE_ELEMENT_HEIGHT,
   VARIABLE_ELEMENT_SIZE,
 } from './utils/constants'
-import { buildHandle } from './handle'
-import { Position } from '@xyflow/react'
+import type {
+  BlockBuilderProps,
+  CommentBuilderProps,
+  CommentNode,
+  ConnectionBuilderProps,
+  ConnectionNode,
+  VariableBuilderProps,
+  VariableNode,
+} from './utils/types'
 
 /**
  *
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/comment.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/comment.tsx
similarity index 94%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/comment.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/comment.tsx
index 438146e39..cb627942e 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/comment.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/comment.tsx
@@ -1,12 +1,12 @@
-import { useOpenPLCStore } from '../../../../store'
-import { cn } from '../../../../utils/cn'
 import { NodeResizer } from '@xyflow/react'
 import { memo, useEffect, useRef, useState } from 'react'
 
+import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
 import { HighlightedTextArea } from '../../highlighted-textarea'
 import { getFBDPouVariablesRungNodeAndEdges } from './utils'
-import { CommentNode, CommentProps } from './utils/types'
 import { MINIMUM_ELEMENT_HEIGHT, MINIMUM_ELEMENT_WIDTH } from './utils/constants'
+import { CommentNode, CommentProps } from './utils/types'
 
 const CommentElement = (block: CommentProps) => {
   const { id, selected, data, width, height } = block
@@ -35,10 +35,18 @@ const CommentElement = (block: CommentProps) => {
     if (data.content) {
       setCommentValue(data.content)
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
+  const didMountRef = useRef(false)
   useEffect(() => {
+    // Skip the initial mount — commentFocused starts as false and the node
+    // already has the correct content. Calling updateNode here would mark
+    // the flow as updated (unsaved) without any user edit.
+    if (!didMountRef.current) {
+      didMountRef.current = true
+      return
+    }
+
     const { node: commentaryBlock } = getFBDPouVariablesRungNodeAndEdges(editor, pous, fbdFlows, {
       nodeId: id,
     })
@@ -86,7 +94,6 @@ const CommentElement = (block: CommentProps) => {
     return () => {
       updateModelFBD({ canEditorZoom: true, canEditorPan: true })
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [commentFocused])
 
   const handleSubmitCommentaryValueOnTextareaBlur = () => {
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/connection.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/connection.tsx
similarity index 98%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/connection.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/connection.tsx
index 1ddc87598..4f5392d5a 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/connection.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/connection.tsx
@@ -1,7 +1,7 @@
-import { useOpenPLCStore } from '../../../../store'
-import { cn } from '../../../../utils/cn'
 import { useEffect, useRef, useState } from 'react'
 
+import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
 import { HighlightedTextArea } from '../../highlighted-textarea'
 import { FBDBlockAutoComplete } from './autocomplete'
 import { CustomHandle } from './handle'
@@ -59,7 +59,6 @@ const ConnectionElement = (block: ConnectionProps) => {
     if (inputConnectionRef.current && selected) {
       inputConnectionRef.current.focus()
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   /**
@@ -87,7 +86,6 @@ const ConnectionElement = (block: ConnectionProps) => {
     if ((connectionNode.data as BasicNodeData).variable.name !== connectionValue) {
       setConnectionValue((connectionNode.data as BasicNodeData).variable.name)
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pous])
 
   /**
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/handle.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/handle.tsx
similarity index 95%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/handle.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/handle.tsx
index 1d43cf322..090edb5a9 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/handle.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/handle.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { Handle, HandleProps } from '@xyflow/react'
 
+import { cn } from '../../../../utils/cn'
+
 export type CustomHandleProps = HandleProps & {
   glbPosition: {
     x: number
@@ -21,6 +22,8 @@ export const CustomHandle = ({
   position,
   isConnectable,
   isDebuggerVisible,
+  glbPosition: _glb,
+  relPosition: _rel,
   ...props
 }: CustomHandleProps) => {
   return (
@@ -50,7 +53,6 @@ type BuildHandleProps = HandleProps & {
  * @param relY: number - The y coordinate of the handle based on the relative position (inside the node)
  * @returns CustomHandleProps
  */
-// eslint-disable-next-line react-refresh/only-export-components
 export const buildHandle = ({ glbX, glbY, relX, relY, ...rest }: BuildHandleProps) => {
   return {
     glbPosition: {
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/index.ts b/src/frontend/components/_atoms/graphical-editor/fbd/index.ts
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/index.ts
rename to src/frontend/components/_atoms/graphical-editor/fbd/index.ts
index 454609db8..80007b3ba 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/index.ts
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/index.ts
@@ -1,8 +1,8 @@
 import * as blockNode from './block'
+import * as buildNodes from './buildNodes'
 import * as commentNode from './comment'
 import * as connectionNode from './connection'
 import * as variableNode from './variable'
-import * as buildNodes from './buildNodes'
 
 export const customNodeTypes = {
   block: blockNode.Block,
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/svg/index.ts b/src/frontend/components/_atoms/graphical-editor/fbd/svg/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/svg/index.ts
rename to src/frontend/components/_atoms/graphical-editor/fbd/svg/index.ts
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
similarity index 92%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
index 3733ef278..7776cb494 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
@@ -43,4 +43,4 @@ export const VARIABLE_ELEMENT_HEIGHT = 32
 export const DEFAULT_VARIABLE_CONNECTOR_X = DEFAULT_VARIABLE_WIDTH
 export const DEFAULT_VARIABLE_CONNECTOR_Y = DEFAULT_VARIABLE_HEIGHT / 2
 
-export const FBD_VARIABLE_NODE_TYPES = ['input-variable', 'output-variable', 'inout-variable'] as const
+export { FBD_VARIABLE_NODE_TYPES } from '../../../../../utils/graphical/constants'
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/utils/index.ts b/src/frontend/components/_atoms/graphical-editor/fbd/utils/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/utils/index.ts
rename to src/frontend/components/_atoms/graphical-editor/fbd/utils/index.ts
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts b/src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
rename to src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
index e5351499f..d7a899711 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
@@ -1,6 +1,6 @@
-import type { PLCVariable } from '../../../../../../middleware/shared/ports/types'
 import { Node, NodeProps, XYPosition } from '@xyflow/react'
 
+import type { PLCVariable } from '../../../../../../middleware/shared/ports/types'
 import { CustomHandleProps } from '../handle'
 
 export type BuilderBasicProps = {
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/utils.ts b/src/frontend/components/_atoms/graphical-editor/fbd/utils/utils.ts
similarity index 96%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/utils/utils.ts
rename to src/frontend/components/_atoms/graphical-editor/fbd/utils/utils.ts
index dbc1e43c1..38af878cb 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/utils.ts
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/utils/utils.ts
@@ -1,16 +1,16 @@
+import { Position } from '@xyflow/react'
+
+import { resolveArrayVariableByName } from '../../../../../utils/PLC/array-variable-utils'
+import type { PLCPou } from '../../../../../../middleware/shared/ports/types'
+import type { PLCVariable } from '../../../../../../middleware/shared/ports/types'
 import type { EditorModel } from '../../../../../store/slices/editor'
 import type { FBDFlowType } from '../../../../../store/slices/fbd'
 import type { LadderFlowType } from '../../../../../store/slices/ladder'
-import type { PLCPou } from '../../../../../../middleware/shared/ports/types'
-import type { PLCVariable } from '../../../../../../middleware/shared/ports/types'
-import { resolveArrayVariableByName } from '../../../../../../backend/shared/array-variable-utils'
-
-import { customNodeTypes } from '..'
-import type { BasicNodeData } from './types'
 import { BlockVariant } from '../../types/block'
-import { DEFAULT_BLOCK_CONNECTOR_Y, DEFAULT_BLOCK_CONNECTOR_Y_OFFSET, DEFAULT_BLOCK_WIDTH } from './constants'
+import { customNodeTypes } from '..'
 import { buildHandle } from '../handle'
-import { Position } from '@xyflow/react'
+import { DEFAULT_BLOCK_CONNECTOR_Y, DEFAULT_BLOCK_CONNECTOR_Y_OFFSET, DEFAULT_BLOCK_WIDTH } from './constants'
+import type { BasicNodeData } from './types'
 
 export const getFBDPouVariablesRungNodeAndEdges = (
   editor: EditorModel,
@@ -27,11 +27,11 @@ export const getFBDPouVariablesRungNodeAndEdges = (
   }
   node: LadderFlowType['rungs'][0]['nodes'][0] | undefined
 } => {
-  const pou = pous.find((pou) => pou.data.name === editor.meta.name)
+  const pou = pous.find((pou) => pou.name === editor.meta.name)
   const rung = fbdFlows.find((flow) => flow.name === editor.meta.name)?.rung
   const node = rung?.nodes.find((node) => node.id === data.nodeId)
 
-  const variables: PLCVariable[] = pou?.data.variables as PLCVariable[]
+  const variables: PLCVariable[] = pou?.interface?.variables ?? []
   let variable = variables.find((variable) => {
     if (!node) return undefined
     switch (node.type as keyof typeof customNodeTypes) {
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/variable.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/variable.tsx
similarity index 94%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/variable.tsx
rename to src/frontend/components/_atoms/graphical-editor/fbd/variable.tsx
index 92a287485..bac35037a 100644
--- a/src2/frontend/components/_atoms/graphical-editor/fbd/variable.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/variable.tsx
@@ -1,8 +1,12 @@
+import * as Popover from '@radix-ui/react-popover'
+import { useEffect, useMemo, useRef, useState } from 'react'
+
+import { PLCVariable } from '../../../../../middleware/shared/ports/types'
 import { useDebugger } from '../../../../../middleware/shared/providers'
 import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
 import { useOpenPLCStore } from '../../../../store'
-import { PLCVariable } from '../../../../../middleware/shared/ports/types'
 import { cn } from '../../../../utils/cn'
+import { resolveArrayVariableByName } from '../../../../utils/PLC/array-variable-utils'
 import {
   floatToBuffer,
   getVariableTypeInfo,
@@ -12,19 +16,15 @@ import {
   parseStringValue,
   stringToBuffer,
 } from '../../../../utils/variable-types'
-import { resolveArrayVariableByName } from '../../../../../backend/shared/array-variable-utils'
-import { useEffect, useMemo, useRef, useState } from 'react'
-import * as Popover from '@radix-ui/react-popover'
-
+import { Modal, ModalContent, ModalTitle } from '../../../_molecules/modal'
 import { HighlightedTextArea } from '../../highlighted-textarea'
 import { Label } from '../../label'
-import { Modal, ModalContent, ModalTitle } from '../../../_molecules/modal'
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../../tooltip'
+import { DebugValueBadge } from '../debug-value-badge'
 import { BlockVariant } from '../types/block'
 import { validateVariableType } from '../utils'
 import { FBDBlockAutoComplete } from './autocomplete'
 import { CustomHandle } from './handle'
-import { getFBDPouVariablesRungNodeAndEdges } from './utils/utils'
 import { BlockNode, VariableNode, VariableProps } from './utils'
 import {
   DEFAULT_VARIABLE_HEIGHT,
@@ -32,6 +32,7 @@ import {
   VARIABLE_ELEMENT_HEIGHT,
   VARIABLE_ELEMENT_SIZE,
 } from './utils/constants'
+import { getFBDPouVariablesRungNodeAndEdges } from './utils/utils'
 
 const VariableElement = (block: VariableProps) => {
   const { id, data, selected } = block
@@ -60,6 +61,7 @@ const VariableElement = (block: VariableProps) => {
       focus: () => void
       isFocused: boolean
       selectedVariable: { positionInArray: number; variableName: string }
+      triggerSubmit?: () => void
     }
   >(null)
 
@@ -101,7 +103,6 @@ const VariableElement = (block: VariableProps) => {
         edge: connectedEdges[index],
         isSource: connectedEdges[index].source === id,
       }))
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [flow])
 
   const primaryConnection = useMemo(() => {
@@ -189,20 +190,22 @@ const VariableElement = (block: VariableProps) => {
       setVariableValue(data.variable.name)
       return
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   /**
-   * useEffect to sync variableValue from node props when autocomplete is closed
-   * This ensures the UI updates after autocomplete selection
+   * useEffect to sync variableValue from node props when the variable name changes externally
+   * (e.g., from autocomplete selection or variable rename propagation).
+   * Only sync when autocomplete is closed to avoid overwriting user input while typing.
+   * Note: openAutocomplete is intentionally NOT in the dependency array to prevent a race
+   * condition where closing the autocomplete (before blur) would restore the old node value,
+   * overwriting the user's cleared input.
    */
   useEffect(() => {
-    // Only sync when autocomplete is closed to avoid overwriting user input while typing
     const name = data.variable?.name ?? ''
     if (!openAutocomplete && name !== '') {
       setVariableValue(name)
     }
-  }, [data.variable?.name, openAutocomplete])
+  }, [data.variable?.name])
 
   /**
    * Update inputError state when the table of variables is updated
@@ -274,14 +277,15 @@ const VariableElement = (block: VariableProps) => {
       setInputError(false)
       return
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pous])
 
   const getVariableType = (): string | undefined => {
     if (!data.variable || !data.variable.name) return undefined
     const { pou } = getFBDPouVariablesRungNodeAndEdges(editor, pous, fbdFlows, { nodeId: id })
     if (!pou) return undefined
-    const variable = pou.data.variables.find((v) => v.name.toLowerCase() === data.variable.name.toLowerCase())
+    const variable = (pou.interface?.variables ?? []).find(
+      (v: PLCVariable) => v.name.toLowerCase() === data.variable.name.toLowerCase(),
+    )
     return variable?.type.value
   }
 
@@ -500,8 +504,8 @@ const VariableElement = (block: VariableProps) => {
     // For variable nodes, allow all types including derived (user-defined types)
     // Don't use getVariableByName here as it filters out derived types
     let variable: PLCVariable | { name: string } | undefined =
-      (pou.data.variables as PLCVariable[]).find((v) => v.name.toLowerCase() === variableNameToSubmit.toLowerCase()) ||
-      resolveArrayVariableByName(pou.data.variables as PLCVariable[], variableNameToSubmit)
+      (pou.interface?.variables ?? []).find((v) => v.name.toLowerCase() === variableNameToSubmit.toLowerCase()) ||
+      resolveArrayVariableByName(pou.interface?.variables ?? [], variableNameToSubmit)
     if (!variable) {
       setIsAVariable(false)
       variable = { name: variableNameToSubmit }
@@ -613,8 +617,11 @@ const VariableElement = (block: VariableProps) => {
                   onFocus={onChangeHandler}
                   onKeyDown={(e) => {
                     if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Tab') e.preventDefault()
-                    if (e.key === 'Enter' && (autocompleteRef.current?.selectedVariable.positionInArray ?? -1) !== -1) {
+                    if (e.key === 'Enter' && openAutocomplete) {
+                      e.preventDefault()
+                      autocompleteRef.current?.triggerSubmit?.()
                       inputVariableRef.current?.blur({ submit: false })
+                      return
                     }
                     setKeyPressedAtTextarea(e.key)
                   }}
@@ -634,6 +641,14 @@ const VariableElement = (block: VariableProps) => {
                 </div>
               )}
 
+              {isDebuggerVisible && isAVariable && (
+                <DebugValueBadge
+                  compositeKey={getCompositeKey(data.variable.name)}
+                  variableType={variableType}
+                  position={data.variant === 'output-variable' ? 'left' : 'right'}
+                />
+              )}
+
               {isDebuggerVisible && contextMenuPosition && (
                 <Popover.Root open={isContextMenuOpen} onOpenChange={setIsContextMenuOpen}>
                   <Popover.Portal>
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
similarity index 88%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
index 780266b94..1804ac44d 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
@@ -1,13 +1,14 @@
-import { toast } from '../../../../_features/[app]/toast/use-toast'
-import { useOpenPLCStore } from '../../../../../store'
-import { extractNumberAtEnd } from '../../../../../store/slices/project/validation/variables'
-import { PLCVariable } from '../../../../../../middleware/shared/ports'
-import { cn } from '../../../../../utils/cn'
-import { expandArrayVariables } from '../../../../../../backend/shared/array-variable-utils'
 import { Node } from '@xyflow/react'
 import { ComponentPropsWithRef, forwardRef } from 'react'
 import { v4 as uuidv4 } from 'uuid'
 
+import { PLCVariable } from '../../../../../../middleware/shared/ports'
+import { useOpenPLCStore } from '../../../../../store'
+import { extractNumberAtEnd } from '../../../../../store/slices/project/validation/variables'
+import { cn } from '../../../../../utils/cn'
+import { getLiteralType } from '../../../../../utils/keywords'
+import { expandArrayVariables } from '../../../../../utils/PLC/array-variable-utils'
+import { toast } from '../../../../_features/[app]/toast/use-toast'
 import { GraphicalEditorAutocomplete } from '../../autocomplete'
 import { getVariableRestrictionType } from '../../utils'
 import { getLadderPouVariablesRungNodeAndEdges } from '../utils'
@@ -68,11 +69,11 @@ const VariablesBlockAutoComplete = forwardRef<HTMLDivElement, VariablesBlockAuto
       ladderFlowActions: { updateNode },
     } = useOpenPLCStore()
 
-    const pou = pous.find((pou) => pou.data.name === editor.meta.name)
-    const variables = pou?.data.variables || []
+    const pou = pous.find((pou) => pou.name === editor.meta.name)
+    const variables = pou?.interface?.variables ?? []
     const variableRestrictions = blockTypeRestrictions(block, blockType)
 
-    const expandedVariables = expandArrayVariables(variables as PLCVariable[])
+    const expandedVariables = expandArrayVariables(variables)
 
     const filteredVariables =
       blockType !== 'block'
@@ -127,8 +128,11 @@ const VariablesBlockAutoComplete = forwardRef<HTMLDivElement, VariablesBlockAuto
       const relatedBlock = rung.nodes.find((node) => node.id === (variableNode as VariableNode).data.block.id)
       if (!relatedBlock) return
 
+      const existingConnected = Array.isArray((relatedBlock.data as BlockNodeData<BlockVariant>).connectedVariables)
+        ? (relatedBlock.data as BlockNodeData<BlockVariant>).connectedVariables
+        : []
       const connectedVariables: LadderBlockConnectedVariables = [
-        ...(relatedBlock.data as BlockNodeData<BlockVariant>).connectedVariables.filter(
+        ...existingConnected.filter(
           (v) =>
             v.type !== variableNode.data.variant || v.handleId !== (variableNode as VariableNode).data.block.handleId,
         ),
@@ -186,7 +190,6 @@ const VariablesBlockAutoComplete = forwardRef<HTMLDivElement, VariablesBlockAuto
         data: {
           id: uuidv4(),
           name: variableName,
-          // @ts-expect-error - type is dynamic
           type: {
             definition: variableTypeRestriction.definition as 'base-type' | 'derived' | 'array' | 'user-data-type',
             value: variableTypeRestriction.value,
@@ -199,7 +202,14 @@ const VariablesBlockAutoComplete = forwardRef<HTMLDivElement, VariablesBlockAuto
         scope: 'local',
         associatedPou: editor.meta.name,
       })
-      if (!res.ok) return
+      if (!res.ok) {
+        toast({
+          title: res.title ?? 'Error',
+          description: res.message ?? 'Failed to create variable',
+          variant: 'fail',
+        })
+        return
+      }
 
       const variable = res.data as PLCVariable | undefined
 
@@ -219,6 +229,12 @@ const VariablesBlockAutoComplete = forwardRef<HTMLDivElement, VariablesBlockAuto
 
     const submit = ({ variable }: { variable: { id: string; name: string } }) => {
       if (variable.id === 'add') {
+        // Check if the input is a literal value (e.g., 2.0, TRUE, 'hello')
+        // Literals should be submitted directly to the block, not created as variables
+        if (getLiteralType(valueToSearch)) {
+          submitVariableToBlock({ name: valueToSearch } as PLCVariable)
+          return
+        }
         submitAddVariable({ variableName: valueToSearch })
         return
       }
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/block.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/block.tsx
similarity index 83%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/block.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/block.tsx
index 0f9400239..9790f1139 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/block.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/block.tsx
@@ -1,25 +1,40 @@
-import { updateDiagramElementsPosition } from '../../../_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram'
-import { toast } from '../../../_features/[app]/toast/use-toast'
-import { useOpenPLCStore } from '../../../../store'
-import { checkVariableNameUnit } from '../../../../store/slices/project/validation/variables'
-import type { PLCVariable } from '../../../../../middleware/shared/ports'
-import { cn } from '../../../../utils/cn'
-import { FocusEvent, useEffect, useRef, useState } from 'react'
+import { FocusEvent, useEffect, useMemo, useRef, useState } from 'react'
 import { v4 as uuidv4 } from 'uuid'
 
-import { LibraryState } from '../../../../store/slices/library'
+import type { PLCVariable } from '../../../../../middleware/shared/ports'
 import { PLCPou } from '../../../../../middleware/shared/ports'
+import { RefreshIcon } from '../../../../assets/icons/interface/Refresh'
+import { useOpenPLCStore } from '../../../../store'
+import { LibraryState } from '../../../../store/slices/library'
+import { checkVariableName } from '../../../../store/slices/project/validation/variables'
+import { cn } from '../../../../utils/cn'
+import { toast } from '../../../_features/[app]/toast/use-toast'
+import { updateDiagramElementsPosition } from '../../../_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram'
 import { HighlightedTextArea } from '../../highlighted-textarea'
 import { InputWithRef } from '../../input'
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../../tooltip'
+import { BlockOutputDebugBadges } from '../block-output-debug-badges'
 import { BlockVariant as newBlockVariant } from '../types/block'
 import { getBlockDocumentation, getVariableRestrictionType } from '../utils'
 import { buildBlockNode } from './buildNodes'
 import { CustomHandle } from './handle'
 import { getLadderPouVariablesRungNodeAndEdges } from './utils'
-import { DEFAULT_BLOCK_CONNECTOR_Y, DEFAULT_BLOCK_CONNECTOR_Y_OFFSET, DEFAULT_BLOCK_HEIGHT, DEFAULT_BLOCK_TYPE, DEFAULT_BLOCK_WIDTH, } from './utils/constants'
-import type { BasicNodeData, BlockNodeData, BlockProps, BlockVariant, LadderBlockConnectedVariables, } from './utils/types'
-import { RefreshIcon } from '../../../../assets/icons/interface/Refresh'
+import {
+  DEFAULT_BLOCK_CONNECTOR_Y,
+  DEFAULT_BLOCK_CONNECTOR_Y_OFFSET,
+  DEFAULT_BLOCK_HEIGHT,
+  DEFAULT_BLOCK_TYPE,
+  DEFAULT_BLOCK_WIDTH,
+} from './utils/constants'
+import type {
+  BasicNodeData,
+  BlockNodeData,
+  BlockProps,
+  BlockVariant,
+  LadderBlockConnectedVariables,
+} from './utils/types'
+
+export type { BlockNode, BlockNodeData, BlockVariant } from './utils/types'
 
 export const BlockNodeElement = <T extends object>({
   nodeId,
@@ -88,7 +103,6 @@ export const BlockNodeElement = <T extends object>({
           break
       }
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   /**
@@ -99,24 +113,19 @@ export const BlockNodeElement = <T extends object>({
       setBlockNameValue(blockName)
       return
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [data])
 
   const resolveLibraryBlock = (blockNameValue: string, libraries: LibraryState['libraries'], pous: PLCPou[]) => {
     const userLibrary = libraries.user.find((lib) => lib.name.toLowerCase() === blockNameValue.toLowerCase())
-    const userPou = pous.find((pou) => pou.data.name.toLowerCase() === userLibrary?.name.toLowerCase())
+    const userPou = pous.find((pou) => pou.name.toLowerCase() === userLibrary?.name.toLowerCase())
 
     if (!userPou) {
-      return (
-        libraries.system
-          // @ts-expect-error - type is dynamic
-          .flatMap((block) => block.pous)
-          // @ts-expect-error - type is dynamic
-          .find((pou) => pou.name.toLowerCase() === blockNameValue.toLowerCase())
-      )
+      return libraries.system
+        .flatMap((block: { pous: Array<{ name: string }> }) => block.pous)
+        .find((pou: { name: string }) => pou.name.toLowerCase() === blockNameValue.toLowerCase())
     }
 
-    const variables = userPou.data.variables.map((variable) => ({
+    const variables = (userPou.interface?.variables ?? []).map((variable) => ({
       name: variable.name,
       class: variable.class,
       type: {
@@ -125,23 +134,24 @@ export const BlockNodeElement = <T extends object>({
       },
     }))
 
-    if (userPou.type === 'function') {
-      const variable = getVariableRestrictionType(userPou.data.returnType)
+    if (userPou.pouType === 'function') {
+      const returnType = userPou.interface?.returnType ?? ''
+      const variable = getVariableRestrictionType(returnType)
       variables.push({
         name: 'OUT',
         class: 'output',
         type: {
           definition: (variable.definition as 'array' | 'base-type' | 'user-data-type' | 'derived') ?? 'derived',
-          value: userPou.data.returnType.toUpperCase(),
+          value: returnType.toUpperCase(),
         },
       })
     }
 
     return {
-      name: userPou.data.name,
-      type: userPou.type,
+      name: userPou.name,
+      type: userPou.pouType,
       variables,
-      documentation: userPou.data.documentation,
+      documentation: userPou.documentation,
       extensible: false,
     }
   }
@@ -166,7 +176,7 @@ export const BlockNodeElement = <T extends object>({
     })
     if (!pou || !rung || !node) return
 
-    if (libraryBlock && pou.type === 'function' && (libraryBlock as BlockVariant).type !== 'function') {
+    if (libraryBlock && pou.pouType === 'function' && (libraryBlock as BlockVariant).type !== 'function') {
       setWrongName(true)
       toast({
         title: 'Can not add block',
@@ -386,6 +396,18 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     nodeId: id,
   })
 
+  const connectedOutputNames = useMemo(() => {
+    const names = new Set<string>()
+    if (Array.isArray(data.connectedVariables)) {
+      for (const cv of data.connectedVariables) {
+        if (cv.type === 'output' && cv.variable) {
+          names.add(cv.handleId)
+        }
+      }
+    }
+    return names
+  }, [data.connectedVariables])
+
   const inputVariableRef = useRef<
     HTMLTextAreaElement & {
       blur: ({ submit }: { submit?: boolean }) => void
@@ -409,10 +431,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       switch (blockType) {
         case 'function-block': {
           if (!data.variable || data.variable.name === '') {
-            const { name, number } = checkVariableNameUnit(
-              variables.all,
-              (data.variant as BlockVariant).name.toUpperCase(),
-            )
+            const { name, number } = checkVariableName(variables.all, (data.variant as BlockVariant).name.toUpperCase())
 
             handleSubmitBlockVariableOnTextareaBlur(`${name}${number}`, true)
             hasCreatedRef.current = true
@@ -425,7 +444,6 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
           break
       }
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [data])
 
   /**
@@ -437,39 +455,59 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       return
     }
 
-    if (!node || !rung) {
-      console.error('Node or rung not found for ID:', id)
+    const {
+      variables: freshVariables,
+      rung: freshRung,
+      node: freshNode,
+    } = getLadderPouVariablesRungNodeAndEdges(editor, pous, ladderFlows, {
+      nodeId: id,
+      variableName: data.variable.name,
+    })
+
+    if (!freshNode || !freshRung) {
       return
     }
 
-    const variable = variables.selected
+    const variable = freshVariables.selected
     if (!variable) {
       setWrongVariable(true)
       return
     }
 
-    if ((node.data as BasicNodeData).variable.id === variable.id) {
-      if ((node.data as BasicNodeData).variable.name !== variable.name) {
+    const nodeVariable = (freshNode.data as BasicNodeData).variable
+    const nodeVariableName = nodeVariable.name.toLowerCase()
+    const selectedVariableName = variable.name.toLowerCase()
+    const nodeBlockType = (freshNode.data as BlockNodeData<BlockVariant>).variant.name
+
+    if (nodeVariableName === selectedVariableName) {
+      const typeMatches =
+        variable.type.definition === 'derived' && variable.type.value.toLowerCase() === nodeBlockType.toLowerCase()
+
+      if (!typeMatches) {
+        setWrongVariable(true)
+        return
+      }
+
+      if (nodeVariable.name !== variable.name) {
         updateNode({
           editorName: editor.meta.name,
-          rungId: rung.id,
-          nodeId: node.id,
+          rungId: freshRung.id,
+          nodeId: freshNode.id,
           node: {
-            ...node,
+            ...freshNode,
             data: {
-              ...node.data,
+              ...freshNode.data,
               variable,
             },
           },
         })
-        setWrongVariable(false)
-        return
       }
+      setWrongVariable(false)
+      return
     }
 
-    setWrongVariable(false)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [pous])
+    setWrongVariable(true)
+  }, [pous, data.variable.name])
 
   /**
    * Handle with the variable input onBlur event
@@ -493,9 +531,9 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     const findMatchingVariable = () =>
       variables.all.find(
         (variable) =>
-          variable.name === variableNameToSubmit &&
+          variable.name.toLowerCase() === variableNameToSubmit.toLowerCase() &&
           variable.type.definition === 'derived' &&
-          variable.type.value === blockType,
+          variable.type.value.toLowerCase() === blockType.toLowerCase(),
       )
 
     const updateNodeVariable = (variable: Partial<PLCVariable> | { name: string }) =>
@@ -514,7 +552,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     const matchingVariable = findMatchingVariable()
 
     if (variableToLink) {
-      if (variableToLink.name === variableNameToSubmit) return
+      if (variableToLink.name.toLowerCase() === variableNameToSubmit.toLowerCase()) return
 
       if (matchingVariable && matchingVariable.id !== variableToLink.id) {
         variableToLink = matchingVariable
@@ -578,11 +616,11 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     const libMatch = userLibraries.find((lib) => lib.name === variant.name && lib.type === variant.type)
     if (!libMatch) return
 
-    const libPou = pous.find((pou) => pou.data.name === libMatch.name)
+    const libPou = pous.find((pou) => pou.name === libMatch.name)
     if (!libPou) return
 
     const blockVariant = node.data.variant as BlockVariant
-    const newNodeVariables = (libPou.data.variables || []).map((variable) => {
+    const newNodeVariables = (libPou.interface?.variables ?? []).map((variable) => {
       let newType
       switch (variable.type.definition) {
         case 'array':
@@ -619,14 +657,15 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       }
     })
 
-    if (libPou.type === 'function') {
-      const variable = getVariableRestrictionType(libPou.data.returnType)
+    if (libPou.pouType === 'function') {
+      const returnType = libPou.interface?.returnType ?? ''
+      const variable = getVariableRestrictionType(returnType)
       newNodeVariables.push({
         name: 'OUT',
         class: 'output',
         type: {
           definition: variable.definition ?? 'derived',
-          value: libPou.data.returnType.toUpperCase(),
+          value: returnType.toUpperCase(),
         },
         location: '',
         documentation: '',
@@ -640,7 +679,12 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       posY: node.position.y,
       handleX: (node.data as BasicNodeData).handles[0].glbPosition.x,
       handleY: (node.data as BasicNodeData).handles[0].glbPosition.y,
-      variant: { ...libPou.data, type: blockVariant.type, variables: [...newNodeVariables] },
+      variant: {
+        name: libPou.name,
+        documentation: libPou.documentation,
+        type: blockVariant.type,
+        variables: [...newNodeVariables],
+      },
       executionControl: (node.data as BlockNodeData<BlockVariant>).executionControl,
     })
 
@@ -728,7 +772,7 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
     >
       {data.hasDivergence && hoveringBlock && (
         <div
-          className='h-6 w-6 absolute right-[-12px] top-[-12px] pointer z-10 rounded-full bg-slate-600 flex justify-center items-center shadow-sm'
+          className='pointer absolute right-[-12px] top-[-12px] z-10 flex h-6 w-6 items-center justify-center rounded-full bg-slate-600 shadow-sm'
           onClick={handleUpdateDivergence}
         >
           <TooltipProvider>
@@ -815,6 +859,17 @@ export const Block = <T extends object>(block: BlockProps<T>) => {
       {data.handles.map((handle, index) => (
         <CustomHandle key={index} {...handle} />
       ))}
+      <BlockOutputDebugBadges
+        blockType={(data.variant as BlockVariant).type}
+        blockName={(data.variant as BlockVariant).name}
+        blockVariableName={data.variable?.name ?? ''}
+        numericId={data.numericId}
+        outputVariables={(data.variant as BlockVariant).variables}
+        connectorStartY={DEFAULT_BLOCK_CONNECTOR_Y}
+        connectorOffsetY={DEFAULT_BLOCK_CONNECTOR_Y_OFFSET}
+        blockWidth={width ?? DEFAULT_BLOCK_WIDTH}
+        connectedOutputNames={connectedOutputNames}
+      />
     </div>
   )
 }
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
index 43b300b71..ac79fc34d 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
@@ -1,5 +1,30 @@
 import { Position } from '@xyflow/react'
+
+import { generateNumericUUID } from '../../../../utils/generate-uuid'
 import { buildHandle } from './handle'
+import { getBlockSize, getBlockVariantAndExecutionControl } from './utils'
+import {
+  DEFAULT_BLOCK_TYPE,
+  DEFAULT_COIL_BLOCK_HEIGHT,
+  DEFAULT_COIL_BLOCK_WIDTH,
+  DEFAULT_COIL_CONNECTOR_Y,
+  DEFAULT_CONTACT_BLOCK_HEIGHT,
+  DEFAULT_CONTACT_BLOCK_WIDTH,
+  DEFAULT_CONTACT_CONNECTOR_Y,
+  DEFAULT_PARALLEL_CONNECTOR_Y,
+  DEFAULT_PARALLEL_HEIGHT,
+  DEFAULT_PARALLEL_WIDTH,
+  DEFAULT_PLACEHOLDER_CONNECTOR_Y,
+  DEFAULT_PLACEHOLDER_HEIGHT,
+  DEFAULT_PLACEHOLDER_WIDTH,
+  DEFAULT_POWER_RAIL_CONNECTOR_X,
+  DEFAULT_POWER_RAIL_CONNECTOR_Y,
+  DEFAULT_POWER_RAIL_HEIGHT,
+  DEFAULT_POWER_RAIL_WIDTH,
+  DEFAULT_VARIABLE_CONNECTOR_Y,
+  DEFAULT_VARIABLE_HEIGHT,
+  DEFAULT_VARIABLE_WIDTH,
+} from './utils/constants'
 import type {
   BlockBuilderProps,
   BlockVariant,
@@ -14,30 +39,6 @@ import type {
   VariableBuilderProps,
   VariableNode,
 } from './utils/types'
-import { generateNumericUUID } from '../../../../utils/generate-uuid'
-import {
-  DEFAULT_COIL_CONNECTOR_Y,
-  DEFAULT_COIL_BLOCK_WIDTH,
-  DEFAULT_COIL_BLOCK_HEIGHT,
-  DEFAULT_CONTACT_CONNECTOR_Y,
-  DEFAULT_CONTACT_BLOCK_WIDTH,
-  DEFAULT_CONTACT_BLOCK_HEIGHT,
-  DEFAULT_BLOCK_TYPE,
-  DEFAULT_PARALLEL_WIDTH,
-  DEFAULT_PARALLEL_HEIGHT,
-  DEFAULT_PARALLEL_CONNECTOR_Y,
-  DEFAULT_PLACEHOLDER_CONNECTOR_Y,
-  DEFAULT_PLACEHOLDER_WIDTH,
-  DEFAULT_PLACEHOLDER_HEIGHT,
-  DEFAULT_POWER_RAIL_CONNECTOR_X,
-  DEFAULT_POWER_RAIL_CONNECTOR_Y,
-  DEFAULT_POWER_RAIL_WIDTH,
-  DEFAULT_POWER_RAIL_HEIGHT,
-  DEFAULT_VARIABLE_WIDTH,
-  DEFAULT_VARIABLE_HEIGHT,
-  DEFAULT_VARIABLE_CONNECTOR_Y,
-} from './utils/constants'
-import { getBlockSize, getBlockVariantAndExecutionControl } from './utils'
 
 /**
  *
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/coil.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/coil.tsx
similarity index 98%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/coil.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/coil.tsx
index 85df70a4b..ac08764a7 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/coil.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/coil.tsx
@@ -1,16 +1,18 @@
-import { useOpenPLCStore } from '../../../../store'
-import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
-import { useDebugger } from '../../../../../middleware/shared/providers'
-import { cn } from '../../../../utils/cn'
-import { useEffect, useRef, useState } from 'react'
 import * as Popover from '@radix-ui/react-popover'
+import { useEffect, useRef, useState } from 'react'
 
+import { useDebugger } from '../../../../../middleware/shared/providers'
+import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
+import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
 import { HighlightedTextArea } from '../../highlighted-textarea'
+import { VariablesBlockAutoComplete } from './autocomplete'
 import { CustomHandle } from './handle'
 import { getLadderPouVariablesRungNodeAndEdges } from './utils'
-import type { BasicNodeData, CoilProps } from './utils/types'
-import { VariablesBlockAutoComplete } from './autocomplete'
 import { DEFAULT_COIL_BLOCK_HEIGHT, DEFAULT_COIL_BLOCK_WIDTH, DEFAULT_COIL_TYPES } from './utils/constants'
+import type { BasicNodeData, CoilProps } from './utils/types'
+
+export type { CoilNode } from './utils/types'
 
 export const Coil = (block: CoilProps) => {
   const { selected, data, id } = block
@@ -44,6 +46,7 @@ export const Coil = (block: CoilProps) => {
       focus: () => void
       isFocused: boolean
       selectedVariable: { positionInArray: number; variableName: string }
+      triggerSubmit: () => void
     }
   >(null)
 
@@ -75,7 +78,6 @@ export const Coil = (block: CoilProps) => {
     if (inputVariableRef.current && selected) {
       inputVariableRef.current.focus()
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   /**
@@ -127,7 +129,6 @@ export const Coil = (block: CoilProps) => {
     }
 
     setWrongVariable(false)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pous])
 
   const getDebuggerFillColor = (): string | undefined => {
@@ -347,8 +348,11 @@ export const Coil = (block: CoilProps) => {
             onChange={onChangeHandler}
             onKeyDown={(e) => {
               if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Tab') e.preventDefault()
-              if (e.key === 'Enter' && autocompleteRef.current?.selectedVariable.positionInArray !== -1) {
+              if (e.key === 'Enter' && openAutocomplete) {
+                e.preventDefault()
+                autocompleteRef.current?.triggerSubmit?.()
                 inputVariableRef.current?.blur({ submit: false })
+                return
               }
               setKeyPressedAtTextarea(e.key)
             }}
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/contact.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/contact.tsx
similarity index 97%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/contact.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/contact.tsx
index de028b809..24919d6a1 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/contact.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/contact.tsx
@@ -1,16 +1,18 @@
+import * as Popover from '@radix-ui/react-popover'
+import { useEffect, useRef, useState } from 'react'
+
 import { useDebugger } from '../../../../../middleware/shared/providers'
 import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
 import { useOpenPLCStore } from '../../../../store'
 import { cn } from '../../../../utils/cn'
-import { useEffect, useRef, useState } from 'react'
-import * as Popover from '@radix-ui/react-popover'
-
 import { HighlightedTextArea } from '../../highlighted-textarea'
+import { VariablesBlockAutoComplete } from './autocomplete'
 import { CustomHandle } from './handle'
 import { getLadderPouVariablesRungNodeAndEdges } from './utils'
+import { DEFAULT_CONTACT_BLOCK_HEIGHT, DEFAULT_CONTACT_BLOCK_WIDTH, DEFAULT_CONTACT_TYPES } from './utils/constants'
 import type { BasicNodeData, ContactProps } from './utils/types'
-import { VariablesBlockAutoComplete } from './autocomplete'
-import { DEFAULT_CONTACT_TYPES, DEFAULT_CONTACT_BLOCK_WIDTH, DEFAULT_CONTACT_BLOCK_HEIGHT } from './utils/constants'
+
+export type { ContactNode } from './utils/types'
 
 export const Contact = (block: ContactProps) => {
   const { selected, data, id } = block
@@ -43,6 +45,7 @@ export const Contact = (block: ContactProps) => {
       focus: () => void
       isFocused: boolean
       selectedVariable: { positionInArray: number; variableName: string }
+      triggerSubmit: () => void
     }
   >(null)
 
@@ -75,7 +78,6 @@ export const Contact = (block: ContactProps) => {
     if (inputVariableRef.current && selected) {
       inputVariableRef.current.focus()
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   /**
@@ -125,7 +127,6 @@ export const Contact = (block: ContactProps) => {
     }
 
     setWrongVariable(false)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pous])
 
   const getDebuggerStrokeColor = (): string | undefined => {
@@ -345,8 +346,11 @@ export const Contact = (block: ContactProps) => {
             onChange={onChangeHandler}
             onKeyDown={(e) => {
               if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Tab') e.preventDefault()
-              if (e.key === 'Enter' && autocompleteRef.current?.selectedVariable.positionInArray !== -1) {
+              if (e.key === 'Enter' && openAutocomplete) {
+                e.preventDefault()
+                autocompleteRef.current?.triggerSubmit?.()
                 inputVariableRef.current?.blur({ submit: false })
+                return
               }
               setKeyPressedAtTextarea(e.key)
             }}
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/handle.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/handle.tsx
similarity index 87%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/handle.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/handle.tsx
index 13718fcfc..e007d643f 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/handle.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/handle.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../../utils/cn'
 import { Handle, HandleProps } from '@xyflow/react'
 
+import { cn } from '../../../../utils/cn'
+
 export type CustomHandleProps = HandleProps & {
   glbPosition: {
     x: number
@@ -12,7 +13,17 @@ export type CustomHandleProps = HandleProps & {
   }
 }
 
-export const CustomHandle = ({ id, className, style, type, position, isConnectable, ...props }: CustomHandleProps) => {
+export const CustomHandle = ({
+  id,
+  className,
+  style,
+  type,
+  position,
+  isConnectable,
+  glbPosition: _glb,
+  relPosition: _rel,
+  ...props
+}: CustomHandleProps) => {
   return (
     <Handle
       id={id}
@@ -40,7 +51,6 @@ type BuildHandleProps = HandleProps & {
  * @param relY: number - The y coordinate of the handle based on the relative position (inside the node)
  * @returns CustomHandleProps
  */
-// eslint-disable-next-line react-refresh/only-export-components
 export const buildHandle = ({ glbX, glbY, relX, relY, ...rest }: BuildHandleProps) => {
   return {
     glbPosition: {
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/index.ts b/src/frontend/components/_atoms/graphical-editor/ladder/index.ts
new file mode 100644
index 000000000..729c7d2b0
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/index.ts
@@ -0,0 +1,25 @@
+import * as blockNode from './block'
+import * as coilNode from './coil'
+import * as contactNode from './contact'
+import * as mockNode from './mock-node'
+import * as parallelNode from './parallel'
+import * as placeholderNode from './placeholder'
+import * as powerRailNode from './power-rail'
+import * as variableNode from './variable'
+
+// Re-export from node-builders (safe for store-layer imports, no circular deps)
+export { checkIfElementIsNode, defaultCustomNodesStyles, nodesBuilder } from './node-builders'
+
+export const DEFAULT_NODES_GAP = 50
+
+export const customNodeTypes = {
+  block: blockNode.Block,
+  coil: coilNode.Coil,
+  contact: contactNode.Contact,
+  parallel: parallelNode.Parallel,
+  parallelPlaceholder: placeholderNode.Placeholder,
+  placeholder: placeholderNode.Placeholder,
+  powerRail: powerRailNode.PowerRail,
+  variable: variableNode.VariableElement,
+  mockNode: mockNode.MockNode,
+}
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/mock-node.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/mock-node.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/mock-node.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/mock-node.tsx
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/index.ts b/src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts
similarity index 81%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/index.ts
rename to src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts
index 951423aa3..06f5e0287 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/index.ts
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts
@@ -1,28 +1,17 @@
-import { Node } from '@xyflow/react'
+/**
+ * Node builder functions and styles extracted from index.ts to avoid circular
+ * dependencies when imported by the store layer.
+ *
+ * index.ts re-exports from here so that existing consumers are unaffected.
+ */
 
-import * as blockNode from './block'
-import * as coilNode from './coil'
-import * as contactNode from './contact'
-import * as mockNode from './mock-node'
-import * as parallelNode from './parallel'
-import * as placeholderNode from './placeholder'
-import * as powerRailNode from './power-rail'
-import * as variableNode from './variable'
-import * as constants from './utils/constants'
-import * as buildNodes from './buildNodes'
+import type { Node } from '@xyflow/react'
 
-export const DEFAULT_NODES_GAP = 50
+import * as buildNodes from './buildNodes'
+import * as constants from './utils/constants'
 
-export const customNodeTypes = {
-  block: blockNode.Block,
-  coil: coilNode.Coil,
-  contact: contactNode.Contact,
-  parallel: parallelNode.Parallel,
-  parallelPlaceholder: placeholderNode.Placeholder,
-  placeholder: placeholderNode.Placeholder,
-  powerRail: powerRailNode.PowerRail,
-  variable: variableNode.VariableElement,
-  mockNode: mockNode.MockNode,
+export const checkIfElementIsNode = (element: unknown): element is Node => {
+  return (element as Node)?.data !== undefined
 }
 
 type CustomLadderNodeTypes = {
@@ -38,6 +27,7 @@ type CustomLadderNodeTypes = {
     }
   }
 }
+
 export const defaultCustomNodesStyles: CustomLadderNodeTypes = {
   block: {
     width: constants.DEFAULT_BLOCK_WIDTH,
@@ -151,7 +141,3 @@ export const nodesBuilder = {
   variable: buildNodes.buildVariableNode,
   mockNode: buildNodes.buildMockNode,
 }
-
-export const checkIfElementIsNode = (element: unknown): element is Node => {
-  return (element as Node)?.data !== undefined
-}
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/parallel.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/parallel.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/parallel.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/parallel.tsx
index 91f288b22..ec52da42d 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/parallel.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/parallel.tsx
@@ -1,8 +1,7 @@
 import { cn } from '../../../../utils/cn'
-
 import { CustomHandle } from './handle'
-import type { ParallelProps } from './utils/types'
 import { DEFAULT_PARALLEL_HEIGHT, DEFAULT_PARALLEL_WIDTH } from './utils/constants'
+import type { ParallelProps } from './utils/types'
 
 export const Parallel = ({ selected, data }: ParallelProps) => {
   return (
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/placeholder.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/placeholder.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/placeholder.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/placeholder.tsx
index c3a7e9061..06c787b3d 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/placeholder.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/placeholder.tsx
@@ -1,9 +1,8 @@
 import { PlaceholderNodeFilled } from '../../../../assets/icons/flow/Placeholder'
 import { cn } from '../../../../utils/cn'
-
 import { CustomHandle } from './handle'
-import { PlaceholderProps } from './utils/types'
 import { DEFAULT_PLACEHOLDER_HEIGHT, DEFAULT_PLACEHOLDER_WIDTH } from './utils/constants'
+import { PlaceholderProps } from './utils/types'
 
 export const Placeholder = ({ selected, data }: PlaceholderProps) => {
   return (
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/power-rail.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/power-rail.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/power-rail.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/power-rail.tsx
index ceab32387..eaee9906d 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/power-rail.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/power-rail.tsx
@@ -1,6 +1,6 @@
 import { CustomHandle } from './handle'
-import { PowerRailProps } from './utils/types'
 import { DEFAULT_POWER_RAIL_HEIGHT, DEFAULT_POWER_RAIL_WIDTH } from './utils/constants'
+import { PowerRailProps } from './utils/types'
 
 export const PowerRail = ({ data }: PowerRailProps) => {
   return (
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
similarity index 97%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
index 9255334fd..7499db6ab 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
@@ -1,3 +1,5 @@
+import { ReactNode } from 'react'
+
 import {
   DefaultCoil,
   FallingEdgeCoil,
@@ -6,10 +8,14 @@ import {
   RisingEdgeCoil,
   SetCoil,
 } from '../../../../../assets/icons/flow/Coil'
-import { DefaultContact, FallingEdgeContact, NegatedContact, RisingEdgeContact } from '../../../../../assets/icons/flow/Contact'
+import {
+  DefaultContact,
+  FallingEdgeContact,
+  NegatedContact,
+  RisingEdgeContact,
+} from '../../../../../assets/icons/flow/Contact'
 import { cn } from '../../../../../utils/cn'
 import { CoilType, ContactType } from './types'
-import { ReactNode } from 'react'
 
 // block
 
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/utils/index.ts b/src/frontend/components/_atoms/graphical-editor/ladder/utils/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/utils/index.ts
rename to src/frontend/components/_atoms/graphical-editor/ladder/utils/index.ts
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts b/src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
similarity index 99%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
rename to src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
index 219ef6aba..2aeeb04e9 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
@@ -1,10 +1,9 @@
-import { PLCVariable } from '../../../../../../middleware/shared/ports'
+import type { Node, NodeProps } from '@xyflow/react'
+import { ReactNode } from 'react'
 
+import { PLCVariable } from '../../../../../../middleware/shared/ports'
 import { CustomHandleProps } from '../handle'
 
-import { ReactNode } from 'react'
-import type { Node, NodeProps } from '@xyflow/react'
-
 export type BuilderBasicProps = {
   id: string
   posX: number
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/utils.ts b/src/frontend/components/_atoms/graphical-editor/ladder/utils/utils.ts
similarity index 97%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/utils/utils.ts
rename to src/frontend/components/_atoms/graphical-editor/ladder/utils/utils.ts
index 49602109d..9b2e91566 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/utils.ts
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/utils/utils.ts
@@ -1,15 +1,15 @@
-import type { EditorModel } from '../../../../../store/slices/editor'
-import type { LadderFlowType } from '../../../../../store/slices/ladder'
-import { baseTypeSchema, genericTypeSchema } from '../../../../../../middleware/shared/ports'
-import type { PLCPou } from '../../../../../../middleware/shared/ports'
-import type { PLCVariable } from '../../../../../../middleware/shared/ports'
-import { resolveArrayVariableByName } from '../../../../../../backend/shared/array-variable-utils'
+import { Position } from '@xyflow/react'
 import { ZodLiteral } from 'zod'
 
-import type { BasicNodeData, BlockVariant } from './types'
-import { DEFAULT_BLOCK_CONNECTOR_Y, DEFAULT_BLOCK_CONNECTOR_Y_OFFSET, DEFAULT_BLOCK_WIDTH } from './constants'
-import { Position } from '@xyflow/react'
+import type { PLCPou } from '../../../../../../middleware/shared/ports'
+import type { PLCVariable } from '../../../../../../middleware/shared/ports'
+import { baseTypeSchema, genericTypeSchema } from '../../../../../../middleware/shared/ports'
+import type { EditorModel } from '../../../../../store/slices/editor'
+import type { LadderFlowType } from '../../../../../store/slices/ladder'
+import { resolveArrayVariableByName } from '../../../../../utils/PLC/array-variable-utils'
 import { buildHandle } from '../handle'
+import { DEFAULT_BLOCK_CONNECTOR_Y, DEFAULT_BLOCK_CONNECTOR_Y_OFFSET, DEFAULT_BLOCK_WIDTH } from './constants'
+import type { BasicNodeData, BlockVariant } from './types'
 
 export const getLadderPouVariablesRungNodeAndEdges = (
   editor: EditorModel,
@@ -26,7 +26,7 @@ export const getLadderPouVariablesRungNodeAndEdges = (
   }
   node: LadderFlowType['rungs'][0]['nodes'][0] | undefined
 } => {
-  const pou = pous.find((pou) => pou.data.name === editor.meta.name)
+  const pou = pous.find((pou) => pou.name === editor.meta.name)
 
   const rung = ladderFlows
     .find((flow) => flow.name === editor.meta.name)
@@ -34,7 +34,7 @@ export const getLadderPouVariablesRungNodeAndEdges = (
 
   const node = rung?.nodes.find((node) => node.id === data.nodeId)
 
-  const variables: PLCVariable[] = pou?.data.variables as PLCVariable[]
+  const variables: PLCVariable[] = pou?.interface?.variables ?? []
   let variable = variables.find((variable) => {
     if (!node) return undefined
     const nodeVariable = (node.data as BasicNodeData).variable
@@ -187,7 +187,7 @@ export const getVariableRestrictionType = (variableType: string) => {
     }
   }
 
-  const isABaseType = baseTypeSchema.safeParse(variableType)
+  const isABaseType = baseTypeSchema.safeParse(variableType.toLowerCase())
 
   return {
     // For base types, lowercase is fine (they're standardized and compared case-insensitively)
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/variable.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/variable.tsx
similarity index 92%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/variable.tsx
rename to src/frontend/components/_atoms/graphical-editor/ladder/variable.tsx
index a1111ad42..9eca153d2 100644
--- a/src2/frontend/components/_atoms/graphical-editor/ladder/variable.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/variable.tsx
@@ -1,10 +1,13 @@
-import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
 import * as Popover from '@radix-ui/react-popover'
+import { useEffect, useRef, useState } from 'react'
+
+import { PLCVariable } from '../../../../../middleware/shared/ports'
 import { useDebugger } from '../../../../../middleware/shared/providers'
+import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
 import { useOpenPLCStore } from '../../../../store'
 import { RungLadderState } from '../../../../store/slices/ladder'
-import { PLCVariable } from '../../../../../middleware/shared/ports'
 import { cn } from '../../../../utils/cn'
+import { getLiteralType } from '../../../../utils/keywords'
 import {
   floatToBuffer,
   getVariableTypeInfo,
@@ -14,16 +17,15 @@ import {
   parseStringValue,
   stringToBuffer,
 } from '../../../../utils/variable-types'
-import { useEffect, useRef, useState } from 'react'
-
-import { Label } from '../../label'
 import { Modal, ModalContent, ModalTitle } from '../../../_molecules/modal'
 import { HighlightedTextArea } from '../../highlighted-textarea'
+import { Label } from '../../label'
+import { DebugValueBadge } from '../debug-value-badge'
+import { VariablesBlockAutoComplete } from './autocomplete'
 import { CustomHandle } from './handle'
 import { getLadderPouVariablesRungNodeAndEdges, validateVariableType } from './utils'
-import { VariablesBlockAutoComplete } from './autocomplete'
-import { BlockNodeData, BlockVariant, LadderBlockConnectedVariables, VariableNode, VariableProps } from './utils/types'
 import { DEFAULT_VARIABLE_HEIGHT, DEFAULT_VARIABLE_WIDTH } from './utils/constants'
+import { BlockNodeData, BlockVariant, LadderBlockConnectedVariables, VariableNode, VariableProps } from './utils/types'
 
 const VariableElement = (block: VariableProps) => {
   const { id, data } = block
@@ -51,6 +53,7 @@ const VariableElement = (block: VariableProps) => {
       focus: () => void
       isFocused: boolean
       selectedVariable: { positionInArray: number; variableName: string }
+      triggerSubmit?: () => void
     }
   >(null)
 
@@ -72,8 +75,11 @@ const VariableElement = (block: VariableProps) => {
       return
     }
 
+    const existing = Array.isArray((relatedBlock.data as BlockNodeData<BlockVariant>).connectedVariables)
+      ? (relatedBlock.data as BlockNodeData<BlockVariant>).connectedVariables
+      : []
     const connectedVariables: LadderBlockConnectedVariables = [
-      ...(relatedBlock.data as BlockNodeData<BlockVariant>).connectedVariables.filter(
+      ...existing.filter(
         (v) => v.type !== variableNode.data.variant || v.handleId !== variableNode.data.block.handleId,
       ),
       {
@@ -102,15 +108,18 @@ const VariableElement = (block: VariableProps) => {
 
   /**
    * useEffect to sync variableValue with data.variable.name when it changes externally
-   * (e.g., from variable rename propagation or autocomplete selection)
-   * Only sync when autocomplete is closed to avoid overwriting user input while typing
+   * (e.g., from variable rename propagation or autocomplete selection).
+   * Only sync when autocomplete is closed to avoid overwriting user input while typing.
+   * Note: openAutocomplete is intentionally NOT in the dependency array to prevent a race
+   * condition where closing the autocomplete (before blur) would restore the old node value,
+   * overwriting the user's cleared input.
    */
   useEffect(() => {
     const name = data.variable?.name ?? ''
     if (!openAutocomplete && name !== '') {
       setVariableValue(name)
     }
-  }, [data.variable?.name, openAutocomplete])
+  }, [data.variable?.name])
 
   /**
    * Update inputError state when the table of variables is updated
@@ -134,13 +143,11 @@ const VariableElement = (block: VariableProps) => {
       setIsAVariable(false)
     } else {
       const nodeVariableName = (variableNode as VariableNode).data.variable.name
-      const nodeVarRef = (variableNode as VariableNode).data.variable
 
       const namesMatchCI = variable.name.toLowerCase() === nodeVariableName.toLowerCase()
       const caseDiffers = variable.name !== nodeVariableName
-      const refStale = nodeVarRef !== variable
 
-      if (!namesMatchCI || caseDiffers || refStale) {
+      if (!namesMatchCI || caseDiffers) {
         updateNode({
           editorName: editor.meta.name,
           rungId: rung.id,
@@ -177,7 +184,6 @@ const VariableElement = (block: VariableProps) => {
       setInputError(true)
       return
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pous, data.variable?.name])
 
   /**
@@ -194,14 +200,22 @@ const VariableElement = (block: VariableProps) => {
 
     // For variable nodes (block pins), allow all types including derived (user-defined types)
     // Don't use getVariableByName here as it filters out derived types
-    let variable: PLCVariable | { name: string } | undefined = (pou.data.variables as PLCVariable[]).find(
+    let variable: PLCVariable | { name: string } | undefined = (pou.interface?.variables ?? []).find(
       (v) => v.name.toLowerCase() === variableNameToSubmit.toLowerCase(),
     )
-    if (!variable) {
+    const literalTypes = getLiteralType(variableNameToSubmit)
+    if (variable) {
+      setIsAVariable(true)
+      setInputError(false)
+    } else if (literalTypes) {
       setIsAVariable(false)
+      const mismatchType = !literalTypes.includes(data.block.variableType.type.value)
+      setInputError(mismatchType)
       variable = { name: variableNameToSubmit }
     } else {
       setIsAVariable(true)
+      setInputError(true)
+      variable = { name: variableNameToSubmit }
     }
 
     updateNode({
@@ -218,7 +232,6 @@ const VariableElement = (block: VariableProps) => {
     })
 
     updateRelatedNode(rung, variableNode, variable as PLCVariable)
-    setInputError(false)
   }
 
   const onChangeHandler = () => {
@@ -231,7 +244,9 @@ const VariableElement = (block: VariableProps) => {
     if (!data.variable || !data.variable.name) return undefined
     const { pou } = getLadderPouVariablesRungNodeAndEdges(editor, pous, ladderFlows, { nodeId: id })
     if (!pou) return undefined
-    const variable = pou.data.variables.find((v) => v.name.toLowerCase() === data.variable.name.toLowerCase())
+    const variable = (pou.interface?.variables ?? []).find(
+      (v) => v.name.toLowerCase() === data.variable.name.toLowerCase(),
+    )
     return variable?.type.value
   }
 
@@ -443,8 +458,11 @@ const VariableElement = (block: VariableProps) => {
           onChange={onChangeHandler}
           onKeyDown={(e) => {
             if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Tab') e.preventDefault()
-            if (e.key === 'Enter' && (autocompleteRef.current?.selectedVariable.positionInArray ?? -1) !== -1) {
+            if (e.key === 'Enter' && openAutocomplete) {
+              e.preventDefault()
+              autocompleteRef.current?.triggerSubmit?.()
               inputVariableRef.current?.blur({ submit: false })
+              return
             }
             setKeyPressedAtTextarea(e.key)
           }}
@@ -466,6 +484,14 @@ const VariableElement = (block: VariableProps) => {
           </div>
         )}
 
+        {isDebuggerVisible && isAVariable && (
+          <DebugValueBadge
+            compositeKey={compositeKey}
+            variableType={variableType}
+            position={data.variant === 'output' ? 'left' : 'right'}
+          />
+        )}
+
         {isDebuggerVisible && contextMenuPosition && (
           <Popover.Root open={isContextMenuOpen} onOpenChange={setIsContextMenuOpen}>
             <Popover.Portal>
diff --git a/src/frontend/components/_atoms/graphical-editor/types/block.ts b/src/frontend/components/_atoms/graphical-editor/types/block.ts
new file mode 100644
index 000000000..e28fb0d26
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/types/block.ts
@@ -0,0 +1,2 @@
+export type { BlockVariant } from '../../../../../middleware/shared/ports/block-types'
+export { blockVariantSchema, blockVariantVariableSchema } from '../../../../../middleware/shared/ports/block-types'
diff --git a/src2/frontend/components/_atoms/graphical-editor/utils/index.ts b/src/frontend/components/_atoms/graphical-editor/utils/index.ts
similarity index 92%
rename from src2/frontend/components/_atoms/graphical-editor/utils/index.ts
rename to src/frontend/components/_atoms/graphical-editor/utils/index.ts
index 0938ce831..c81b3b19a 100644
--- a/src2/frontend/components/_atoms/graphical-editor/utils/index.ts
+++ b/src/frontend/components/_atoms/graphical-editor/utils/index.ts
@@ -1,10 +1,9 @@
-import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
-import { resolveArrayVariableByName } from '../../../../../backend/shared/array-variable-utils'
+import { resolveArrayVariableByName } from '../../../../utils/PLC/array-variable-utils'
 import {
-  validateVariableType as _validateVariableType,
   getVariableRestrictionType,
-} from '../../../../../backend/shared/validate-variable-type'
-
+  validateVariableType as _validateVariableType,
+} from '../../../../utils/PLC/validate-variable-type'
+import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
 import { BlockVariant } from '../ladder/utils/types'
 import { BlockVariant as newBlockVariant } from '../types/block'
 
diff --git a/src/renderer/components/_atoms/highlighted-text/index.tsx b/src/frontend/components/_atoms/highlighted-text/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/highlighted-text/index.tsx
rename to src/frontend/components/_atoms/highlighted-text/index.tsx
diff --git a/src2/frontend/components/_atoms/highlighted-textarea/index.tsx b/src/frontend/components/_atoms/highlighted-textarea/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/highlighted-textarea/index.tsx
rename to src/frontend/components/_atoms/highlighted-textarea/index.tsx
index cccf9aeae..43ee3ffac 100644
--- a/src2/frontend/components/_atoms/highlighted-textarea/index.tsx
+++ b/src/frontend/components/_atoms/highlighted-textarea/index.tsx
@@ -1,8 +1,9 @@
+import type { ChangeEvent, ComponentPropsWithRef, UIEvent } from 'react'
+import { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react'
+
 import { useOpenPLCStore } from '../../../store'
 import { extractSearchQuery } from '../../../store/slices/search/utils'
 import { cn } from '../../../utils/cn'
-import type { ChangeEvent, ComponentPropsWithRef, UIEvent } from 'react'
-import { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react'
 
 type HighlightedTextAreaProps = ComponentPropsWithRef<'textarea'> & {
   textAreaValue: string
diff --git a/src2/frontend/components/_atoms/input/index.tsx b/src/frontend/components/_atoms/input/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/input/index.tsx
rename to src/frontend/components/_atoms/input/index.tsx
diff --git a/src2/frontend/components/_atoms/label/index.tsx b/src/frontend/components/_atoms/label/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/label/index.tsx
rename to src/frontend/components/_atoms/label/index.tsx
index bb4572f6b..19dafbe74 100644
--- a/src2/frontend/components/_atoms/label/index.tsx
+++ b/src/frontend/components/_atoms/label/index.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type LabelProps = ComponentPropsWithoutRef<'label'>
 
 const Label = (props: LabelProps) => {
diff --git a/src2/frontend/components/_atoms/react-flow/index.tsx b/src/frontend/components/_atoms/react-flow/index.tsx
similarity index 97%
rename from src2/frontend/components/_atoms/react-flow/index.tsx
rename to src/frontend/components/_atoms/react-flow/index.tsx
index 3c13a89c6..ccb9f75c3 100644
--- a/src2/frontend/components/_atoms/react-flow/index.tsx
+++ b/src/frontend/components/_atoms/react-flow/index.tsx
@@ -1,8 +1,11 @@
-import { cn } from '../../../utils/cn'
+import './style.css'
+
 import type { BackgroundProps, ControlProps, ReactFlowProps } from '@xyflow/react'
 import { Background, Controls, ReactFlow } from '@xyflow/react'
 import { PropsWithChildren } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type ReactFlowPanelProps = PropsWithChildren & {
   background?: boolean
   controls?: boolean
diff --git a/src2/frontend/components/_atoms/react-flow/style.css b/src/frontend/components/_atoms/react-flow/style.css
similarity index 65%
rename from src2/frontend/components/_atoms/react-flow/style.css
rename to src/frontend/components/_atoms/react-flow/style.css
index 26dd5ed79..c32e17471 100644
--- a/src2/frontend/components/_atoms/react-flow/style.css
+++ b/src/frontend/components/_atoms/react-flow/style.css
@@ -14,6 +14,16 @@ html:not(.dark) .react-flow {
   border: none;
 }
 
+/* Dark theme fallback for platforms using prefers-color-scheme (e.g. Electron) */
+@media (prefers-color-scheme: dark) {
+  html:not(.light) .react-flow {
+    --xy-controls-button-background-color-default: #2e3038;
+    --xy-controls-button-background-color-hover-default: #5e6275;
+    --xy-controls-button-border-color-default: #2e3038;
+    border: none;
+  }
+}
+
 .react-flow__controls {
   gap: 0.2rem;
   box-shadow: none;
diff --git a/src2/frontend/components/_atoms/resolution-warning-message/index.tsx b/src/frontend/components/_atoms/resolution-warning-message/index.tsx
similarity index 68%
rename from src2/frontend/components/_atoms/resolution-warning-message/index.tsx
rename to src/frontend/components/_atoms/resolution-warning-message/index.tsx
index 62da7e10b..883a9ab74 100644
--- a/src2/frontend/components/_atoms/resolution-warning-message/index.tsx
+++ b/src/frontend/components/_atoms/resolution-warning-message/index.tsx
@@ -1,6 +1,7 @@
-import { LogoIcon } from '../../../assets/icons/interface/Logo'
 import { useEffect, useState } from 'react'
 
+import { LogoIcon } from '../../../assets/icons/interface/Logo'
+
 const ResolutionWarning = () => {
   const [isPortrait, setIsPortrait] = useState(window.innerHeight > window.innerWidth)
 
@@ -14,16 +15,16 @@ const ResolutionWarning = () => {
   }, [])
 
   return (
-    <div className='flex flex-col h-screen w-screen items-center justify-center bg-brand-dark dark:bg-neutral-950 gap-6'>
-      <div className='w-[40.24%] h-1/5 '>
+    <div className='flex h-screen w-screen flex-col items-center justify-center gap-6 bg-brand-dark dark:bg-neutral-950'>
+      <div className='h-1/5 w-[40.24%] '>
         <LogoIcon size='lg' />
       </div>
       {isPortrait ? (
-        <p className='w-3/5 h-24 top-2/3 left-1/5 font-normal text-xl leading-[24.38px] text-center text-white'>
+        <p className='left-1/5 top-2/3 h-24 w-3/5 text-center text-xl font-normal leading-[24.38px] text-white'>
           Please rotate your device.
         </p>
       ) : (
-        <p className='w-3/5 h-24 top-2/3 left-1/5 font-normal text-xl leading-[24.38px] text-center text-white'>
+        <p className='left-1/5 top-2/3 h-24 w-3/5 text-center text-xl font-normal leading-[24.38px] text-white'>
           This application isn't supported on mobile devices. You can try the OpenPLC Web Editor on a desktop, laptop,
           or tablet.
         </p>
diff --git a/src2/frontend/components/_atoms/select/index.tsx b/src/frontend/components/_atoms/select/index.tsx
similarity index 96%
rename from src2/frontend/components/_atoms/select/index.tsx
rename to src/frontend/components/_atoms/select/index.tsx
index a4fdbd3a3..06da952be 100644
--- a/src2/frontend/components/_atoms/select/index.tsx
+++ b/src/frontend/components/_atoms/select/index.tsx
@@ -1,7 +1,8 @@
 import * as PrimitiveSelect from '@radix-ui/react-select'
+import { ComponentPropsWithoutRef, ElementRef, forwardRef, ReactElement } from 'react'
+
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { cn } from '../../../utils/cn'
-import { ComponentPropsWithoutRef, ElementRef, forwardRef, ReactElement } from 'react'
 
 const Select = PrimitiveSelect.Root
 
@@ -72,9 +73,7 @@ const SelectItem = forwardRef<ElementRef<typeof PrimitiveSelect.Item>, ISelectIt
     return (
       <PrimitiveSelect.Item {...res} ref={forwardedRef}>
         <PrimitiveSelect.ItemText>{children}</PrimitiveSelect.ItemText>
-        <PrimitiveSelect.ItemIndicator>
-          {indicator}
-        </PrimitiveSelect.ItemIndicator>
+        <PrimitiveSelect.ItemIndicator>{indicator}</PrimitiveSelect.ItemIndicator>
       </PrimitiveSelect.Item>
     )
   },
diff --git a/src/renderer/components/_atoms/tab-list/index.tsx b/src/frontend/components/_atoms/tab-list/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/tab-list/index.tsx
rename to src/frontend/components/_atoms/tab-list/index.tsx
diff --git a/src2/frontend/components/_atoms/tab/index.tsx b/src/frontend/components/_atoms/tab/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/tab/index.tsx
rename to src/frontend/components/_atoms/tab/index.tsx
index e6d707fd1..fdd4bbe3f 100644
--- a/src2/frontend/components/_atoms/tab/index.tsx
+++ b/src/frontend/components/_atoms/tab/index.tsx
@@ -1,8 +1,10 @@
-import { ArrayIcon } from '../../../assets/icons/project/Array'
+import { ComponentPropsWithoutRef, useCallback } from 'react'
+
 import { CloseIcon } from '../../../assets/icons/interface/Close'
 import { ConfigIcon } from '../../../assets/icons/interface/Config'
-import { CppIcon } from '../../../assets/icons/project/Cpp'
 import { DeviceTransferIcon } from '../../../assets/icons/interface/DeviceTransfer'
+import { ArrayIcon } from '../../../assets/icons/project/Array'
+import { CppIcon } from '../../../assets/icons/project/Cpp'
 import { EnumIcon } from '../../../assets/icons/project/Enum'
 import { FBDIcon } from '../../../assets/icons/project/FBD'
 import { ILIcon } from '../../../assets/icons/project/IL'
@@ -15,11 +17,10 @@ import { ServerIcon } from '../../../assets/icons/project/Server'
 import { SFCIcon } from '../../../assets/icons/project/SFC'
 import { STIcon } from '../../../assets/icons/project/ST'
 import { StructureIcon } from '../../../assets/icons/project/Structure'
-import type { TabsProps } from '../../../store/slices/tabs'
 import { useOpenPLCStore } from '../../../store'
+import type { TabsProps } from '../../../store/slices/tabs'
 import { cn } from '../../../utils/cn'
 import { isUnsaved, unsavedLabel } from '../../../utils/unsaved-label'
-import { ComponentPropsWithoutRef, useCallback } from 'react'
 
 type ITabProps = ComponentPropsWithoutRef<'div'> & {
   fileName: string
diff --git a/src2/frontend/components/_atoms/table-actions/index.tsx b/src/frontend/components/_atoms/table-actions/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/table-actions/index.tsx
rename to src/frontend/components/_atoms/table-actions/index.tsx
index db05e4551..601158f2c 100644
--- a/src2/frontend/components/_atoms/table-actions/index.tsx
+++ b/src/frontend/components/_atoms/table-actions/index.tsx
@@ -1,6 +1,6 @@
-import { cn } from '../../../utils/cn'
 import React, { ButtonHTMLAttributes, ReactNode } from 'react'
 
+import { cn } from '../../../utils/cn'
 import { TableActionButton } from '../buttons/tables-actions'
 
 type TableAction = {
diff --git a/src2/frontend/components/_atoms/table/index.tsx b/src/frontend/components/_atoms/table/index.tsx
similarity index 98%
rename from src2/frontend/components/_atoms/table/index.tsx
rename to src/frontend/components/_atoms/table/index.tsx
index 309ddf244..c3a8ca30e 100644
--- a/src2/frontend/components/_atoms/table/index.tsx
+++ b/src/frontend/components/_atoms/table/index.tsx
@@ -1,9 +1,10 @@
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithRef, forwardRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const Table = forwardRef<HTMLTableElement, ComponentPropsWithRef<'table'> & { context?: string }>(
   ({ className, context, ...res }, ref) => (
-    <div aria-label='Table container' className={cn('h-fit select-none w-fit', className)}>
+    <div aria-label='Table container' className={cn('h-fit w-fit select-none', className)}>
       <table
         aria-label={`${context} table`}
         ref={ref}
diff --git a/src2/frontend/components/_atoms/tooltip/index.tsx b/src/frontend/components/_atoms/tooltip/index.tsx
similarity index 99%
rename from src2/frontend/components/_atoms/tooltip/index.tsx
rename to src/frontend/components/_atoms/tooltip/index.tsx
index 564f60c00..256979c64 100644
--- a/src2/frontend/components/_atoms/tooltip/index.tsx
+++ b/src/frontend/components/_atoms/tooltip/index.tsx
@@ -1,7 +1,8 @@
 import * as PrimitiveTooltip from '@radix-ui/react-tooltip'
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef, ElementRef, forwardRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const TooltipProvider = PrimitiveTooltip.Provider
 const Tooltip = PrimitiveTooltip.Root
 
diff --git a/src2/frontend/components/_atoms/type-dropdown-selector/index.tsx b/src/frontend/components/_atoms/type-dropdown-selector/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/type-dropdown-selector/index.tsx
rename to src/frontend/components/_atoms/type-dropdown-selector/index.tsx
index 03e9b9ed7..b3e8c93b8 100644
--- a/src2/frontend/components/_atoms/type-dropdown-selector/index.tsx
+++ b/src/frontend/components/_atoms/type-dropdown-selector/index.tsx
@@ -1,8 +1,8 @@
 import * as PrimitiveDropdown from '@radix-ui/react-dropdown-menu'
-import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import _ from 'lodash'
 import { useState } from 'react'
 
+import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { InputWithRef } from '../input'
 
 type TypeDropdownSelectorProps = {
diff --git a/src/renderer/components/_atoms/workspace-activity-bar/divider.tsx b/src/frontend/components/_atoms/workspace-activity-bar/divider.tsx
similarity index 100%
rename from src/renderer/components/_atoms/workspace-activity-bar/divider.tsx
rename to src/frontend/components/_atoms/workspace-activity-bar/divider.tsx
diff --git a/src2/frontend/components/_features/[app]/loading-overlay/index.tsx b/src/frontend/components/_features/[app]/loading-overlay/index.tsx
similarity index 85%
rename from src2/frontend/components/_features/[app]/loading-overlay/index.tsx
rename to src/frontend/components/_features/[app]/loading-overlay/index.tsx
index 625eabc18..9b906e370 100644
--- a/src2/frontend/components/_features/[app]/loading-overlay/index.tsx
+++ b/src/frontend/components/_features/[app]/loading-overlay/index.tsx
@@ -1,7 +1,9 @@
 import { useOpenPLCStore } from '../../../../store'
 
 export const LoadingOverlay = () => {
-  const { isProjectLoading, projectLoadingMessage } = useOpenPLCStore()
+  const {
+    workspace: { isProjectLoading, projectLoadingMessage },
+  } = useOpenPLCStore()
 
   if (!isProjectLoading) {
     return null
diff --git a/src2/frontend/components/_features/[app]/toast/index.tsx b/src/frontend/components/_features/[app]/toast/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[app]/toast/index.tsx
rename to src/frontend/components/_features/[app]/toast/index.tsx
index f7c654b03..ff3395197 100644
--- a/src2/frontend/components/_features/[app]/toast/index.tsx
+++ b/src/frontend/components/_features/[app]/toast/index.tsx
@@ -1,9 +1,10 @@
 import * as PrimitiveToast from '@radix-ui/react-toast'
-import { CloseIcon } from '../../../../assets/icons/interface/Close'
-import { cn } from '../../../../utils/cn'
 import { cva, type VariantProps } from 'cva'
 import { ComponentPropsWithoutRef, ElementRef, forwardRef, ReactElement } from 'react'
 
+import { CloseIcon } from '../../../../assets/icons/interface/Close'
+import { cn } from '../../../../utils/cn'
+
 const ToastProvider = PrimitiveToast.ToastProvider
 
 const ToastViewport = forwardRef<
diff --git a/src/renderer/components/_features/[app]/toast/toaster.tsx b/src/frontend/components/_features/[app]/toast/toaster.tsx
similarity index 100%
rename from src/renderer/components/_features/[app]/toast/toaster.tsx
rename to src/frontend/components/_features/[app]/toast/toaster.tsx
diff --git a/src/frontend/components/_features/[app]/toast/use-toast.tsx b/src/frontend/components/_features/[app]/toast/use-toast.tsx
new file mode 100644
index 000000000..fccd8deab
--- /dev/null
+++ b/src/frontend/components/_features/[app]/toast/use-toast.tsx
@@ -0,0 +1,39 @@
+/*-----------------------------------------------------------------------------
+ * This implementation is provided by the Shadcn/UI collection, which is inspired
+ * by the react-hot-toast library
+ * Check the following link for more instructions:
+ * https://ui.shadcn.com/docs/components/toast#installation
+ *------------------------------------------------------------------------------*/
+import { useEffect, useState } from 'react'
+
+import type { State, ToasterToast } from '../../../../utils/toast'
+import { dispatch, getMemoryState, listeners, toast } from '../../../../utils/toast'
+
+type useToastReturnType = {
+  toast: typeof toast
+  dismiss: (toastId?: string) => void
+  toasts: ToasterToast[]
+}
+
+function useToast(): useToastReturnType {
+  const [state, setState] = useState<State>(getMemoryState)
+
+  useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  }
+}
+
+export { toast, useToast }
+export type { ToasterToast }
diff --git a/src2/frontend/components/_features/[start]/menu/index.tsx b/src/frontend/components/_features/[start]/menu/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[start]/menu/index.tsx
rename to src/frontend/components/_features/[start]/menu/index.tsx
index b621e7066..a12c920da 100644
--- a/src2/frontend/components/_features/[start]/menu/index.tsx
+++ b/src/frontend/components/_features/[start]/menu/index.tsx
@@ -1,7 +1,8 @@
-import { Button } from '../../../_atoms/buttons/default'
-import { cn } from '../../../../utils/cn'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { cn } from '../../../../utils/cn'
+import { Button } from '../../../_atoms/buttons/default'
+
 type IMenuRootProps = ComponentPropsWithoutRef<'div'>
 const MenuRoot = (props: IMenuRootProps) => {
   const { children, ...res } = props
diff --git a/src2/frontend/components/_features/[start]/new-project/interval-model.tsx b/src/frontend/components/_features/[start]/new-project/interval-model.tsx
similarity index 100%
rename from src2/frontend/components/_features/[start]/new-project/interval-model.tsx
rename to src/frontend/components/_features/[start]/new-project/interval-model.tsx
index df37404b1..f48f5c5d4 100644
--- a/src2/frontend/components/_features/[start]/new-project/interval-model.tsx
+++ b/src/frontend/components/_features/[start]/new-project/interval-model.tsx
@@ -1,7 +1,7 @@
-import { Modal, ModalContent, ModalTitle, ModalTrigger } from '../../../_molecules/modal'
-import { cn } from '../../../../utils/cn'
 import { useEffect, useMemo, useState } from 'react'
 
+import { cn } from '../../../../utils/cn'
+import { Modal, ModalContent, ModalTitle, ModalTrigger } from '../../../_molecules/modal'
 import ArrowButtonGroup from '../../[workspace]/editor/graphical/elements/arrow-button-group'
 
 type IntervalModalProps = {
diff --git a/src2/frontend/components/_features/[start]/new-project/project-modal.tsx b/src/frontend/components/_features/[start]/new-project/project-modal.tsx
similarity index 97%
rename from src2/frontend/components/_features/[start]/new-project/project-modal.tsx
rename to src/frontend/components/_features/[start]/new-project/project-modal.tsx
index 890b6470a..809ba4aeb 100644
--- a/src2/frontend/components/_features/[start]/new-project/project-modal.tsx
+++ b/src/frontend/components/_features/[start]/new-project/project-modal.tsx
@@ -1,7 +1,7 @@
-import { Modal, ModalContent, ModalTitle } from '../../../_molecules/modal'
-import { useOpenPLCStore } from '../../../../store'
 import { useEffect, useState } from 'react'
 
+import { useOpenPLCStore } from '../../../../store'
+import { Modal, ModalContent, ModalTitle } from '../../../_molecules/modal'
 import { Step1 } from './steps/first-step'
 import { Step2 } from './steps/second-step'
 import { Step3 } from './steps/third-step'
@@ -42,7 +42,6 @@ const ProjectModal = ({ isOpen }: { isOpen: boolean }) => {
     resetFormData()
     setEditingState('unsaved')
     clearTabs()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   const renderStep = () => {
diff --git a/src2/frontend/components/_features/[start]/new-project/steps/first-step.tsx b/src/frontend/components/_features/[start]/new-project/steps/first-step.tsx
similarity index 100%
rename from src2/frontend/components/_features/[start]/new-project/steps/first-step.tsx
rename to src/frontend/components/_features/[start]/new-project/steps/first-step.tsx
index 847006529..694a1663f 100644
--- a/src2/frontend/components/_features/[start]/new-project/steps/first-step.tsx
+++ b/src/frontend/components/_features/[start]/new-project/steps/first-step.tsx
@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-misused-promises */
 
-import { BookIcon } from '../../../../../assets/icons/interface/Book'
-import { FolderIcon } from '../../../../../assets/icons/interface/Folder'
-import { cn } from '../../../../../utils/cn'
 import { useEffect, useState } from 'react'
 import { SubmitHandler, useForm } from 'react-hook-form'
 
+import { BookIcon } from '../../../../../assets/icons/interface/Book'
+import { FolderIcon } from '../../../../../assets/icons/interface/Folder'
+import { cn } from '../../../../../utils/cn'
 import { NewProjectStore } from '../store'
 
 const Step1 = ({ onNext, onClose }: { onNext: () => void; onClose: () => void }) => {
diff --git a/src2/frontend/components/_features/[start]/new-project/steps/second-step.tsx b/src/frontend/components/_features/[start]/new-project/steps/second-step.tsx
similarity index 100%
rename from src2/frontend/components/_features/[start]/new-project/steps/second-step.tsx
rename to src/frontend/components/_features/[start]/new-project/steps/second-step.tsx
index 1088c90d2..27f18cf9d 100644
--- a/src2/frontend/components/_features/[start]/new-project/steps/second-step.tsx
+++ b/src/frontend/components/_features/[start]/new-project/steps/second-step.tsx
@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-misused-promises */
 
-import { PathIcon } from '../../../../../assets/icons/interface/Path'
-import { cn } from '../../../../../utils/cn'
-import { useCapabilities, useProject } from '../../../../../../middleware/shared/providers/platform-context'
 import { useEffect, useState } from 'react'
 import { SubmitHandler, useForm } from 'react-hook-form'
 
+import { useCapabilities, useProject } from '../../../../../../middleware/shared/providers/platform-context'
+import { PathIcon } from '../../../../../assets/icons/interface/Path'
+import { cn } from '../../../../../utils/cn'
 import { NewProjectStore } from '../store'
 
 const Step2 = ({ onNext, onPrev }: { onNext: () => void; onPrev: () => void }) => {
diff --git a/src2/frontend/components/_features/[start]/new-project/steps/third-step.tsx b/src/frontend/components/_features/[start]/new-project/steps/third-step.tsx
similarity index 86%
rename from src2/frontend/components/_features/[start]/new-project/steps/third-step.tsx
rename to src/frontend/components/_features/[start]/new-project/steps/third-step.tsx
index b79417703..e9e5956fd 100644
--- a/src2/frontend/components/_features/[start]/new-project/steps/third-step.tsx
+++ b/src/frontend/components/_features/[start]/new-project/steps/third-step.tsx
@@ -1,24 +1,17 @@
 /* eslint-disable @typescript-eslint/no-misused-promises */
-import { PouLanguageSources } from '../../../../../data/sources/POU'
+import { useState } from 'react'
+import { Controller, SubmitHandler, useForm } from 'react-hook-form'
+
+import { useProject } from '../../../../../../middleware/shared/providers'
 import { TimerIcon } from '../../../../../assets/icons/interface/Timer'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../_atoms/select'
+import { PouLanguageSources } from '../../../../../data/sources/POU'
 import { useOpenPLCStore } from '../../../../../store'
 import { cn } from '../../../../../utils/cn'
 import { ConvertToLangShortenedFormat } from '../../../../../utils/formatters/POU'
-import { useState } from 'react'
-import { Controller, SubmitHandler, useForm } from 'react-hook-form'
-
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../_atoms/select'
 import { useToast } from '../../../[app]/toast/use-toast'
 import { IntervalModal } from '../interval-model'
 import { NewProjectStore } from '../store'
-
-type CreateProjectFileProps = {
-  language: 'il' | 'st' | 'ld' | 'sfc' | 'fbd'
-  time: string
-  type: 'plc-project' | 'plc-library'
-  name: string
-  path: string
-}
 {
   /** TODO: Need to be implemented - Sequential Functional Chart and Functional Block Diagram */
 }
@@ -47,8 +40,11 @@ const Step3 = ({ onPrev, onFinish, onClose }: { onPrev: () => void; onFinish: ()
   const projectData = NewProjectStore((state) => state.formData)
   const [isModalOpen, setModalOpen] = useState(false)
   const [intervalValue, setIntervalValue] = useState('T#20ms')
+  const projectPort = useProject()
   const {
-    sharedWorkspaceActions: { createProject },
+    projectActions: { setProject },
+    deviceActions: { setDeviceDefinitions },
+    workspaceActions: { setEditingState },
   } = useOpenPLCStore()
 
   const handleFormSubmit: SubmitHandler<FormData> = async (data) => {
@@ -60,8 +56,35 @@ const Step3 = ({ onPrev, onFinish, onClose }: { onPrev: () => void; onFinish: ()
 
     handleUpdateForm(allData)
     try {
-      await createProject(allData as CreateProjectFileProps)
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const result = await projectPort.createProject({
+        name: allData.name,
+        type: allData.type as 'plc-project' | 'plc-library',
+        path: allData.path,
+        language: allData.language,
+        time: allData.time,
+      })
+
+      if (!result.success || !result.data) {
+        toast({
+          title: 'Cannot create a project!',
+          description: result.error?.description ?? 'Failed to create the project.',
+          variant: 'fail',
+        })
+        return
+      }
+
+      // Hydrate store with returned project data
+      setProject({
+        meta: result.data.meta,
+        data: result.data.projectData,
+      })
+      if (result.data.deviceConfiguration || result.data.devicePinMapping) {
+        setDeviceDefinitions({
+          configuration: result.data.deviceConfiguration,
+          pinMapping: result.data.devicePinMapping,
+        })
+      }
+      setEditingState('saved')
     } catch (_error) {
       toast({
         title: 'Cannot create a project!',
diff --git a/src/renderer/components/_features/[start]/new-project/store/index.ts b/src/frontend/components/_features/[start]/new-project/store/index.ts
similarity index 100%
rename from src/renderer/components/_features/[start]/new-project/store/index.ts
rename to src/frontend/components/_features/[start]/new-project/store/index.ts
diff --git a/src2/frontend/components/_features/[workspace]/create-element/element-card/data-type-element.tsx b/src/frontend/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
similarity index 93%
rename from src2/frontend/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
rename to src/frontend/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
index 2b8ff164e..711da0623 100644
--- a/src2/frontend/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
+++ b/src/frontend/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
@@ -1,6 +1,7 @@
-import { ComponentPropsWithoutRef } from 'react'
-import { EnumIcon, StructureIcon, ArrayIcon } from '../../../../../assets/icons/project'
 import { startCase } from 'lodash'
+import { ComponentPropsWithoutRef } from 'react'
+
+import { ArrayIcon, EnumIcon, StructureIcon } from '../../../../../assets/icons/project'
 
 type CreateDataTypeProps = ComponentPropsWithoutRef<'div'> & {
   derivation: 'enumerated' | 'structure' | 'array'
diff --git a/src2/frontend/components/_features/[workspace]/create-element/element-card/index.tsx b/src/frontend/components/_features/[workspace]/create-element/element-card/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/create-element/element-card/index.tsx
rename to src/frontend/components/_features/[workspace]/create-element/element-card/index.tsx
index b3027dc13..8cd9b5ece 100644
--- a/src2/frontend/components/_features/[workspace]/create-element/element-card/index.tsx
+++ b/src/frontend/components/_features/[workspace]/create-element/element-card/index.tsx
@@ -1,24 +1,29 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-misused-promises */
-import { CreatePouSources, PouLanguageSources } from '../../../../../data/sources/POU'
 import * as Popover from '@radix-ui/react-popover'
+
+import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
 import { ArrowIcon } from '../../../../../assets/icons/interface/Arrow'
-import { InputWithRef } from '../../../../_atoms/input'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../_atoms/select'
 import { DatatypeDerivationSources } from '../../../../../data/sources/data-type'
+import { CreatePouSources, PouLanguageSources } from '../../../../../data/sources/POU'
 import { useOpenPLCStore } from '../../../../../store'
-import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
+import { InputWithRef } from '../../../../_atoms/input'
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../_atoms/select'
 
 type PLCArrayDatatype = Extract<PLCDataType, { derivation: 'array' }>
 type PLCEnumeratedDatatype = Extract<PLCDataType, { derivation: 'enumerated' }>
 type PLCStructureDatatype = Extract<PLCDataType, { derivation: 'structure' }>
-import { cn } from '../../../../../utils/cn'
-import { isArduinoTarget as checkIsArduinoTarget, isOpenPLCRuntimeV4Target, isSimulatorTarget } from '../../../../../utils/device'
-import { ConvertToLangShortenedFormat } from '../../../../../utils/formatters/POU'
 import { startCase } from 'lodash'
 import { Dispatch, ReactNode, SetStateAction, useState } from 'react'
 import { Controller, SubmitHandler, useForm } from 'react-hook-form'
 
+import { cn } from '../../../../../utils/cn'
+import {
+  isArduinoTarget as checkIsArduinoTarget,
+  isOpenPLCRuntimeV4Target,
+  isSimulatorTarget,
+} from '../../../../../utils/device'
+import { ConvertToLangShortenedFormat } from '../../../../../utils/formatters/POU'
 import { useToast } from '../../../[app]/toast/use-toast'
 
 type ElementCardProps = {
@@ -159,7 +164,7 @@ const ElementCard = (props: ElementCardProps): ReactNode => {
         derivation: data.derivation,
         baseType: {
           definition: 'base-type',
-          value: 'bool',
+          value: 'BOOL',
         },
         initialValue: '',
         dimensions: [],
diff --git a/src2/frontend/components/_features/[workspace]/create-element/hooks/use-name-validation.ts b/src/frontend/components/_features/[workspace]/create-element/hooks/use-name-validation.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/create-element/hooks/use-name-validation.ts
rename to src/frontend/components/_features/[workspace]/create-element/hooks/use-name-validation.ts
diff --git a/src2/frontend/components/_features/[workspace]/create-element/index.tsx b/src/frontend/components/_features/[workspace]/create-element/index.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/create-element/index.tsx
rename to src/frontend/components/_features/[workspace]/create-element/index.tsx
index f0684f5cc..5824423a1 100644
--- a/src2/frontend/components/_features/[workspace]/create-element/index.tsx
+++ b/src/frontend/components/_features/[workspace]/create-element/index.tsx
@@ -2,8 +2,8 @@ import * as Popover from '@radix-ui/react-popover'
 import { useState } from 'react'
 
 import { PlusIcon } from '../../../../assets/icons/interface/Plus'
-import { cn } from '../../../../utils/cn'
 import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
 import { ElementCard } from './element-card'
 
 const CreatePLCElement = () => {
diff --git a/src2/frontend/components/_features/[workspace]/data-type/index.tsx b/src/frontend/components/_features/[workspace]/data-type/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/data-type/index.tsx
rename to src/frontend/components/_features/[workspace]/data-type/index.tsx
index 37a19ac70..5d7c6004c 100644
--- a/src2/frontend/components/_features/[workspace]/data-type/index.tsx
+++ b/src/frontend/components/_features/[workspace]/data-type/index.tsx
@@ -1,11 +1,12 @@
+import { ComponentPropsWithoutRef, useEffect, useState } from 'react'
+
+import type { PLCDataType } from '../../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '../../../../store'
+import { extractSearchQuery } from '../../../../store/slices/search/utils'
 import { InputWithRef } from '../../../_atoms/input'
 import { ArrayDataType } from '../../../_molecules/data-types/array'
 import { EnumeratorDataType } from '../../../_molecules/data-types/enumerated'
 import { StructureDataType } from '../../../_molecules/data-types/structure'
-import { useOpenPLCStore } from '../../../../store'
-import { extractSearchQuery } from '../../../../store/slices/search/utils'
-import type { PLCDataType } from '../../../../../middleware/shared/ports/types'
-import { ComponentPropsWithoutRef, useEffect, useState } from 'react'
 
 type DatatypeEditorProps = ComponentPropsWithoutRef<'div'> & {
   dataTypeName: string
diff --git a/src2/frontend/components/_features/[workspace]/editor/data-type/index.tsx b/src/frontend/components/_features/[workspace]/editor/data-type/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/data-type/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/data-type/index.tsx
index b38de48b6..e358cbdba 100644
--- a/src2/frontend/components/_features/[workspace]/editor/data-type/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/data-type/index.tsx
@@ -1,11 +1,12 @@
+import { ComponentPropsWithoutRef, useEffect, useState } from 'react'
+
+import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '../../../../../store'
+import { extractSearchQuery } from '../../../../../store/slices/search/utils'
 import { InputWithRef } from '../../../../_atoms/input'
 import { ArrayDataType } from '../../../../_molecules/data-types/array'
 import { EnumeratorDataType } from '../../../../_molecules/data-types/enumerated'
 import { StructureDataType } from '../../../../_molecules/data-types/structure'
-import { useOpenPLCStore } from '../../../../../store'
-import { extractSearchQuery } from '../../../../../store/slices/search/utils'
-import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
-import { ComponentPropsWithoutRef, useEffect, useState } from 'react'
 
 type DatatypeEditorProps = ComponentPropsWithoutRef<'div'> & {
   dataTypeName: string
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/components/configuration-editor.tsx b/src/frontend/components/_features/[workspace]/editor/device/components/configuration-editor.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/device/components/configuration-editor.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/components/configuration-editor.tsx
index 3eb8b6930..93377238e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/components/configuration-editor.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/components/configuration-editor.tsx
@@ -1,7 +1,7 @@
-import { Checkbox } from '../../../../../_atoms/checkbox'
-import { useOpenPLCStore } from '../../../../../../store'
 import { useEffect, useState } from 'react'
 
+import { useOpenPLCStore } from '../../../../../../store'
+import { Checkbox } from '../../../../../_atoms/checkbox'
 import { BoardConfiguration } from '../elements/board-configuration'
 import { RTUSettings } from '../elements/rtu-settings'
 import { TCPSettings } from '../elements/tcp-settings'
@@ -30,7 +30,6 @@ const ConfigurationEditor = () => {
     }
 
     updateModbusConfig()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [deviceBoard])
 
   const toggleModbus = (type: 'RTU' | 'TCP') => setModbusConfig((prev) => ({ ...prev, [type]: !prev[type] }))
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/components/pin-mapping-editor.tsx b/src/frontend/components/_features/[workspace]/editor/device/components/pin-mapping-editor.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/device/components/pin-mapping-editor.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/components/pin-mapping-editor.tsx
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/board.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/board.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/board.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/board.tsx
index 7ee639171..feae4a5de 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/board.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/board.tsx
@@ -1,25 +1,32 @@
 /* eslint-disable @typescript-eslint/no-misused-promises */
-import { boardSelectors, compileOnlySelectors, pinSelectors } from '../../../../../../hooks/use-store-selectors'
+import type { TimingStats } from '@root/middleware/shared/ports/types'
+import { useCapabilities, useDevice, useRuntime } from '@root/middleware/shared/providers/platform-context'
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
 import { MinusIcon } from '../../../../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../../../../assets/icons/interface/Plus'
 import { RefreshIcon } from '../../../../../../assets/icons/interface/Refresh'
+import { boardSelectors, compileOnlySelectors, pinSelectors } from '../../../../../../hooks/use-store-selectors'
+import { useOpenPLCStore } from '../../../../../../store'
+import type { RuntimeConnection } from '../../../../../../store/slices/device/types'
+import { cn } from '../../../../../../utils/cn'
+import {
+  isArduinoTarget,
+  isOpenPLCRuntimeTarget,
+  isOpenPLCRuntimeV4Target,
+  isSimulatorTarget,
+  validateRuntimeVersion,
+} from '../../../../../../utils/device'
 import { Checkbox } from '../../../../../_atoms/checkbox'
 import { Label } from '../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../_atoms/select'
 import TableActions from '../../../../../_atoms/table-actions'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../../../../../_molecules/modal'
 import { DeviceEditorSlot } from '../../../../../_templates/[editors]/device-editor-slot'
-import { useOpenPLCStore } from '../../../../../../store'
-import type { RuntimeConnection } from '../../../../../../store/slices/device/types'
-import type { TimingStats } from '../../../../../../../middleware/shared/ports/types'
-import { useDevice, useRuntime } from '../../../../../../../middleware/shared/providers/platform-context'
-import { cn } from '../../../../../../utils/cn'
-import { isArduinoTarget, isOpenPLCRuntimeTarget, isOpenPLCRuntimeV4Target, isSimulatorTarget, validateRuntimeVersion } from '../../../../../../utils/device'
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
-
 import { PinMappingTable } from './components/pin-mapping-table'
 
 const Board = memo(function () {
+  const capabilities = useCapabilities()
   const device = useDevice()
   const runtime = useRuntime()
 
@@ -167,7 +174,7 @@ const Board = memo(function () {
       const targetBoardInfo = availableBoards.get(normalizedBoard)
       const isArduino = isArduinoTarget(targetBoardInfo)
       const hasPythonFunctionBlocks = pous.some(
-        (pou) => pou.type === 'function-block' && pou.data.language === 'python',
+        (pou) => pou.pouType === 'function-block' && pou.body.language === 'python',
       )
 
       if (isArduino && hasPythonFunctionBlocks) {
@@ -288,7 +295,15 @@ const Board = memo(function () {
     } catch (_error) {
       setRuntimeConnectionStatus('error')
     }
-  }, [runtime, runtimeIpAddress, connectionStatus, setRuntimeConnectionStatus, setRuntimeJwtToken, openModal, deviceBoard])
+  }, [
+    runtime,
+    runtimeIpAddress,
+    connectionStatus,
+    setRuntimeConnectionStatus,
+    setRuntimeJwtToken,
+    openModal,
+    deviceBoard,
+  ])
 
   // Enable timing stats in global polling when this screen is visible
   useEffect(() => {
@@ -415,7 +430,7 @@ const Board = memo(function () {
                 )}
               </div>
             </>
-          ) : (
+          ) : capabilities.hasLocalSerialPorts ? (
             <div id='communication-ports-selector' className='flex w-full items-center justify-start gap-1'>
               <Label
                 id='communication-ports-selector-label'
@@ -473,7 +488,7 @@ const Board = memo(function () {
                 <RefreshIcon size='sm' className={isPressed ? 'spin-refresh' : ''} />
               </button>
             </div>
-          )}
+          ) : null}
           {!isOpenPLCRuntimeTarget(currentBoardInfo) && !isSimulatorTarget(currentBoardInfo) && (
             <div id='board-specs' className='flex w-full flex-col items-start justify-start gap-4'>
               <Label id='board-specs-label' className='w-fit text-xs text-neutral-950 dark:text-white'>
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/communication.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/communication.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/communication.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/communication.tsx
index bcbb6c2b1..71c05212e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/communication.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/communication.tsx
@@ -1,11 +1,11 @@
+import { useEffect, useMemo } from 'react'
+
 import { communicationSelectors } from '../../../../../../hooks/use-store-selectors'
+import { useOpenPLCStore } from '../../../../../../store'
+import { cn } from '../../../../../../utils/cn'
 import { Checkbox } from '../../../../../_atoms/checkbox'
 import { Label } from '../../../../../_atoms/label'
 import { DeviceEditorSlot } from '../../../../../_templates/[editors]/device-editor-slot'
-import { useOpenPLCStore } from '../../../../../../store'
-import { cn } from '../../../../../../utils/cn'
-import { useEffect, useMemo } from 'react'
-
 import { ModbusRTUComponent } from './components/modbus-rtu'
 import { ModbusTCPComponent } from './components/modbus-tcp'
 
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
index 1477aae46..a3a6fb6ef 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
@@ -1,13 +1,14 @@
 import { zodResolver } from '@hookform/resolvers/zod'
-import { rtuSelectors } from '../../../../../../../hooks/use-store-selectors'
+import { rtuSelectors } from '@root/frontend/hooks/use-store-selectors'
+import { cn } from '@root/frontend/utils/cn'
+import { memo, useEffect, useRef, useState } from 'react'
+import { Controller, useForm } from 'react-hook-form'
+import { z } from 'zod'
+
 import { Checkbox } from '../../../../../../_atoms/checkbox'
 import { InputWithRef } from '../../../../../../_atoms/input'
 import { Label } from '../../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
-import { cn } from '../../../../../../../utils/cn'
-import { memo, useEffect, useRef, useState } from 'react'
-import { Controller, useForm } from 'react-hook-form'
-import { z } from 'zod'
 
 const INPUT_STYLES = {
   default:
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
index 7cb991819..9e15bfeec 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
@@ -1,15 +1,15 @@
 import { zodResolver } from '@hookform/resolvers/zod'
-import { tcpSelectors } from '../../../../../../../hooks/use-store-selectors'
-import { Checkbox } from '../../../../../../_atoms/checkbox'
-import { InputWithRef } from '../../../../../../_atoms/input'
-import { Label } from '../../../../../../_atoms/label'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
-import { useOpenPLCStore } from '../../../../../../../store'
-import { cn } from '../../../../../../../utils/cn'
+import { tcpSelectors } from '@root/frontend/hooks/use-store-selectors'
+import { useOpenPLCStore } from '@root/frontend/store'
+import { cn } from '@root/frontend/utils/cn'
 import { ComponentPropsWithoutRef, memo } from 'react'
 import { Controller, useForm } from 'react-hook-form'
 import { z } from 'zod'
 
+import { Checkbox } from '../../../../../../_atoms/checkbox'
+import { InputWithRef } from '../../../../../../_atoms/input'
+import { Label } from '../../../../../../_atoms/label'
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
 import { StaticHostConfigurationComponent } from './static-host'
 
 const INPUT_STYLES = {
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
similarity index 90%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
index d46fc4c0a..ce397d444 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
@@ -1,10 +1,11 @@
+import { pinSelectors } from '@root/frontend/hooks/use-store-selectors'
+import type { DevicePin } from '@root/middleware/shared/ports/types'
+import { createColumnHelper } from '@tanstack/react-table'
+
 import { GenericTable } from '../../../../../../_atoms/generic-table'
 import { PinComboboxInputCell } from '../../../../../../_molecules/pin-mapping-table/combobox-input'
 import { PinSelectInputCell } from '../../../../../../_molecules/pin-mapping-table/select-input'
 import { PinTextInputCell } from '../../../../../../_molecules/pin-mapping-table/text-input'
-import { pinSelectors } from '../../../../../../../hooks/use-store-selectors'
-import type { DevicePin } from '../../../../../../../../middleware/shared/ports/types'
-import { createColumnHelper } from '@tanstack/react-table'
 
 const columnHelper = createColumnHelper<DevicePin>()
 
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
index 32596eadc..d0441c20e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
@@ -1,11 +1,12 @@
 import { zodResolver } from '@hookform/resolvers/zod'
-import { staticHostSelectors } from '../../../../../../../hooks/use-store-selectors'
-import { InputWithRef } from '../../../../../../_atoms/input'
-import { Label } from '../../../../../../_atoms/label'
+import { staticHostSelectors } from '@root/frontend/hooks/use-store-selectors'
 import { ComponentPropsWithoutRef, memo } from 'react'
 import { Controller, useForm } from 'react-hook-form'
 import { z } from 'zod'
 
+import { InputWithRef } from '../../../../../../_atoms/input'
+import { Label } from '../../../../../../_atoms/label'
+
 const INPUT_STYLES = {
   default:
     'flex h-[30px] w-full items-center justify-between gap-1 rounded-md border border-neutral-100 bg-white px-2 py-1 font-caption text-cp-sm font-medium text-neutral-850 outline-none focus:border-brand-medium-dark dark:border-neutral-850 dark:bg-neutral-950 dark:text-neutral-300',
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/configuration/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/configuration/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/device/configuration/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/configuration/index.tsx
index 30aeb5028..b03d30354 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/configuration/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/configuration/index.tsx
@@ -1,5 +1,4 @@
 import { DeviceEditorTemplate } from '../../../../../_templates/[editors]/device-editor-template'
-
 import { Board } from './board'
 import { Communication } from './communication'
 
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/elements/board-configuration/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/elements/board-configuration/index.tsx
similarity index 92%
rename from src2/frontend/components/_features/[workspace]/editor/device/elements/board-configuration/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/elements/board-configuration/index.tsx
index 2cb91af16..2f2a64396 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/elements/board-configuration/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/elements/board-configuration/index.tsx
@@ -1,8 +1,9 @@
-import { RefreshIcon } from '../../../../../../../assets/icons/interface/Refresh'
-import { SelectField } from '../../../../../../_molecules/select-field'
-import { useOpenPLCStore } from '../../../../../../../store'
+import { RefreshIcon } from '@root/frontend/assets/icons/interface/Refresh'
+import { useOpenPLCStore } from '@root/frontend/store'
 import { useCallback, useMemo, useState } from 'react'
 
+import { SelectField } from '../../../../../../_molecules/select-field'
+
 const BoardConfiguration = () => {
   const [isPressed, setIsPressed] = useState(false)
   const {
@@ -13,7 +14,7 @@ const BoardConfiguration = () => {
     deviceActions: { setDeviceBoard, setCommunicationPort },
   } = useOpenPLCStore()
 
-  const refreshCommunicationPorts = async (e: React.MouseEvent) => {
+  const refreshCommunicationPorts = (e: React.MouseEvent) => {
     e.preventDefault()
     try {
       setIsPressed(true)
@@ -60,7 +61,7 @@ const BoardConfiguration = () => {
         </div>
         <div id='programming-port-selection' className='flex items-center justify-center gap-1'>
           <SelectField
-            options={availableCommunicationPorts}
+            options={availableCommunicationPorts.map((p) => p.name)}
             setSelectedOption={setCommunicationPort}
             label='Programming Port'
             placeholder={communicationPort}
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/elements/rtu-settings/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/elements/rtu-settings/index.tsx
similarity index 85%
rename from src2/frontend/components/_features/[workspace]/editor/device/elements/rtu-settings/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/elements/rtu-settings/index.tsx
index 3a4b472de..7d249545e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/elements/rtu-settings/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/elements/rtu-settings/index.tsx
@@ -1,8 +1,9 @@
+import { useOpenPLCStore } from '@root/frontend/store'
+import { cn } from '@root/frontend/utils/cn'
+import { ComponentPropsWithoutRef } from 'react'
+
 import { InputField } from '../../../../../../_molecules/input-field'
 import { SelectField } from '../../../../../../_molecules/select-field'
-import { useOpenPLCStore } from '../../../../../../../store'
-import { cn } from '../../../../../../../utils/cn'
-import { ComponentPropsWithoutRef } from 'react'
 
 type RTUSettingsProps = ComponentPropsWithoutRef<'div'> & {
   userEnabled?: boolean
@@ -10,11 +11,11 @@ type RTUSettingsProps = ComponentPropsWithoutRef<'div'> & {
 
 const RTUSettings = ({ userEnabled, ...props }: RTUSettingsProps) => {
   const {
-    deviceAvailableOptions: { availableRTUInterfaces, availableRTUBaudrates },
+    deviceAvailableOptions: { availableRTUInterfaces, availableRTUBaudRates },
     deviceDefinitions: {
       configuration: {
         communicationConfiguration: {
-          modbusRTU: { rtuInterface, rtuBaudrate },
+          modbusRTU: { rtuInterface, rtuBaudRate },
         },
       },
     },
@@ -44,8 +45,8 @@ const RTUSettings = ({ userEnabled, ...props }: RTUSettingsProps) => {
         <SelectField
           ariaLabel='RTU Baudrate select'
           // setSelectedOption={setSelectBaudRateOption}
-          selectedOption={rtuBaudrate}
-          options={availableRTUBaudrates}
+          selectedOption={rtuBaudRate}
+          options={availableRTUBaudRates}
           label='Baudrate'
         />
         <InputField
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/elements/tcp-settings/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/elements/tcp-settings/index.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/device/elements/tcp-settings/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/elements/tcp-settings/index.tsx
index 47e7f20bd..09f3790c5 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/elements/tcp-settings/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/elements/tcp-settings/index.tsx
@@ -1,8 +1,9 @@
+import { cn } from '@root/frontend/utils/cn'
+import { ComponentPropsWithoutRef, useState } from 'react'
+
 import { Checkbox } from '../../../../../../_atoms/checkbox'
 import { InputField } from '../../../../../../_molecules/input-field'
 import { SelectField } from '../../../../../../_molecules/select-field'
-import { cn } from '../../../../../../../utils/cn'
-import { ComponentPropsWithoutRef, useState } from 'react'
 
 type TCPSettingsProps = ComponentPropsWithoutRef<'div'> & {
   userEnabled: boolean
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/index.tsx
similarity index 59%
rename from src2/frontend/components/_features/[workspace]/editor/device/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/index.tsx
index 931466758..d295637e1 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/index.tsx
@@ -1,15 +1,19 @@
-import { useOpenPLCStore } from '../../../../../store'
 import { useEffect } from 'react'
 
+import { useOpenPLCStore } from '../../../../../store'
 import { DeviceConfigurationEditor } from './configuration'
+import { DeviceOrchestratorsEditor } from './orchestrators'
 
 const DeviceEditor = () => {
   const {
+    editor,
     deviceUpdated: { updated: deviceUpdated },
     deviceActions: { resetDeviceUpdated },
     sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
   } = useOpenPLCStore()
 
+  const derivation = editor.type === 'plc-device' ? editor.meta.derivation : null
+
   useEffect(() => {
     if (deviceUpdated) {
       handleFileAndWorkspaceSavedState('Configuration')
@@ -17,7 +21,11 @@ const DeviceEditor = () => {
     }
   }, [deviceUpdated])
 
-  return <DeviceConfigurationEditor />
+  return (
+    <div aria-label='Device content container' className='h-full w-full overflow-hidden'>
+      {derivation === 'orchestrators' ? <DeviceOrchestratorsEditor /> : <DeviceConfigurationEditor />}
+    </div>
+  )
 }
 
 export { DeviceEditor }
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/orchestrators/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/orchestrators/index.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/device/orchestrators/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/orchestrators/index.tsx
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/orchestrators/orchestrators-list.tsx b/src/frontend/components/_features/[workspace]/editor/device/orchestrators/orchestrators-list.tsx
similarity index 85%
rename from src2/frontend/components/_features/[workspace]/editor/device/orchestrators/orchestrators-list.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/orchestrators/orchestrators-list.tsx
index 2ab5a2165..3bde74e1e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/orchestrators/orchestrators-list.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/orchestrators/orchestrators-list.tsx
@@ -1,107 +1,19 @@
-import { DeviceEditorSlot } from '../../../../../_templates/[editors]/device-editor-slot'
-import { cn } from '../../../../../../utils/cn'
 import { useCallback, useEffect, useRef, useState } from 'react'
+
+import type { OrchestratorInfo } from '../../../../../../../middleware/shared/ports/orchestrator-port'
+import { useOrchestrator, useRuntime } from '../../../../../../../middleware/shared/providers'
 import { ArrowIcon } from '../../../../../../assets/icons/interface/Arrow'
 import { RefreshIcon } from '../../../../../../assets/icons/interface/Refresh'
+import { WarningIcon } from '../../../../../../assets/icons/interface/Warning'
 import { useOpenPLCStore } from '../../../../../../store'
-import { runtimeGetUsersInfo, runtimeLogout } from '../../../../../../services/api/runtime-api'
-import { RuntimeLoginModal, RuntimeCreateUserModal } from '../../../../../_organisms/modals'
+import { cn } from '../../../../../../utils/cn'
+import { getErrorMessage } from '../../../../../../utils/get-error-message'
 import { Modal, ModalContent, ModalTitle } from '../../../../../_molecules/modal'
-import { WarningIcon } from '../../../../../../assets/icons/interface/Warning'
-import { listOrchestratorsRequest, type OrchestratorResponse, type DeviceResponse, } from '../../../../../../api/queries/orchestrators'
+import { DeviceEditorSlot } from '../../../../../_templates/[editors]/device-editor-slot'
 
 // Note: Status and timing stats polling is handled globally by useRuntimePolling hook.
 // This component sets includeTimingStatsInPolling=true on mount to request timing stats.
 
-/**
- * Local device interface for UI display
- * Uses a subset of DeviceResponse fields needed for the orchestrators list
- */
-interface Device {
-  id: string
-  name: string
-  status: string | null
-  active: boolean | null
-}
-
-/**
- * Local orchestrator interface for UI display
- */
-interface Orchestrator {
-  id: string
-  name: string
-  orchestrator_id: string
-  description: string | null
-  devices: Device[]
-}
-
-/**
- * Maps Edge API DeviceResponse to local Device interface
- * Derives 'active' from 'is_running' field since Edge API doesn't have 'active' directly
- */
-function mapDeviceResponseToDevice(device: DeviceResponse): Device {
-  return {
-    id: device.id,
-    name: device.name,
-    status: device.container_status || device.status,
-    // Derive 'active' from 'is_running' - device is active if its container is running
-    active: device.is_running ?? (device.status !== 'inactive' && device.status !== 'error'),
-  }
-}
-
-/**
- * Maps Edge API OrchestratorResponse to local Orchestrator interface
- */
-function mapOrchestratorResponse(orchestrator: OrchestratorResponse): Orchestrator {
-  return {
-    id: orchestrator.id,
-    name: orchestrator.name,
-    orchestrator_id: orchestrator.orchestrator_id,
-    description: orchestrator.description,
-    devices: orchestrator.devices.map(mapDeviceResponseToDevice),
-  }
-}
-
-// Mock data for development environment testing
-// This allows testing the orchestrators UI without a backend connection
-const MOCK_ORCHESTRATORS: Orchestrator[] = [
-  {
-    id: 'mock-orch-1',
-    name: 'Lab Orchestrator',
-    orchestrator_id: 'LAB12345',
-    description: 'Raspberry Pi in the development lab',
-    devices: [
-      { id: 'mock-dev-1', name: 'Lab PLC #1', status: 'running', active: true },
-      { id: 'mock-dev-2', name: 'Lab PLC #2', status: 'stopped', active: true },
-      { id: 'mock-dev-3', name: 'Inactive Device', status: 'offline', active: false },
-    ],
-  },
-  {
-    id: 'mock-orch-2',
-    name: 'QA Orchestrator',
-    orchestrator_id: 'QA98765',
-    description: 'QA test environment',
-    devices: [
-      { id: 'mock-dev-4', name: 'QA Runtime', status: 'running', active: true },
-      { id: 'mock-dev-5', name: 'QA Backup', status: 'idle', active: true },
-    ],
-  },
-  {
-    id: 'mock-orch-3',
-    name: 'Production Orchestrator',
-    orchestrator_id: 'PROD54321',
-    description: 'Production environment - handle with care',
-    devices: [{ id: 'mock-dev-6', name: 'Main PLC', status: 'running', active: true }],
-  },
-  {
-    id: 'mock-orch-4',
-    name: 'Empty Orchestrator',
-    orchestrator_id: 'EMPTY0000',
-    description: 'Orchestrator with no devices registered',
-    devices: [],
-  },
-]
-
 const SIMULATOR_BOARD_NAME = 'OpenPLC Simulator'
 const RUNTIME_BOARD_NAME = 'OpenPLC Runtime v3'
 
@@ -148,8 +60,10 @@ const StatusBadge = ({ status }: { status: string | null }) => {
 }
 
 const OrchestratorsList = () => {
+  const orchestratorPort = useOrchestrator()
+  const runtimePort = useRuntime()
   const { modalActions, deviceActions, runtimeConnection } = useOpenPLCStore()
-  const [orchestrators, setOrchestrators] = useState<Orchestrator[]>([])
+  const [orchestrators, setOrchestrators] = useState<OrchestratorInfo[]>([])
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
   const [expandedOrchestrators, setExpandedOrchestrators] = useState<Set<string>>(new Set())
@@ -201,29 +115,17 @@ const OrchestratorsList = () => {
   }, [runtimeConnection.connectionStatus, isSimulatorSelected, deviceActions])
 
   const fetchOrchestrators = useCallback(async () => {
-    console.info('[Orchestrators] Using Edge API to fetch orchestrators')
     try {
-      const response = await listOrchestratorsRequest()
-      // Map Edge API response to local interface format
-      const mappedOrchestrators = response.data.orchestrators.map(mapOrchestratorResponse)
-      setOrchestrators(mappedOrchestrators)
+      const result = await orchestratorPort.listOrchestrators()
+      setOrchestrators(result)
       setError(null)
     } catch (error) {
-      console.error('[Orchestrators] Edge API fetch failed', error)
-
-      // In development mode, fall back to mock data for local testing
-      if (import.meta.env?.DEV) {
-        console.info('[Orchestrators] Using mock data for development')
-        await new Promise((resolve) => setTimeout(resolve, 300))
-        setOrchestrators(MOCK_ORCHESTRATORS)
-        setError(null)
-      } else {
-        setError('Failed to load orchestrators. Please try again.')
-      }
+      console.error('[Orchestrators] Fetch failed', error)
+      setError('Failed to load orchestrators. Please try again.')
     } finally {
       setLoading(false)
     }
-  }, [])
+  }, [orchestratorPort])
 
   useEffect(() => {
     void fetchOrchestrators()
@@ -311,8 +213,14 @@ const OrchestratorsList = () => {
         deviceName: selectedDevice.deviceName,
       })
 
-      // Check if the runtime has users (token handling is done internally by runtimeGetUsersInfo)
-      const usersInfo = await runtimeGetUsersInfo(selectedDevice.orchestratorAgentId, selectedDevice.deviceId)
+      // Set device context so the runtime adapter knows which device to target
+      runtimePort.setDeviceContext?.({
+        agentId: selectedDevice.orchestratorAgentId,
+        deviceId: selectedDevice.deviceId,
+      })
+
+      // Check if the runtime has users via the runtime port
+      const usersInfo = await runtimePort.getUsersInfo()
 
       if (usersInfo.error) {
         setConnectionError('Failed to connect to runtime: ' + usersInfo.error)
@@ -327,12 +235,12 @@ const OrchestratorsList = () => {
         modalActions.openModal('runtime-create-user')
       }
     } catch (err: unknown) {
-      setConnectionError('Error: ' + String(err))
+      setConnectionError('Error: ' + getErrorMessage(err))
       deviceActions.setRuntimeConnectionStatus('error')
     } finally {
       setIsConnecting(false)
     }
-  }, [selectedDevice, deviceActions, modalActions])
+  }, [selectedDevice, deviceActions, modalActions, runtimePort])
 
   // Helper to clear all connection state (store + local component state)
   // This centralizes the "tear down connection" logic to avoid duplication
@@ -351,22 +259,22 @@ const OrchestratorsList = () => {
     setConnectionError(null)
 
     try {
-      // Token handling is done internally by runtimeLogout
-      await runtimeLogout(
-        runtimeConnection.selectedDevice.orchestratorAgentId,
-        runtimeConnection.selectedDevice.deviceId,
-        runtimeConnection.jwtToken,
-      )
+      // Logout via the runtime port (clears JWT on the adapter side)
+      await runtimePort.clearCredentials()
+
+      // Clear device context since we're disconnecting
+      runtimePort.setDeviceContext?.(null)
 
       // Clear all connection state regardless of logout result
       clearConnectionState()
     } catch {
       // Still clear the connection state on error
+      runtimePort.setDeviceContext?.(null)
       clearConnectionState()
     } finally {
       setIsDisconnecting(false)
     }
-  }, [runtimeConnection.selectedDevice, runtimeConnection.jwtToken, clearConnectionState])
+  }, [runtimeConnection.selectedDevice, runtimeConnection.jwtToken, runtimePort, clearConnectionState])
 
   const handleSimulatorSelect = useCallback(() => {
     // If connected to an orchestrator device, disconnect first
@@ -424,7 +332,7 @@ const OrchestratorsList = () => {
             </p>
             <button
               type='button'
-              onClick={handleRefresh}
+              onClick={() => void handleRefresh()}
               disabled={isRefreshing}
               className={cn('group', isRefreshing && 'cursor-not-allowed opacity-50')}
               aria-label='Refresh orchestrators'
@@ -438,7 +346,7 @@ const OrchestratorsList = () => {
             className={cn(
               'cursor-pointer rounded-lg border px-4 py-3',
               isSimulatorSelected && runtimeConnection.connectionStatus !== 'connected'
-                ? 'border-brand bg-brand/5 dark:border-brand dark:bg-brand/10'
+                ? 'bg-brand/5 dark:bg-brand/10 border-brand dark:border-brand'
                 : 'border-neutral-200 bg-neutral-50 hover:bg-neutral-100 dark:border-neutral-700 dark:bg-neutral-900 dark:hover:bg-neutral-800',
             )}
             onClick={handleSimulatorSelect}
@@ -548,7 +456,7 @@ const OrchestratorsList = () => {
                               onClick={() =>
                                 handleDeviceSelect(
                                   orchestrator.id,
-                                  orchestrator.orchestrator_id,
+                                  orchestrator.agentId,
                                   device.id,
                                   device.name,
                                   device.active !== false,
@@ -629,9 +537,6 @@ const OrchestratorsList = () => {
             </div>
           )}
 
-          <RuntimeLoginModal />
-          <RuntimeCreateUserModal />
-
           {/* Device Switch Confirmation Modal */}
           <Modal open={showSwitchConfirmModal} onOpenChange={setShowSwitchConfirmModal}>
             <ModalContent className='flex h-[320px] w-[400px] select-none flex-col items-center justify-evenly rounded-lg'>
diff --git a/src2/frontend/components/_features/[workspace]/editor/device/remote-device/index.tsx b/src/frontend/components/_features/[workspace]/editor/device/remote-device/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/device/remote-device/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/device/remote-device/index.tsx
index d25f2848d..ebaa60f78 100644
--- a/src2/frontend/components/_features/[workspace]/editor/device/remote-device/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/device/remote-device/index.tsx
@@ -1,19 +1,21 @@
 import * as Popover from '@radix-ui/react-popover'
+import type { ModbusIOGroup, ModbusIOPoint } from '@root/middleware/shared/ports/types'
+import { useRuntime } from '@root/middleware/shared/providers/platform-context'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { v4 as uuidv4 } from 'uuid'
+
 import { ArrowIcon } from '../../../../../../assets/icons/interface/Arrow'
 import { MinusIcon } from '../../../../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../../../../assets/icons/interface/Plus'
+import { useOpenPLCStore } from '../../../../../../store'
+import { cn } from '../../../../../../utils/cn'
+import { getErrorMessage } from '../../../../../../utils/get-error-message'
 import { InputWithRef } from '../../../../../_atoms/input'
 import { Label } from '../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../_atoms/select'
 import TableActions from '../../../../../_atoms/table-actions'
-import ScrollAreaComponent from '../../../../../ui/scroll-area'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../../../../../_molecules/modal'
-import { useOpenPLCStore } from '../../../../../../store'
-import { useRuntime } from '../../../../../../../middleware/shared/providers/platform-context'
-import type { ModbusIOGroup, ModbusIOPoint } from '../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../utils/cn'
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { v4 as uuidv4 } from 'uuid'
+import ScrollAreaComponent from '../../../../../ui/scroll-area'
 
 type FunctionCodeOption = {
   value: '1' | '2' | '3' | '4' | '5' | '6' | '15' | '16'
@@ -490,7 +492,7 @@ const IOGroupRow = ({
   onEdit,
   onUpdateAlias,
 }: IOGroupRowProps) => {
-  const firstIOPoint = ioGroup.ioPoints[0]
+  const firstIOPoint = ioGroup.ioPoints?.[0]
   const groupType = firstIOPoint?.type || '-'
   const groupAddress = firstIOPoint?.iecLocation || '-'
   const groupOffset = ioGroup.offset
@@ -529,7 +531,7 @@ const IOGroupRow = ({
         <td className='px-2 py-2 text-sm text-neutral-700 dark:text-neutral-300'>-</td>
       </tr>
       {isExpanded &&
-        ioGroup.ioPoints.map((ioPoint: ModbusIOPoint, index: number) => (
+        (ioGroup.ioPoints ?? []).map((ioPoint: ModbusIOPoint, index: number) => (
           <IOPointRow
             key={ioPoint.id}
             ioPoint={ioPoint}
@@ -683,7 +685,7 @@ const RemoteDeviceEditor = () => {
       consoleActions.addLog({
         id: crypto.randomUUID(),
         level: 'warning',
-        message: `Error fetching serial ports: ${String(error)}`,
+        message: `Error fetching serial ports: ${getErrorMessage(error)}`,
       })
       setSerialPortOptions([])
     } finally {
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/FBD/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/FBD/index.tsx
similarity index 85%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/FBD/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/FBD/index.tsx
index e699f2bf7..13bfface4 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/FBD/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/FBD/index.tsx
@@ -1,9 +1,10 @@
+import { useEffect, useMemo } from 'react'
+
+import { useOpenPLCStore } from '../../../../../../store'
+import { zodFBDFlowSchema } from '../../../../../../store/slices/fbd'
 import { BlockNodeData } from '../../../../../_atoms/graphical-editor/fbd/block'
 import { BlockVariant } from '../../../../../_atoms/graphical-editor/types/block'
 import { FBDBody } from '../../../../../_molecules/graphical-editor/fbd'
-import { useOpenPLCStore } from '../../../../../../store'
-import { zodFBDFlowSchema } from '../../../../../../store/slices/fbd'
-import { useEffect, useMemo } from 'react'
 
 export default function FbdEditor() {
   const editor = useOpenPLCStore((state) => state.editor)
@@ -32,11 +33,11 @@ export default function FbdEditor() {
       const libMatch = userLibraries.find((lib) => lib.name === variant.name && lib.type === variant.type)
       if (!libMatch) continue
 
-      const originalPou = pous.find((pou) => pou.data.name === libMatch.name)
+      const originalPou = pous.find((pou) => pou.name === libMatch.name)
       if (!originalPou) continue
 
-      const originalVariables = originalPou.data?.variables ?? []
-      const originalInOut = originalVariables?.filter((variable) =>
+      const originalVariables = originalPou.interface?.variables ?? []
+      const originalInOut = originalVariables.filter((variable) =>
         ['input', 'output', 'inOut'].includes(variable.class || ''),
       )
 
@@ -51,10 +52,10 @@ export default function FbdEditor() {
         type: { definition: string; value: string }
       }) => `${variable.name}|${variable.class}|${variable.type.definition}|${variable.type.value?.toLowerCase()}`
 
-      if (originalPou.type === 'function') {
+      if (originalPou.pouType === 'function') {
         const outVariable = variant.variables.find((v) => v.name === 'OUT')
         const outType = outVariable?.type?.value?.toUpperCase()
-        const returnType = originalPou.data.returnType?.toUpperCase()
+        const returnType = originalPou.interface?.returnType?.toUpperCase()
         if (!outType || !returnType || outType !== returnType) {
           divergences.push(node.id)
           continue
@@ -92,7 +93,12 @@ export default function FbdEditor() {
     })
 
     fbdFlowActions.setFlowUpdated({ editorName: editor.meta.name, updated: false })
-    handleFileAndWorkspaceSavedState(editor.meta.name)
+
+    // During debug the editor is read-only — any flow update is from internal state
+    // management (e.g. node styling for debug indicators), not a user edit.
+    if (!isDebuggerVisible) {
+      handleFileAndWorkspaceSavedState(editor.meta.name)
+    }
   }, [flowUpdated])
 
   return (
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/SFC/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/SFC/index.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/SFC/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/SFC/index.tsx
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
similarity index 92%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
index 1209f1296..9f6cdc656 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
@@ -1,4 +1,4 @@
-import ArrowButton from '../../../../../../../assets/icons/interface/ArrowButton'
+import ArrowButton from '@root/frontend/assets/icons/interface/ArrowButton'
 
 type ArrowButtonGroupProps = {
   onIncrement: () => void
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
similarity index 94%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
index ff04c368e..0da5971a1 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
@@ -1,25 +1,8 @@
 import * as Switch from '@radix-ui/react-switch'
-import { InputWithRef } from '../../../../../../../_atoms/input'
-import {
-  BlockNode,
-  BlockNodeData,
-  BlockNodeElement,
-} from '../../../../../../../_atoms/graphical-editor/fbd/block'
-import { buildBlockNode } from '../../../../../../../_atoms/graphical-editor/fbd/buildNodes'
-import { getBlockSize } from '../../../../../../../_atoms/graphical-editor/fbd/utils/utils'
-import { BasicNodeData } from '../../../../../../../_atoms/graphical-editor/fbd/utils/types'
-import { getFBDPouVariablesRungNodeAndEdges } from '../../../../../../../_atoms/graphical-editor/fbd/utils/utils'
-import { BlockVariant } from '../../../../../../../_atoms/graphical-editor/types/block'
-import {
-  getBlockDocumentation,
-  getVariableRestrictionType,
-} from '../../../../../../../_atoms/graphical-editor/utils'
-import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
-import { useOpenPLCStore } from '../../../../../../../../store'
-import type { EditorModel } from '../../../../../../../../store/slices/editor'
-import type { LibraryState } from '../../../../../../../../store/slices/library'
-import { PLCPou } from '../../../../../../../../../middleware/shared/ports'
-import { cn } from '../../../../../../../../utils/cn'
+import { useOpenPLCStore } from '@root/frontend/store'
+import type { EditorModel } from '@root/frontend/store/slices/editor'
+import type { LibraryState } from '@root/frontend/store/slices/library'
+import { cn } from '@root/frontend/utils/cn'
 import {
   assembleVariables,
   buildNextExtensibleInput,
@@ -27,10 +10,20 @@ import {
   getMinInputCount,
   rebuildVariablesForInputCount,
   removeLastExtensibleInput,
-} from '../../../../../../../../utils/PLC/extensible-block-variables'
+} from '@root/frontend/utils/PLC/extensible-block-variables'
+import { PLCPou } from '@root/middleware/shared/ports'
 import { useEffect, useRef, useState } from 'react'
 import { v4 as uuidv4 } from 'uuid'
 
+import { BlockNode, BlockNodeData, BlockNodeElement } from '../../../../../../../_atoms/graphical-editor/fbd/block'
+import { buildBlockNode } from '../../../../../../../_atoms/graphical-editor/fbd/buildNodes'
+import { BasicNodeData } from '../../../../../../../_atoms/graphical-editor/fbd/utils/types'
+import { getBlockSize } from '../../../../../../../_atoms/graphical-editor/fbd/utils/utils'
+import { getFBDPouVariablesRungNodeAndEdges } from '../../../../../../../_atoms/graphical-editor/fbd/utils/utils'
+import { BlockVariant } from '../../../../../../../_atoms/graphical-editor/types/block'
+import { getBlockDocumentation, getVariableRestrictionType } from '../../../../../../../_atoms/graphical-editor/utils'
+import { InputWithRef } from '../../../../../../../_atoms/input'
+import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
 import ArrowButtonGroup from '../../arrow-button-group'
 import { ModalBlockLibrary } from './library'
 
@@ -49,7 +42,7 @@ const searchLibraryByPouName = (
   let libraryBlock: unknown = undefined
 
   const filteredLibraries = libraries.system.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.pous.some((pou) => pou.type === 'function')
       : true,
   )
@@ -134,30 +127,31 @@ const BlockElement = <T extends object>({ isOpen, onClose, selectedNode }: Block
 
       let pouLibrary = undefined
       if (type === 'user') {
-        const pou = pous.find((pou) => pou.data.name === selectedFile?.name)
+        const pou = pous.find((pou) => pou.name === selectedFile?.name)
         if (!pou) return
-        const variables = pou.data.variables.map((variable) => ({
+        const variables = (pou.interface?.variables ?? []).map((variable) => ({
           name: variable.name,
           class: variable.class,
           type: { definition: variable.type.definition, value: variable.type.value.toUpperCase() },
         }))
-        if (pou.type === 'function') {
-          const variable = getVariableRestrictionType(pou.data.returnType)
+        if (pou.pouType === 'function') {
+          const returnType = pou.interface?.returnType ?? ''
+          const variable = getVariableRestrictionType(returnType)
           variables.push({
             name: 'OUT',
             class: 'output',
             type: {
               definition: (variable.definition as 'array' | 'base-type' | 'user-data-type' | 'derived') ?? 'derived',
-              value: pou.data.returnType.toUpperCase(),
+              value: returnType.toUpperCase(),
             },
           })
         }
 
         pouLibrary = {
-          name: pou.data.name,
-          type: pou.type as 'function-block' | 'function',
+          name: pou.name,
+          type: pou.pouType as 'function-block' | 'function',
           variables: variables,
-          documentation: pou.data.documentation,
+          documentation: pou.documentation,
           extensible: false,
         }
       }
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
similarity index 92%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
index 877c4d842..fe919554a 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
@@ -1,8 +1,9 @@
-import { MagnifierIcon } from '../../../../../../../../assets/icons/interface/Magnifier'
+import { MagnifierIcon } from '@root/frontend/assets/icons/interface/Magnifier'
+import { useOpenPLCStore } from '@root/frontend/store'
+import { useState } from 'react'
+
 import { InputWithRef } from '../../../../../../../_atoms/input'
 import { LibraryFile, LibraryFolder, LibraryRoot } from '../../../../../../../_molecules/library-tree'
-import { useOpenPLCStore } from '../../../../../../../../store'
-import { useState } from 'react'
 
 export const ModalBlockLibrary = ({
   selectedFileKey,
@@ -22,12 +23,12 @@ export const ModalBlockLibrary = ({
   const [filterText, setFilterText] = useState('')
 
   const systemLibraries = system.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.pous.some((pou) => pou.name.toLowerCase().includes(filterText) && pou.type === 'function')
       : library.pous.some((pou) => pou.name.toLowerCase().includes(filterText)),
   )
   const userLibraries = user.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.type === 'function' && library.name.toLowerCase().includes(filterText)
       : library.name.toLowerCase().includes(filterText),
   )
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
similarity index 94%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
index 8fa7626a8..865634d76 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
@@ -1,5 +1,20 @@
 import * as Switch from '@radix-ui/react-switch'
-import { InputWithRef } from '../../../../../../../_atoms/input'
+import { useOpenPLCStore } from '@root/frontend/store'
+import type { EditorModel } from '@root/frontend/store/slices/editor'
+import type { LibraryState } from '@root/frontend/store/slices/library'
+import { cn } from '@root/frontend/utils/cn'
+import {
+  assembleVariables,
+  buildNextExtensibleInput,
+  classifyBlockVariables,
+  getMinInputCount,
+  rebuildVariablesForInputCount,
+  removeLastExtensibleInput,
+} from '@root/frontend/utils/PLC/extensible-block-variables'
+import { PLCPou } from '@root/middleware/shared/ports'
+import { useEffect, useRef, useState } from 'react'
+import { v4 as uuidv4 } from 'uuid'
+
 import {
   BlockNode,
   BlockNodeData,
@@ -7,32 +22,14 @@ import {
   BlockVariant as LadderBlockVariant,
 } from '../../../../../../../_atoms/graphical-editor/ladder/block'
 import { buildBlockNode } from '../../../../../../../_atoms/graphical-editor/ladder/buildNodes'
+import { BasicNodeData } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { getBlockSize } from '../../../../../../../_atoms/graphical-editor/ladder/utils/utils'
 import { getLadderPouVariablesRungNodeAndEdges } from '../../../../../../../_atoms/graphical-editor/ladder/utils/utils'
-import { BasicNodeData } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { BlockVariant } from '../../../../../../../_atoms/graphical-editor/types/block'
-import {
-  getBlockDocumentation,
-  getVariableRestrictionType,
-} from '../../../../../../../_atoms/graphical-editor/utils'
-import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
+import { getBlockDocumentation, getVariableRestrictionType } from '../../../../../../../_atoms/graphical-editor/utils'
+import { InputWithRef } from '../../../../../../../_atoms/input'
 import { updateDiagramElementsPosition } from '../../../../../../../_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram'
-import { useOpenPLCStore } from '../../../../../../../../store'
-import type { EditorModel } from '../../../../../../../../store/slices/editor'
-import type { LibraryState } from '../../../../../../../../store/slices/library'
-import { PLCPou } from '../../../../../../../../../middleware/shared/ports'
-import { cn } from '../../../../../../../../utils/cn'
-import {
-  assembleVariables,
-  buildNextExtensibleInput,
-  classifyBlockVariables,
-  getMinInputCount,
-  rebuildVariablesForInputCount,
-  removeLastExtensibleInput,
-} from '../../../../../../../../utils/PLC/extensible-block-variables'
-import { useEffect, useRef, useState } from 'react'
-import { v4 as uuidv4 } from 'uuid'
-
+import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
 import ArrowButtonGroup from '../../arrow-button-group'
 import { ModalBlockLibrary } from './library'
 
@@ -51,7 +48,7 @@ const searchLibraryByPouName = (
   let libraryBlock: unknown = undefined
 
   const filteredLibraries = libraries.system.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.pous.some((pou) => pou.type === 'function')
       : true,
   )
@@ -139,30 +136,31 @@ const BlockElement = <T extends object>({ isOpen, onClose, selectedNode }: Block
 
       let pouLibrary = undefined
       if (type === 'user') {
-        const pou = pous.find((pou) => pou.data.name === selectedFile?.name)
+        const pou = pous.find((pou) => pou.name === selectedFile?.name)
         if (!pou) return
-        const variables = pou.data.variables.map((variable) => ({
+        const variables = (pou.interface?.variables ?? []).map((variable) => ({
           name: variable.name,
           class: variable.class,
           type: { definition: variable.type.definition, value: variable.type.value.toUpperCase() },
         }))
-        if (pou.type === 'function') {
-          const variable = getVariableRestrictionType(pou.data.returnType)
+        if (pou.pouType === 'function') {
+          const returnType = pou.interface?.returnType ?? ''
+          const variable = getVariableRestrictionType(returnType)
           variables.push({
             name: 'OUT',
             class: 'output',
             type: {
               definition: (variable.definition as 'array' | 'base-type' | 'user-data-type' | 'derived') ?? 'derived',
-              value: pou.data.returnType.toUpperCase(),
+              value: returnType.toUpperCase(),
             },
           })
         }
 
         pouLibrary = {
-          name: pou.data.name,
-          type: pou.type as 'function-block' | 'function',
+          name: pou.name,
+          type: pou.pouType as 'function-block' | 'function',
           variables: variables,
-          documentation: pou.data.documentation,
+          documentation: pou.documentation,
           extensible: false,
         }
       }
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
similarity index 92%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
index 877c4d842..fe919554a 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
@@ -1,8 +1,9 @@
-import { MagnifierIcon } from '../../../../../../../../assets/icons/interface/Magnifier'
+import { MagnifierIcon } from '@root/frontend/assets/icons/interface/Magnifier'
+import { useOpenPLCStore } from '@root/frontend/store'
+import { useState } from 'react'
+
 import { InputWithRef } from '../../../../../../../_atoms/input'
 import { LibraryFile, LibraryFolder, LibraryRoot } from '../../../../../../../_molecules/library-tree'
-import { useOpenPLCStore } from '../../../../../../../../store'
-import { useState } from 'react'
 
 export const ModalBlockLibrary = ({
   selectedFileKey,
@@ -22,12 +23,12 @@ export const ModalBlockLibrary = ({
   const [filterText, setFilterText] = useState('')
 
   const systemLibraries = system.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.pous.some((pou) => pou.name.toLowerCase().includes(filterText) && pou.type === 'function')
       : library.pous.some((pou) => pou.name.toLowerCase().includes(filterText)),
   )
   const userLibraries = user.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.type === 'function' && library.name.toLowerCase().includes(filterText)
       : library.name.toLowerCase().includes(filterText),
   )
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
index 3ec3061cf..040a8a33b 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
@@ -1,9 +1,10 @@
+import { useOpenPLCStore } from '@root/frontend/store'
+import { useState } from 'react'
+
 import { CoilNode } from '../../../../../../../_atoms/graphical-editor/ladder/coil'
 import { DEFAULT_COIL_TYPES } from '../../../../../../../_atoms/graphical-editor/ladder/utils/constants'
 import { getLadderPouVariablesRungNodeAndEdges } from '../../../../../../../_atoms/graphical-editor/ladder/utils/utils'
 import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
-import { useOpenPLCStore } from '../../../../../../../../store'
-import { useState } from 'react'
 
 type CoilElementProps = {
   isOpen: boolean
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
index dc0d23624..eba913f7f 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
@@ -1,9 +1,10 @@
+import { useOpenPLCStore } from '@root/frontend/store'
+import { useState } from 'react'
+
 import { ContactNode } from '../../../../../../../_atoms/graphical-editor/ladder/contact'
 import { DEFAULT_CONTACT_TYPES } from '../../../../../../../_atoms/graphical-editor/ladder/utils/constants'
 import { getLadderPouVariablesRungNodeAndEdges } from '../../../../../../../_atoms/graphical-editor/ladder/utils/utils'
 import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
-import { useOpenPLCStore } from '../../../../../../../../store'
-import { useState } from 'react'
 
 type ContactElementProps = {
   isOpen: boolean
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/index.tsx
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
similarity index 88%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
index a7cd10ac4..8402ffb9a 100644
--- a/src2/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
@@ -15,20 +15,21 @@ import {
 import { restrictToParentElement } from '@dnd-kit/modifiers'
 import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
 import * as Portal from '@radix-ui/react-portal'
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { createPortal } from 'react-dom'
+import { v4 as uuidv4 } from 'uuid'
+
+import { ladderSelectors } from '../../../../../../hooks/use-store-selectors'
+import { openPLCStoreBase, useOpenPLCStore } from '../../../../../../store'
+import { RungLadderState, zodLadderFlowSchema } from '../../../../../../store/slices/ladder'
+import type { PouHistorySnapshot } from '../../../../../../store/slices/shared/types'
+import { cn } from '../../../../../../utils/cn'
 import { BlockNode, BlockNodeData } from '../../../../../_atoms/graphical-editor/ladder/block'
 import { CoilNode } from '../../../../../_atoms/graphical-editor/ladder/coil'
 import { ContactNode } from '../../../../../_atoms/graphical-editor/ladder/contact'
 import { BlockVariant } from '../../../../../_atoms/graphical-editor/types/block'
 import { CreateRung } from '../../../../../_molecules/graphical-editor/ladder/rung/create-rung'
 import { Rung } from '../../../../../_organisms/graphical-editor/ladder/rung'
-import { ladderSelectors } from '../../../../../../hooks/use-store-selectors'
-import { openPLCStoreBase, useOpenPLCStore } from '../../../../../../store'
-import { RungLadderState, zodLadderFlowSchema } from '../../../../../../store/slices/ladder'
-import { cn } from '../../../../../../utils/cn'
-import { useEffect, useRef, useState } from 'react'
-import { createPortal } from 'react-dom'
-import { v4 as uuidv4 } from 'uuid'
-
 import BlockElement from '../elements/ladder/block'
 import CoilElement from '../elements/ladder/coil'
 import ContactElement from '../elements/ladder/contact'
@@ -47,11 +48,24 @@ export default function LadderEditor() {
     editorActions: { saveEditorViewState },
     modalActions: { closeModal },
     sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
-    snapshotActions: { addSnapshot },
+    snapshotActions: { pushToHistory },
     libraries: { user: userLibraries },
     workspace: { isDebuggerVisible },
   } = useOpenPLCStore()
 
+  const captureSnapshot = useCallback(
+    (pouName: string): PouHistorySnapshot | null => {
+      const pou = pous.find((p) => p.name === pouName)
+      if (!pou) return null
+      return {
+        variables: pou.interface?.variables ?? [],
+        body: pou.body.value,
+        globalVariables: openPLCStoreBase.getState().project.data.configurations.resource.globalVariables,
+      }
+    },
+    [pous],
+  )
+
   const updateModelLadder = ladderSelectors.useUpdateModelLadder()
 
   const flow = ladderFlows.find((flow) => flow.name === editor.meta.name)
@@ -92,7 +106,11 @@ export default function LadderEditor() {
 
     ladderFlowActions.setFlowUpdated({ editorName: editor.meta.name, updated: false })
 
-    handleFileAndWorkspaceSavedState(editor.meta.name)
+    // During debug the editor is read-only — any flow update is from internal state
+    // management (e.g. node styling for debug indicators), not a user edit.
+    if (!isDebuggerVisible) {
+      handleFileAndWorkspaceSavedState(editor.meta.name)
+    }
   }, [flowUpdated])
 
   /**
@@ -137,7 +155,8 @@ export default function LadderEditor() {
   const handleAddNewRung = () => {
     if (isDebuggerVisible) return
 
-    addSnapshot(editor.meta.name)
+    const snapshot = captureSnapshot(editor.meta.name)
+    if (snapshot) pushToHistory(editor.meta.name, snapshot)
 
     const defaultViewport: [number, number] = [300, 100]
 
@@ -196,7 +215,8 @@ export default function LadderEditor() {
     auxRungs.splice(destinationIndex, 0, removed)
 
     try {
-      addSnapshot(editor.meta.name)
+      const snapshot = captureSnapshot(editor.meta.name)
+      if (snapshot) pushToHistory(editor.meta.name, snapshot)
       ladderFlowActions.setRungs({ editorName: editor.meta.name, rungs: auxRungs })
     } catch (error) {
       console.error('Failed to update rungs:', error)
@@ -257,11 +277,11 @@ export default function LadderEditor() {
         const libMatch = userLibraries.find((lib) => lib.name === variant.name && lib.type === variant.type)
         if (!libMatch) continue
 
-        const originalPou = pous.find((pou) => pou.data.name === libMatch.name)
+        const originalPou = pous.find((pou) => pou.name === libMatch.name)
         if (!originalPou) continue
 
-        const originalVariables = originalPou.data?.variables ?? []
-        const originalInOut = originalVariables?.filter((variable) =>
+        const originalVariables = originalPou.interface?.variables ?? []
+        const originalInOut = originalVariables.filter((variable) =>
           ['input', 'output', 'inOut'].includes(variable.class || ''),
         )
 
@@ -277,10 +297,10 @@ export default function LadderEditor() {
           type: { definition: string; value: string }
         }) => `${variable.name}|${variable.class}|${variable.type.definition}|${variable.type.value?.toLowerCase()}`
 
-        if (originalPou.type === 'function') {
+        if (originalPou.pouType === 'function') {
           const outVariable = variant.variables.find((v) => v.name === 'OUT')
           const outType = outVariable?.type?.value?.toUpperCase()
-          const returnType = originalPou.data.returnType?.toUpperCase()
+          const returnType = originalPou.interface?.returnType?.toUpperCase()
           if (!outType || !returnType || outType !== returnType) {
             divergences.push(`${rung.id}:${node.id}`)
             continue
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/ai-inline-completion-provider.ts b/src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/ai-inline-completion-provider.ts
similarity index 64%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/ai-inline-completion-provider.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/ai-inline-completion-provider.ts
index 9e261193e..70abf9126 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/ai-inline-completion-provider.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/ai-inline-completion-provider.ts
@@ -1,9 +1,11 @@
-import { openPLCStoreBase } from '../../../../../../store'
 import type * as monaco from 'monaco-editor'
+
+import type { AICompleteParams, AIPort } from '../../../../../../../middleware/shared/ports/ai-port'
+import { openPLCStoreBase } from '../../../../../../store'
 import { buildFIMContext } from './context-builder'
 
 // ---------------------------------------------------------------------------
-// Inline utilities (self-contained — AI services are web-only, not yet in src2)
+// Inline utilities
 // ---------------------------------------------------------------------------
 
 class CompletionCache<V> {
@@ -52,10 +54,6 @@ function hashString(str: string): string {
   return (hash >>> 0).toString(36)
 }
 
-// ---------------------------------------------------------------------------
-// Telemetry stubs — fire-and-forget, no-op when AI services are unavailable
-// ---------------------------------------------------------------------------
-
 type TelemetryTimer = { elapsed: () => number }
 
 function startTimer(): TelemetryTimer {
@@ -63,108 +61,6 @@ function startTimer(): TelemetryTimer {
   return { elapsed: () => Math.round(performance.now() - start) }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackCompletionRequested(_data: Record<string, unknown>): void {}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackCompletionShown(_data: Record<string, unknown>): void {}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackCompletionAccepted(_data: Record<string, unknown>): void {}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackCompletionDismissed(_data: Record<string, unknown>): void {}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackCompletionError(_data: Record<string, unknown>): void {}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function trackCompletionTimeout(_data: Record<string, unknown>): void {}
-
-// ---------------------------------------------------------------------------
-// AI request types & streaming (self-contained)
-// ---------------------------------------------------------------------------
-
-type AICompleteRequest = {
-  prefix: string
-  suffix: string
-  language: 'st' | 'il' | 'python' | 'cpp'
-  projectContext?: string
-  model?: 'haiku' | 'sonnet'
-  maxTokens?: number
-}
-
-class AIRequestError extends Error {
-  constructor(
-    message: string,
-    public readonly status: number,
-    public readonly retryAfter?: number,
-  ) {
-    super(message)
-    this.name = 'AIRequestError'
-  }
-}
-
-type AISSEEvent = { type: string; text?: string }
-
-function parseSSELine(line: string): AISSEEvent | null {
-  if (!line.startsWith('data: ')) return null
-  const data = line.slice(6)
-  if (data === '[DONE]') return { type: 'message_stop' }
-  try {
-    return JSON.parse(data) as AISSEEvent
-  } catch {
-    return null
-  }
-}
-
-async function* streamAIRequest(
-  endpoint: string,
-  body: AICompleteRequest,
-  signal?: AbortSignal,
-): AsyncGenerator<string, void, unknown> {
-  // Determine the base URL. In the web app, this comes from VITE_EDGE_API_URL.
-  // Falls back to a relative path if the env var is not set.
-  const envBase =
-    typeof import.meta !== 'undefined' && (import.meta as Record<string, Record<string, string>>).env?.VITE_EDGE_API_URL
-  const baseUrl = envBase ? `${envBase}/ai` : '/api/ai'
-
-  const response = await fetch(`${baseUrl}${endpoint}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    credentials: 'include',
-    body: JSON.stringify(body),
-    signal,
-  })
-
-  if (!response.ok) {
-    if (response.status === 429) {
-      const retryAfter = response.headers.get('Retry-After')
-      throw new AIRequestError('Rate limited. Please wait before trying again.', 429, retryAfter ? Number(retryAfter) : undefined)
-    }
-    throw new AIRequestError(`AI request failed: ${response.statusText}`, response.status)
-  }
-
-  const reader = response.body?.getReader()
-  if (!reader) return
-
-  const decoder = new TextDecoder()
-  let buffer = ''
-
-  while (true) {
-    const { done, value } = await reader.read()
-    if (done) break
-
-    buffer += decoder.decode(value, { stream: true })
-    const lines = buffer.split('\n')
-    buffer = lines.pop() ?? ''
-
-    for (const line of lines) {
-      const event = parseSSELine(line.trim())
-      if (!event) continue
-      if (event.type === 'message_stop') return
-      if (event.type === 'content_block_delta' && event.text) {
-        yield event.text
-      }
-    }
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Provider implementation
 // ---------------------------------------------------------------------------
@@ -183,7 +79,7 @@ type ShownCompletion = {
 
 /**
  * Monaco InlineCompletionsProvider powered by the AI backend.
- * Streams inline completions via SSE with caching, debouncing, and request cancellation.
+ * Streams inline completions via the AIPort with caching, debouncing, and request cancellation.
  */
 export class AIInlineCompletionProvider implements monaco.languages.InlineCompletionsProvider {
   private activeAbortController: AbortController | null = null
@@ -197,6 +93,7 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
   constructor(
     private readonly pouName: string,
     private readonly language: 'st' | 'il' | 'python' | 'cpp',
+    private readonly aiPort: AIPort,
   ) {}
 
   async provideInlineCompletions(
@@ -266,7 +163,7 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
     const timer = startTimer()
 
     try {
-      const request: AICompleteRequest = {
+      const request: AICompleteParams = {
         prefix: fimContext.prefix,
         suffix: fimContext.suffix,
         language: fimContext.language,
@@ -275,7 +172,7 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
         maxTokens: 256,
       }
 
-      trackCompletionRequested({
+      this.aiPort.sendTelemetry('completion_requested', {
         language: this.language,
         model: currentModel,
         prefixLength: request.prefix.length,
@@ -286,7 +183,7 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
       // 6a. Start client-side timeout
       const timeoutId = setTimeout(() => {
         this.activeAbortController?.abort()
-        trackCompletionTimeout({
+        this.aiPort.sendTelemetry('completion_timeout', {
           language: this.language,
           model: currentModel,
           timeoutMs: AIInlineCompletionProvider.TIMEOUT_MS,
@@ -295,7 +192,7 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
 
       let completion = ''
       let ttftMs = -1
-      for await (const chunk of streamAIRequest('/complete', request, signal)) {
+      for await (const chunk of this.aiPort.streamCompletion(request, signal)) {
         if (ttftMs < 0) {
           ttftMs = timer.elapsed()
           clearTimeout(timeoutId)
@@ -332,34 +229,23 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
     } catch (error) {
       if (error instanceof Error && error.name === 'AbortError') return emptyResult
 
-      if (error instanceof AIRequestError) {
-        trackCompletionError({
-          language: this.language,
-          model: currentModel,
-          errorType: 'api_error',
-          statusCode: error.status,
-          latencyMs: timer.elapsed(),
-        })
-        console.warn(`[AI Completion] ${error.status}: ${error.message}`)
-      } else {
-        trackCompletionError({
-          language: this.language,
-          model: currentModel,
-          errorType: error instanceof Error ? error.name : 'unknown',
-          latencyMs: timer.elapsed(),
-        })
-        console.warn('[AI Completion] Unexpected error:', error)
-      }
+      const statusCode = (error as { status?: number }).status
+      this.aiPort.sendTelemetry('completion_error', {
+        language: this.language,
+        model: currentModel,
+        errorType: statusCode ? 'api_error' : error instanceof Error ? error.name : 'unknown',
+        ...(statusCode !== undefined && { statusCode }),
+        latencyMs: timer.elapsed(),
+      })
+      console.warn('[AI Completion]', error instanceof Error ? error.message : error)
       return emptyResult
     }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   freeInlineCompletions(_completions: monaco.languages.InlineCompletions): void {
     this.trackAcceptOrDismiss()
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   disposeInlineCompletions(_completions: monaco.languages.InlineCompletions): void {
     this.trackAcceptOrDismiss()
   }
@@ -386,7 +272,7 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
       model,
       shownAt: performance.now(),
     }
-    trackCompletionShown({
+    this.aiPort.sendTelemetry('completion_shown', {
       language: this.language,
       model: openPLCStoreBase.getState().ai.model,
       completionLength: completionText.length,
@@ -410,12 +296,20 @@ export class AIInlineCompletionProvider implements monaco.languages.InlineComple
       const accepted = textAfterPosition.startsWith(text.split('\n')[0])
 
       if (accepted) {
-        trackCompletionAccepted({ language: this.language, completionLength: text.length })
+        this.aiPort.sendTelemetry('completion_accepted', { language: this.language, completionLength: text.length })
       } else {
-        trackCompletionDismissed({ language: this.language, completionLength: text.length, shownDurationMs })
+        this.aiPort.sendTelemetry('completion_dismissed', {
+          language: this.language,
+          completionLength: text.length,
+          shownDurationMs,
+        })
       }
     } catch {
-      trackCompletionDismissed({ language: this.language, completionLength: text.length, shownDurationMs })
+      this.aiPort.sendTelemetry('completion_dismissed', {
+        language: this.language,
+        completionLength: text.length,
+        shownDurationMs,
+      })
     }
   }
 
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/context-builder.ts b/src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/context-builder.ts
similarity index 93%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/context-builder.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/context-builder.ts
index 09abe56bf..a7e5af0c6 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/context-builder.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/context-builder.ts
@@ -1,6 +1,7 @@
-import { openPLCStoreBase } from '../../../../../../store'
 import type * as monaco from 'monaco-editor'
 
+import { openPLCStoreBase } from '../../../../../../store'
+
 /** Maximum characters to extract before cursor for FIM prefix */
 const MAX_PREFIX_CHARS = 3000
 /** Maximum characters to extract after cursor for FIM suffix */
@@ -27,9 +28,9 @@ function collectProjectContext(pouName: string, maxTokenBudget: number): string
   let approxTokens = 0
 
   for (const pou of pous) {
-    if (pou.data.name === pouName) continue
-    const header = `${pou.type} ${pou.data.name}`
-    const vars = pou.data.variables
+    if (pou.name === pouName) continue
+    const header = `${pou.pouType} ${pou.name}`
+    const vars = (pou.interface?.variables ?? [])
       .slice(0, 10)
       .map((v) => `  ${v.class ?? 'local'} ${v.name}: ${v.type.value}`)
       .join('\n')
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/index.ts b/src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/index.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/ai-completion/index.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/ai-completion/index.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-consent-modal.tsx b/src/frontend/components/_features/[workspace]/editor/monaco/ai-consent-modal.tsx
similarity index 93%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/ai-consent-modal.tsx
rename to src/frontend/components/_features/[workspace]/editor/monaco/ai-consent-modal.tsx
index 1938ce81c..fa7a67316 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-consent-modal.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/ai-consent-modal.tsx
@@ -1,5 +1,5 @@
-import { Modal, ModalContent, ModalTitle } from '../../../../_molecules/modal'
 import { useOpenPLCStore } from '../../../../../store'
+import { Modal, ModalContent, ModalTitle } from '../../../../_molecules/modal'
 
 const AIConsentModal = () => {
   const {
@@ -23,7 +23,7 @@ const AIConsentModal = () => {
 
   return (
     <Modal open={isOpen} onOpenChange={(open) => onOpenChange('ai-consent', open)}>
-      <ModalContent className='flex !inset-x-0 !top-1/2 !bottom-auto !h-auto w-[400px] !-translate-y-1/2 select-none flex-col gap-5 rounded-lg p-6'>
+      <ModalContent className='!inset-x-0 !bottom-auto !top-1/2 flex !h-auto w-[400px] !-translate-y-1/2 select-none flex-col gap-5 rounded-lg p-6'>
         <ModalTitle className='text-base font-semibold text-neutral-950 dark:text-white'>AI-Assisted Coding</ModalTitle>
 
         <div className='flex flex-col gap-3 text-sm text-neutral-600 dark:text-neutral-300'>
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/ai-status-indicator.tsx b/src/frontend/components/_features/[workspace]/editor/monaco/ai-status-indicator.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/ai-status-indicator.tsx
rename to src/frontend/components/_features/[workspace]/editor/monaco/ai-status-indicator.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts b/src/frontend/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts b/src/frontend/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
index 024ea5f27..9d99eeca7 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
@@ -1,8 +1,9 @@
-import type { VariableDTO } from '../../../../../../store/slices/project'
-import { PLCDataType, PLCStructureVariable } from '../../../../../../../middleware/shared/ports/types'
+import { PLCDataType, PLCStructureVariable } from '@root/middleware/shared/ports/types'
 import { escapeRegExp } from 'lodash'
 import * as monaco from 'monaco-editor'
 
+import type { VariableDTO } from '../../../../../../store/slices/project'
+
 interface DataTypeCompletionContext {
   isAfterDot: boolean
   instancePath: string[] // Changed: array to support multi-level like ["B", "J"]
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts b/src/frontend/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
similarity index 85%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
index 4cae311f5..f9f78004c 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
@@ -1,9 +1,10 @@
-import { StandardFunctionBlocks } from '../../../../../../data/library/standard-function-blocks'
-import type { VariableDTO } from '../../../../../../store/slices/project'
-import { PLCProject } from '../../../../../../../middleware/shared/ports/types'
+import { PLCProject } from '@root/middleware/shared/ports/types'
 import { escapeRegExp } from 'lodash'
 import * as monaco from 'monaco-editor'
 
+import { StandardFunctionBlocks } from '../../../../../../data/library/standard-function-blocks'
+import type { VariableDTO } from '../../../../../../store/slices/project'
+
 interface FBCompletionContext {
   isAfterDot: boolean
   instancePath: string[] // Changed: array to support multi-level
@@ -48,7 +49,7 @@ function analyzeContext(model: monaco.editor.ITextModel, position: monaco.IPosit
 function findFinalType(
   instancePath: string[],
   pouVariables: VariableDTO['data'][] = [],
-  customFBs: PLCProject['data']['pous'] = [],
+  customFBs: PLCProject['pous'] = [],
 ): { type: string; isStandard: boolean } | null {
   if (instancePath.length === 0) return null
 
@@ -82,10 +83,10 @@ function findFinalType(
     } else {
       // Check if it's a Custom FB
       const customFB = customFBs.find(
-        (fb) => fb.data.name.toUpperCase() === currentTypeName.toUpperCase() && fb.type === 'function-block',
+        (fb) => fb.name.toUpperCase() === currentTypeName.toUpperCase() && fb.pouType === 'function-block',
       )
       if (customFB) {
-        const field = customFB.data.variables.find(
+        const field = (customFB.interface?.variables ?? []).find(
           (v) => v.name === fieldName && (v.class === 'input' || v.class === 'output' || v.class === 'inOut'),
         )
         if (field && (field.type?.definition === 'derived' || field.type?.definition === 'user-data-type')) {
@@ -114,7 +115,7 @@ function findFBType(
   code: string,
   instanceName: string,
   pouVariables: VariableDTO['data'][] = [],
-  customFBs: PLCProject['data']['pous'] = [],
+  customFBs: PLCProject['pous'] = [],
 ): { type: string; isStandard: boolean } | null {
   // First, check in POU variables (from the store)
   const pouVariable = pouVariables.find((variable) => {
@@ -134,9 +135,9 @@ function findFBType(
     }
 
     // Check if it's a Custom FB
-    const customFB = customFBs.find((fb) => fb.data.name.toUpperCase() === typeName && fb.type === 'function-block')
+    const customFB = customFBs.find((fb) => fb.name.toUpperCase() === typeName && fb.pouType === 'function-block')
     if (customFB) {
-      return { type: customFB.data.name, isStandard: false }
+      return { type: customFB.name, isStandard: false }
     }
   }
 
@@ -154,9 +155,9 @@ function findFBType(
     }
 
     // Check Custom FBs
-    const customFB = customFBs.find((fb) => fb.data.name.toUpperCase() === typeName && fb.type === 'function-block')
+    const customFB = customFBs.find((fb) => fb.name.toUpperCase() === typeName && fb.pouType === 'function-block')
     if (customFB) {
-      return { type: customFB.data.name, isStandard: false }
+      return { type: customFB.name, isStandard: false }
     }
   }
 
@@ -197,16 +198,16 @@ function getStandardFBVariableSuggestions(
  */
 function getCustomFBVariableSuggestions(
   fbType: string,
-  customFBs: PLCProject['data']['pous'],
+  customFBs: PLCProject['pous'],
   range: monaco.IRange,
   editorName: string,
 ): monaco.languages.CompletionItem[] {
-  const functionBlock = customFBs.find((fb) => fb.data.name === fbType && fb.type === 'function-block')
+  const functionBlock = customFBs.find((fb) => fb.name === fbType && fb.pouType === 'function-block')
 
   if (!functionBlock) return []
 
   // Filter only public variables (Input, Output, InOut) - same as Standard FBs
-  const publicVariables = functionBlock.data.variables
+  const publicVariables = (functionBlock.interface?.variables ?? [])
     .filter((variable) => variable.class === 'input' || variable.class === 'output' || variable.class === 'inOut')
     .filter((variable) => variable.name !== editorName)
 
@@ -216,7 +217,7 @@ function getCustomFBVariableSuggestions(
     insertText: variable.name,
     detail: `${variable.type.value} (${variable.class})`,
     documentation: {
-      value: `**${variable.name}** - ${variable.class} variable\n\nType: \`${variable.type.value}\`\n\nCustom Function Block: ${fbType}\n\n${variable.documentation || functionBlock.data.documentation}`,
+      value: `**${variable.name}** - ${variable.class} variable\n\nType: \`${variable.type.value}\`\n\nCustom Function Block: ${fbType}\n\n${variable.documentation || functionBlock.documentation}`,
     },
     range,
     sortText: `${variable.class === 'input' ? '1' : variable.class === 'output' ? '2' : '3'}_${variable.name}`,
@@ -227,18 +228,19 @@ function getCustomFBVariableSuggestions(
  * Get custom function block instance suggestions (for direct FB calls)
  */
 function getCustomFBInstanceSuggestions(
-  customFBs: PLCProject['data']['pous'],
+  customFBs: PLCProject['pous'],
   range: monaco.IRange,
   editorName: string,
 ): monaco.languages.CompletionItem[] {
   return customFBs
-    .filter((fb) => fb.type === 'function-block')
-    .filter((fb) => fb.data.name !== editorName)
+    .filter((fb) => fb.pouType === 'function-block')
+    .filter((fb) => fb.name !== editorName)
     .map((fb) => {
-      const inputVars = fb.data.variables.filter((v) => v.class === 'input')
+      const variables = fb.interface?.variables ?? []
+      const inputVars = variables.filter((v) => v.class === 'input')
 
       // Generate snippet with input parameters
-      let snippet = `${fb.data.name}(`
+      let snippet = `${fb.name}(`
       if (inputVars.length > 0) {
         snippet += '\n'
         inputVars.forEach((input, index) => {
@@ -251,16 +253,16 @@ function getCustomFBInstanceSuggestions(
       snippet += ')'
 
       return {
-        label: fb.data.name,
+        label: fb.name,
         kind: monaco.languages.CompletionItemKind.Class,
         insertText: snippet,
         insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
         detail: `Custom Function Block`,
         documentation: {
-          value: `**${fb.data.name}** - Custom Function Block\n\n${fb.data.documentation || 'User-defined function block'}\n\n**Variables:**\n${fb.data.variables.map((v) => `- **${v.name}** (${v.class}): ${v.type.value}`).join('\n')}`,
+          value: `**${fb.name}** - Custom Function Block\n\n${fb.documentation || 'User-defined function block'}\n\n**Variables:**\n${variables.map((v) => `- **${v.name}** (${v.class}): ${v.type.value}`).join('\n')}`,
         },
         range,
-        sortText: `2_${fb.data.name}`, // Sort after standard FBs
+        sortText: `2_${fb.name}`, // Sort after standard FBs
       }
     })
 }
@@ -281,7 +283,7 @@ export const fbCompletion = ({
   range: monaco.IRange
   editorName: string
   pouVariables?: VariableDTO['data'][]
-  customFBs?: PLCProject['data']['pous']
+  customFBs?: PLCProject['pous']
 }) => {
   const context = analyzeContext(model, position)
   const code = model.getValue()
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/index.ts b/src/frontend/components/_features/[workspace]/editor/monaco/completion/index.ts
similarity index 94%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/completion/index.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/completion/index.ts
index 79343ea56..62edb2fee 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/index.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/completion/index.ts
@@ -1,9 +1,9 @@
-import type { EditorState } from '../../../../../../store/slices/editor'
-import type { LibraryState } from '../../../../../../store/slices/library'
-import { PLCVariable } from '../../../../../../../middleware/shared/ports/types'
-import { PLCProject } from '../../../../../../../middleware/shared/ports/types'
+import { PLCVariable } from '@root/middleware/shared/ports/types'
+import { PLCProject } from '@root/middleware/shared/ports/types'
 import * as monaco from 'monaco-editor'
 
+import type { EditorState } from '../../../../../../store/slices/editor'
+import type { LibraryState } from '../../../../../../store/slices/library'
 import { pythonSnippets } from '../configs/languages/python/python.snippets'
 import { stSnippets } from '../configs/languages/st/st.snippets'
 import { parsePouToStText } from '../drag-and-drop/st'
@@ -330,12 +330,12 @@ export const libraryCompletion = ({
 }: {
   range: monaco.IRange
   library: LibraryState['libraries']
-  pous: PLCProject['data']['pous']
+  pous: PLCProject['pous']
   editor: EditorState['editor']
 }) => {
   const systemSuggestions = library.system
     .filter((library) =>
-      pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+      pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
         ? library.pous.some((pou) => pou.type === 'function')
         : library.pous.some((pou) => pou),
     )
@@ -374,9 +374,10 @@ export const libraryCompletion = ({
       return userLibrary.name !== editor.meta.name
     })
     .flatMap((user) => {
-      const pou = pous.find((pou) => pou.data.name === user.name)
+      const pou = pous.find((pou) => pou.name === user.name)
       if (!pou) return []
 
+      const variables = pou.interface?.variables ?? []
       const data: {
         name: string
         language?: string
@@ -390,22 +391,22 @@ export const libraryCompletion = ({
         }[]
         extensible?: boolean
       } = {
-        name: pou.data.name,
-        type: pou.type,
-        variables: pou.data.variables.map((variable) => ({
+        name: pou.name,
+        type: pou.pouType,
+        variables: variables.map((variable) => ({
           name: variable.name,
           class: variable.class,
           type: { definition: variable.type.definition, value: variable.type.value.toUpperCase() },
         })),
-        documentation: pou.data.documentation,
+        documentation: pou.documentation,
         extensible: false,
       }
       const text = parsePouToStText(data)
 
       return {
-        label: pou.data.name,
+        label: pou.name,
         insertText: text,
-        documentation: pou.data.documentation,
+        documentation: pou.documentation,
         kind: monaco.languages.CompletionItemKind.Function,
         range,
       }
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/index.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/index.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/index.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/index.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
index cda15fc8a..42480a8df 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
@@ -1,5 +1,5 @@
 /* eslint-disable no-useless-escape */
-import { PLCDataType } from '../../../../../../../../../middleware/shared/ports/types'
+import { PLCDataType } from '@root/middleware/shared/ports/types'
 import { languages } from 'monaco-editor'
 
 type PLCEnumeratedDatatype = Extract<PLCDataType, { derivation: 'enumerated' }>
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts b/src/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts b/src/frontend/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/index.tsx b/src/frontend/components/_features/[workspace]/editor/monaco/index.tsx
similarity index 89%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/monaco/index.tsx
index 925614fa8..6532abb18 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/index.tsx
@@ -1,15 +1,20 @@
 import './configs'
 
 import { Editor as PrimitiveEditor } from '@monaco-editor/react'
-import { Modal, ModalContent, ModalTitle } from '../../../../_molecules/modal'
-import { openPLCStoreBase, useOpenPLCStore } from '../../../../../store'
-import type { PLCVariable, PLCPou } from '../../../../../../middleware/shared/ports/types'
-import { baseTypeSchema } from '../../../../../../middleware/shared/ports/plc-schemas'
-import { useCapabilities } from '../../../../../../middleware/shared/providers/platform-context'
 import * as monaco from 'monaco-editor'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
+import { baseTypeSchema } from '../../../../../../middleware/shared/ports/plc-schemas'
+import type { PLCPou } from '../../../../../../middleware/shared/ports/types'
+import { useAI, useCapabilities, useProject } from '../../../../../../middleware/shared/providers'
+import { openPLCStoreBase, useOpenPLCStore } from '../../../../../store'
+import { getExtensionFromLanguage, getFolderFromPouType } from '../../../../../utils/PLC/pou-file-extensions'
+import { parseHybridPouFromString, parseTextualPouFromString } from '../../../../../utils/PLC/pou-text-parser'
+import { Modal, ModalContent, ModalTitle } from '../../../../_molecules/modal'
 import { toast } from '../../../[app]/toast/use-toast'
+import { AIInlineCompletionProvider } from './ai-completion/ai-inline-completion-provider'
+import { AIConsentModal } from './ai-consent-modal'
+import { AIStatusIndicator } from './ai-status-indicator'
 import {
   arduinoApiCompletion,
   cppSignatureHelp,
@@ -31,9 +36,6 @@ import {
 import { parsePouToStText } from './drag-and-drop/st'
 import { cleanupPythonLSP, initPythonLSP, setupPythonLSPForEditor } from './python-lsp'
 import { applyThemeNow, ensureOpenplcThemes } from './theme-utils'
-import { AIInlineCompletionProvider } from './ai-completion/ai-inline-completion-provider'
-import { AIConsentModal } from './ai-consent-modal'
-import { AIStatusIndicator } from './ai-status-indicator'
 
 type monacoEditorProps = {
   path: string
@@ -59,29 +61,13 @@ type SnippetController = {
   insert: (snippet: string, options?: unknown) => void
 }
 
-// ---------------------------------------------------------------------------
-// File watcher bridge type (editor-only, accessed via window.bridge)
-// ---------------------------------------------------------------------------
-
-type FileWatcherBridge = {
-  fileWatchStart: (path: string) => Promise<{ success: boolean; error?: string }>
-  fileWatchStop: (path: string) => Promise<{ success: boolean }>
-  fileReadContent: (path: string) => Promise<{ success: boolean; content?: string; error?: string }>
-  onFileExternalChange: (
-    handler: (event: unknown, data: { filePath: string }) => void,
-  ) => () => void
-}
-
 // ---------------------------------------------------------------------------
 // Comment stripping (for debug variable position scanning)
 // ---------------------------------------------------------------------------
 
 type BlockCommentState = false | 'paren' | 'slash'
 
-function stripLineComments(
-  line: string,
-  state: BlockCommentState,
-): { stripped: string; state: BlockCommentState } {
+function stripLineComments(line: string, state: BlockCommentState): { stripped: string; state: BlockCommentState } {
   const chars = [...line]
   let i = 0
   let s = state
@@ -137,9 +123,13 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   const editorRef = useRef<null | monaco.editor.IStandaloneCodeEditor>(null)
   const monacoRef = useRef<null | typeof monaco>(null)
   const focusDisposables = useRef<{ onFocus?: monaco.IDisposable; onBlur?: monaco.IDisposable }>({})
+  const [editorMounted, setEditorMounted] = useState(false)
+  const [modelVersion, setModelVersion] = useState(0)
   const isSyncingModelRef = useRef(false)
 
   const capabilities = useCapabilities()
+  const aiPort = useAI()
+  const projectPort = useProject()
 
   const {
     editor,
@@ -262,41 +252,17 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     const currentProjectPath = openPLCStoreBase.getState().project.meta.path
     if (!currentProjectPath || !pou) return
 
-    const bridge = window.bridge as unknown as FileWatcherBridge
-    if (!bridge?.fileWatchStart) return
-
-    // Import dynamically to avoid bundling editor-only utils on web
-    let getExtensionFromLanguage: ((lang: string) => string) | null = null
-    let getFolderFromPouType: ((type: string) => string) | null = null
-    let parseTextualPouFromString: ((...args: unknown[]) => { data: { body: { value: unknown } } }) | null = null
-    let parseHybridPouFromString: ((...args: unknown[]) => { data: { body: { value: unknown } } }) | null = null
-
-    try {
-      // These utils exist in the editor's src/ tree; they're accessed at runtime only
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const pouExtensions = require('@root/utils/PLC/pou-file-extensions')
-      getExtensionFromLanguage = pouExtensions.getExtensionFromLanguage
-      getFolderFromPouType = pouExtensions.getFolderFromPouType
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const pouParser = require('@root/utils/PLC/pou-text-parser')
-      parseTextualPouFromString = pouParser.parseTextualPouFromString
-      parseHybridPouFromString = pouParser.parseHybridPouFromString
-    } catch {
-      // Not available in this platform
-      return
-    }
-
-    if (!getExtensionFromLanguage || !getFolderFromPouType) return
+    if (!projectPort.watchFile || !projectPort.onFileExternalChange) return
 
     const actualExtension = getExtensionFromLanguage(language)
     const pouFolder = getFolderFromPouType(pou.pouType)
     const fullPath = `${currentProjectPath}/pous/${pouFolder}/${name}${actualExtension}`
     watchedFilePathRef.current = fullPath
 
-    void bridge.fileWatchStart(fullPath)
+    void projectPort.watchFile(fullPath)
 
-    const handleExternalChange = (_event: unknown, data: { filePath: string }) => {
-      if (data.filePath !== watchedFilePathRef.current) return
+    const handleExternalChange = (filePath: string) => {
+      if (filePath !== watchedFilePathRef.current) return
 
       const isSaved = openPLCStoreBase.getState().fileActions.getSavedState({ name })
       if (isSaved) {
@@ -308,14 +274,14 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       if (!watchedFilePathRef.current) return
 
       try {
-        const result = await bridge.fileReadContent(watchedFilePathRef.current)
+        const result = await projectPort.readFileContent(watchedFilePathRef.current)
 
-        if (result.success && result.content && parseTextualPouFromString && parseHybridPouFromString) {
+        if (result.success && result.content) {
           const parsedPou =
             language === 'st' || language === 'il'
               ? parseTextualPouFromString(result.content, language, pou.pouType)
               : parseHybridPouFromString(result.content, language, pou.pouType)
-          const newBodyValue = typeof parsedPou.data.body.value === 'string' ? parsedPou.data.body.value : ''
+          const newBodyValue = typeof parsedPou.body.value === 'string' ? parsedPou.body.value : ''
 
           setLocalText(newBodyValue)
           updatePou({ name, content: { language, value: newBodyValue } })
@@ -325,17 +291,29 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       }
     }
 
-    const cleanup = bridge.onFileExternalChange(handleExternalChange)
+    const cleanup = projectPort.onFileExternalChange(handleExternalChange)
 
     return () => {
       cleanup()
       if (watchedFilePathRef.current) {
-        void bridge.fileWatchStop(watchedFilePathRef.current)
+        void projectPort.unwatchFile?.(watchedFilePathRef.current)
         watchedFilePathRef.current = null
       }
     }
   }, [pou?.pouType, name, language, capabilities.hasFileWatcher])
 
+  // Track when @monaco-editor/react switches models (tab changes with keepCurrentModel).
+  // onMount only fires once on initial mount, so we use onDidChangeModel to detect when the
+  // model has actually switched, then bump modelVersion to trigger debugVarPositions recomputation.
+  useEffect(() => {
+    const editor = editorRef.current
+    if (!editor) return
+    const disposable = editor.onDidChangeModel(() => {
+      setModelVersion((v) => v + 1)
+    })
+    return () => disposable.dispose()
+  }, [editorMounted])
+
   // Update readOnly when debugger visibility changes (editor-only)
   useEffect(() => {
     editorRef.current?.updateOptions({ readOnly: isDebuggerVisible })
@@ -361,11 +339,17 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   }, [debugVariableValues])
 
   const debugVarPositions = useMemo(() => {
-    if (!isDebuggerVisible || !editorRef.current || (language !== 'st' && language !== 'il')) return null
+    if (!isDebuggerVisible || !editorRef.current || !monacoRef.current || (language !== 'st' && language !== 'il'))
+      return null
 
     const model = editorRef.current.getModel()
     if (!model) return null
 
+    // Guard: ensure the model matches the current POU. During tab switches the memo may
+    // fire before @monaco-editor/react has swapped the model, so we'd scan the wrong file.
+    const expectedUri = monacoRef.current.Uri.file(uniqueMonacoPath).toString()
+    if (model.uri.toString() !== expectedUri) return null
+
     const prefix = fbInstanceContext
       ? `${fbInstanceContext.programName}:${fbInstanceContext.fbVariableName}.`
       : `${name}:`
@@ -406,7 +390,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     }
 
     return { prefix, positions }
-  }, [isDebuggerVisible, debugVarKeySet, language, name, fbInstanceContext])
+  }, [isDebuggerVisible, debugVarKeySet, language, name, fbInstanceContext, editorMounted, modelVersion])
 
   useEffect(() => {
     if (!debugVarPositions || !editorRef.current) return
@@ -434,7 +418,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     (range: monaco.IRange) => {
       const suggestions = tableVariablesCompletion({
         range,
-        variables: pouVariables as PLCVariable[],
+        variables: pouVariables,
       }).suggestions
       const uniqueSuggestions = Array.from(new Map(suggestions.map((s) => [s.label, s])).values())
       const labels = uniqueSuggestions.map((suggestion) => suggestion.label)
@@ -447,7 +431,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     (range: monaco.IRange) => {
       const suggestions = tableGlobalVariablesCompletion({
         range,
-        variables: globalVariables as PLCVariable[],
+        variables: globalVariables,
       }).suggestions
       const uniqueSuggestions = Array.from(new Map(suggestions.map((s) => [s.label, s])).values())
       const labels = uniqueSuggestions.map((suggestion) => suggestion.label)
@@ -468,7 +452,6 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       const labels = uniqueSuggestions.map((suggestion) => suggestion.label)
       return { suggestions: uniqueSuggestions, labels }
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [sliceLibraries],
   )
 
@@ -488,7 +471,6 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       const labels = uniqueSuggestions.map((suggestion) => suggestion.label)
       return { suggestions: uniqueSuggestions, labels }
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [pouVariables, pous],
   )
 
@@ -655,7 +637,6 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       },
     })
     return () => disposable.dispose()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pouVariables, globalVariables, sliceLibraries, language, snippetsSTSuggestions])
 
   // -----------------------------------------------------------------------
@@ -761,14 +742,16 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       return
     }
 
-    const provider = new AIInlineCompletionProvider(name, language)
+    if (!aiPort) return
+
+    const provider = new AIInlineCompletionProvider(name, language, aiPort)
     const disposable = monaco.languages.registerInlineCompletionsProvider(language, provider)
 
     return () => {
       disposable.dispose()
       provider.dispose()
     }
-  }, [name, language, aiState.isEnabled, aiState.hasConsented, modalActions, capabilities.hasAIAssistant])
+  }, [name, language, aiState.isEnabled, aiState.hasConsented, modalActions, capabilities.hasAIAssistant, aiPort])
 
   // -----------------------------------------------------------------------
   // Theme management
@@ -782,7 +765,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   useEffect(() => {
     const monacoInstance = monacoRef.current
     if (!monacoInstance) return
-    applyThemeNow(monacoInstance)
+    applyThemeNow(monacoInstance, shouldUseDarkMode)
   }, [shouldUseDarkMode])
 
   // -----------------------------------------------------------------------
@@ -795,6 +778,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   ) {
     editorRef.current = editorInstance
     monacoRef.current = monacoInstance
+    setEditorMounted(true)
 
     if (!editorInstance || !monacoInstance) return
 
@@ -822,11 +806,12 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     })
 
     // Apply theme
+    const isDark = openPLCStoreBase.getState().workspace.systemConfigs.shouldUseDarkMode
     if (!didApplyInitialTheme) {
-      applyThemeNow(monacoInstance)
+      applyThemeNow(monacoInstance, isDark)
       didApplyInitialTheme = true
     } else {
-      applyThemeNow(monacoInstance)
+      applyThemeNow(monacoInstance, isDark)
     }
 
     // Check for external file changes on mount (editor-only)
@@ -842,24 +827,18 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
         if (!currentProjectPath) return
 
         try {
-          // eslint-disable-next-line @typescript-eslint/no-require-imports
-          const { getExtensionFromLanguage, getFolderFromPouType } = require('@root/utils/PLC/pou-file-extensions')
-          // eslint-disable-next-line @typescript-eslint/no-require-imports
-          const { parseTextualPouFromString, parseHybridPouFromString } = require('@root/utils/PLC/pou-text-parser')
-
           const actualExtension = getExtensionFromLanguage(language)
           const pouFolder = getFolderFromPouType(currentPou.pouType)
           const fullPath = `${currentProjectPath}/pous/${pouFolder}/${name}${actualExtension}`
 
-          const bridge = window.bridge as unknown as FileWatcherBridge
-          const result = await bridge.fileReadContent(fullPath)
+          const result = await projectPort.readFileContent(fullPath)
 
           if (result.success && result.content) {
             const parsedPou =
               language === 'st' || language === 'il'
                 ? parseTextualPouFromString(result.content, language, currentPou.pouType)
                 : parseHybridPouFromString(result.content, language, currentPou.pouType)
-            const newBodyValue = typeof parsedPou.data.body.value === 'string' ? parsedPou.data.body.value : ''
+            const newBodyValue = typeof parsedPou.body.value === 'string' ? parsedPou.body.value : ''
 
             const currentBodyValue = typeof currentPou.body.value === 'string' ? currentPou.body.value : ''
             if (newBodyValue !== currentBodyValue) {
@@ -902,13 +881,17 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       injectCppTemplateIfNeeded(editorInstance, pou, name)
     }
 
-    // Keyboard shortcuts: Ctrl+S, Ctrl+Shift+S
+    // Keyboard shortcuts: Ctrl+S (save project), Ctrl+Shift+S (save project)
     editorInstance.addCommand(monacoInstance.KeyMod.CtrlCmd | monacoInstance.KeyCode.KeyS, () => {
-      if (editingState !== 'save-request' && name) {
-        const sharedActions = openPLCStoreBase.getState().sharedWorkspaceActions
-        if ('saveFile' in sharedActions) {
-          void (sharedActions as { saveFile: (name: string) => Promise<void> }).saveFile(name)
-        }
+      if (editingState !== 'save-request') {
+        const state = openPLCStoreBase.getState()
+        void projectPort.saveProject({
+          projectPath: state.project.meta.path,
+          projectName: state.project.meta.name,
+          projectData: state.project.data,
+          deviceConfiguration: state.deviceDefinitions.configuration,
+          devicePinMapping: state.deviceDefinitions.pinMapping.pins,
+        })
       }
     })
 
@@ -916,10 +899,14 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
       monacoInstance.KeyMod.CtrlCmd | monacoInstance.KeyMod.Shift | monacoInstance.KeyCode.KeyS,
       () => {
         if (editingState !== 'save-request') {
-          const sharedActions = openPLCStoreBase.getState().sharedWorkspaceActions
-          if ('saveProject' in sharedActions) {
-            void (sharedActions as { saveProject: () => Promise<void> }).saveProject()
-          }
+          const state = openPLCStoreBase.getState()
+          void projectPort.saveProject({
+            projectPath: state.project.meta.path,
+            projectName: state.project.meta.name,
+            projectData: state.project.data,
+            deviceConfiguration: state.deviceDefinitions.configuration,
+            devicePinMapping: state.deviceDefinitions.pinMapping.pins,
+          })
         }
       },
     )
@@ -957,7 +944,12 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
           if (!position) return
           editorInstance.executeEdits('ai-chat-insert', [
             {
-              range: new monacoInstance.Range(position.lineNumber, position.column, position.lineNumber, position.column),
+              range: new monacoInstance.Range(
+                position.lineNumber,
+                position.column,
+                position.lineNumber,
+                position.column,
+              ),
               text: code,
             },
           ])
@@ -982,7 +974,11 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   // Template injection
   // -----------------------------------------------------------------------
 
-  function injectPythonTemplateIfNeeded(editorInst: monaco.editor.IStandaloneCodeEditor, pouObj: PLCPou, pouName: string) {
+  function injectPythonTemplateIfNeeded(
+    editorInst: monaco.editor.IStandaloneCodeEditor,
+    pouObj: PLCPou,
+    pouName: string,
+  ) {
     const editorModel = editorInst.getModel()
     if (!editorModel) return
 
@@ -1110,6 +1106,9 @@ void loop()
 
     setLocalText(value)
     if (isSyncingModelRef.current) return
+    // During debug the editor is read-only — any onChange event is a false positive
+    // from Monaco's internal state management (e.g. model sync), not a user edit.
+    if (isDebuggerVisible) return
     handleFileAndWorkspaceSavedState(name)
     updatePou({ name, content: { language, value } })
   }
@@ -1279,7 +1278,6 @@ void loop()
     )
 
     return () => unsub()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   // -----------------------------------------------------------------------
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/python-lsp/index.ts b/src/frontend/components/_features/[workspace]/editor/monaco/python-lsp/index.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/python-lsp/index.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/python-lsp/index.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/theme-utils.ts b/src/frontend/components/_features/[workspace]/editor/monaco/theme-utils.ts
similarity index 86%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/theme-utils.ts
rename to src/frontend/components/_features/[workspace]/editor/monaco/theme-utils.ts
index b1af1f002..f2b308a06 100644
--- a/src2/frontend/components/_features/[workspace]/editor/monaco/theme-utils.ts
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/theme-utils.ts
@@ -1,4 +1,5 @@
 import type * as monaco from 'monaco-editor'
+
 import { darkThemeData, lightThemeData } from './configs/themes/openplc/openplc'
 
 const instancesWithOpenplcThemes = new WeakSet<object>()
@@ -26,12 +27,11 @@ export function ensureOpenplcThemes(monacoInstance: typeof monaco) {
 
 /**
  * Applies the correct theme to the Monaco instance based on the current app theme.
- * Uses the DOM as the source of truth for the current theme state.
  *
  * @param monacoInstance - The Monaco instance to apply the theme to
+ * @param isDark - Whether dark mode is active (from the Zustand store)
  */
-export function applyThemeNow(monacoInstance: typeof monaco) {
-  const isDark = document.documentElement.classList.contains('dark')
+export function applyThemeNow(monacoInstance: typeof monaco, isDark: boolean) {
   const themeName = isDark ? 'openplc-dark' : 'openplc-light'
   monacoInstance.editor.setTheme(themeName)
 }
diff --git a/src2/frontend/components/_features/[workspace]/editor/resource-editor/index.tsx b/src/frontend/components/_features/[workspace]/editor/resource-editor/index.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/resource-editor/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/resource-editor/index.tsx
diff --git a/src2/frontend/components/_features/[workspace]/editor/search-in-project/index.tsx b/src/frontend/components/_features/[workspace]/editor/search-in-project/index.tsx
similarity index 93%
rename from src2/frontend/components/_features/[workspace]/editor/search-in-project/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/search-in-project/index.tsx
index dce874443..d23cdc8f1 100644
--- a/src2/frontend/components/_features/[workspace]/editor/search-in-project/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/search-in-project/index.tsx
@@ -1,10 +1,10 @@
 import * as Checkbox from '@radix-ui/react-checkbox'
 import { CheckIcon } from '@radix-ui/react-icons'
-import { InputWithRef } from '../../../../_atoms/input'
-import { useOpenPLCStore } from '../../../../../store'
 import { useEffect, useState } from 'react'
 import { v4 as uuidv4 } from 'uuid'
 
+import { useOpenPLCStore } from '../../../../../store'
+import { InputWithRef } from '../../../../_atoms/input'
 import { useToast } from '../../../[app]/toast/use-toast'
 
 type OptionProps = {
@@ -205,15 +205,16 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
 
     const groupedPous = data.pous
       .filter((pou) => {
-        const pouTypeMatchesFilter = activeFilters.length === 0 || activeFilters.includes(pou.type)
+        const pouTypeMatchesFilter = activeFilters.length === 0 || activeFilters.includes(pou.pouType)
 
         const pouMatches = regularExpressionOption
-          ? countOccurrences(pou.data.name, searchQuery, sensitiveCaseOption, regularExpressionOption) > 0
+          ? countOccurrences(pou.name, searchQuery, sensitiveCaseOption, regularExpressionOption) > 0
           : sensitiveCaseOption
-            ? pou.data.name.includes(searchQuery)
-            : pou.data.name.toLowerCase().includes(searchQuery.toLowerCase())
+            ? pou.name.includes(searchQuery)
+            : pou.name.toLowerCase().includes(searchQuery.toLowerCase())
 
-        const variableMatches = pou.data.variables.some((variable) =>
+        const pouVariables = pou.interface?.variables ?? []
+        const variableMatches = pouVariables.some((variable) =>
           regularExpressionOption
             ? countOccurrences(variable.name, searchQuery, sensitiveCaseOption, regularExpressionOption) > 0
             : sensitiveCaseOption
@@ -225,11 +226,11 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
           pouTypeMatchesFilter &&
           (pouMatches ||
             variableMatches ||
-            (['st', 'il'].includes(pou.data.language) &&
+            (['st', 'il'].includes(pou.body.language) &&
               (() => {
                 try {
                   const regex = new RegExp(searchQuery, sensitiveCaseOption ? 'g' : 'gi')
-                  const matches = (pou.data.body.value as string).match(regex)
+                  const matches = (pou.body.value as string).match(regex)
                   return matches ? matches.length > 0 : false
                 } catch (error) {
                   console.error('Invalid regex or error processing body:', error)
@@ -240,22 +241,23 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
       })
       .reduce(
         (acc, pou) => {
-          const pouType = pou.type
+          const pouType = pou.pouType
 
           if (!acc[pouType]) {
             acc[pouType] = []
           }
 
+          const pouVariables = pou.interface?.variables ?? []
           acc[pouType].push({
-            name: pou.data.name,
-            language: pou.data.language,
-            pouType: pou.type,
+            name: pou.name,
+            language: pou.body.language as 'ld' | 'sfc' | 'fbd' | 'il' | 'st' | 'python' | 'cpp',
+            pouType: pou.pouType,
             body:
-              (['st', 'il'].includes(pou.data.language) &&
+              (['st', 'il'].includes(pou.body.language) &&
                 (() => {
                   try {
                     const regex = new RegExp(`\\b(${searchQuery}\\w*)`, sensitiveCaseOption ? 'g' : 'gi')
-                    const matches = (pou.data.body.value as string).match(regex)
+                    const matches = (pou.body.value as string).match(regex)
                     return matches ? matches.join(', ') : ''
                   } catch (error) {
                     console.error('Invalid regex or error processing body:', error)
@@ -263,7 +265,7 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
                   }
                 })()) ||
               '',
-            variable: pou.data.variables
+            variable: pouVariables
               .filter((variable) =>
                 regularExpressionOption
                   ? countOccurrences(variable.name, searchQuery, sensitiveCaseOption, regularExpressionOption) > 0
@@ -307,7 +309,7 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
         type: dataType.derivation,
       }))
 
-    const resourceGlobalVar = data.configuration.resource.globalVariables.filter((variable) => {
+    const resourceGlobalVar = data.configurations.resource.globalVariables.filter((variable) => {
       const resourceMatchesFilter = activeFilters.length === 0 || activeFilters.includes('configuration')
       return (
         resourceMatchesFilter &&
@@ -319,7 +321,7 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
       )
     })
 
-    const resourceTasks = data.configuration.resource.tasks.filter((task) => {
+    const resourceTasks = data.configurations.resource.tasks.filter((task) => {
       const resourceMatchesFilter = activeFilters.length === 0 || activeFilters.includes('configuration')
       return (
         resourceMatchesFilter &&
@@ -331,7 +333,7 @@ export default function SearchInProject({ onClose }: SearchInProjectModalProps)
       )
     })
 
-    const resourceInstances = data.configuration.resource.instances.filter((instance) => {
+    const resourceInstances = data.configurations.resource.instances.filter((instance) => {
       const resourceMatchesFilter = activeFilters.length === 0 || activeFilters.includes('configuration')
       return (
         resourceMatchesFilter &&
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/modbus-server/address-mapping-reference.tsx b/src/frontend/components/_features/[workspace]/editor/server/modbus-server/address-mapping-reference.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/server/modbus-server/address-mapping-reference.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/modbus-server/address-mapping-reference.tsx
index faf8701ff..a9f09b1d6 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/modbus-server/address-mapping-reference.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/modbus-server/address-mapping-reference.tsx
@@ -1,10 +1,11 @@
 import * as CollapsiblePrimitive from '@radix-ui/react-collapsible'
 import { ChevronDownIcon } from '@radix-ui/react-icons'
-import { cn } from '../../../../../../utils/cn'
 import { useMemo, useState } from 'react'
 
+import { cn } from '../../../../../../utils/cn'
+
 // ---------------------------------------------------------------------------
-// Types (self-contained — modbus utils not yet migrated to src2)
+// Types (self-contained — modbus utils not yet migrated)
 // ---------------------------------------------------------------------------
 
 interface ModbusSlaveBufferMapping {
@@ -325,4 +326,4 @@ const AddressMappingReference = ({ bufferMapping, defaultExpanded = false }: Add
 }
 
 export { AddressMappingReference }
-export type { ModbusSlaveBufferMapping, AddressMappingRow, AddressMappingSection }
+export type { AddressMappingRow, AddressMappingSection, ModbusSlaveBufferMapping }
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/modbus-server/index.tsx b/src/frontend/components/_features/[workspace]/editor/server/modbus-server/index.tsx
similarity index 80%
rename from src2/frontend/components/_features/[workspace]/editor/server/modbus-server/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/modbus-server/index.tsx
index fb85bad01..1a514dcc0 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/modbus-server/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/modbus-server/index.tsx
@@ -1,12 +1,14 @@
 import * as AccordionPrimitive from '@radix-ui/react-accordion'
 import { ChevronDownIcon } from '@radix-ui/react-icons'
-import { InputWithRef } from '../../../../../_atoms/input'
-import { Label } from '../../../../../_atoms/label'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../_atoms/select'
+import type { ModbusBufferMapping } from '@root/middleware/shared/ports/types'
+import { forwardRef, useCallback, useEffect, useMemo, useState } from 'react'
+
 import { useOpenPLCStore } from '../../../../../../store'
 import { cn } from '../../../../../../utils/cn'
 import { DEFAULT_BUFFER_MAPPING } from '../../../../../../utils/modbus/generate-modbus-slave-config'
-import { forwardRef, useCallback, useEffect, useMemo, useState } from 'react'
+import { InputWithRef } from '../../../../../_atoms/input'
+import { Label } from '../../../../../_atoms/label'
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../_atoms/select'
 
 const DEFAULT_NETWORK_INTERFACE_OPTIONS = [
   { value: '0.0.0.0', label: 'All Interfaces (0.0.0.0)' },
@@ -135,16 +137,27 @@ const ModbusServerEditor = () => {
   const [iwCount, setIwCount] = useState(DEFAULT_BUFFER_MAPPING.inputRegisters.iwCount.toString())
 
   // Helper function to reset buffer mapping state to defaults or provided values
-  const setBufferMappingState = useCallback((bufferMapping: typeof DEFAULT_BUFFER_MAPPING = DEFAULT_BUFFER_MAPPING) => {
-    setQwCount(bufferMapping.holdingRegisters.qwCount.toString())
-    setMwCount(bufferMapping.holdingRegisters.mwCount.toString())
-    setMdCount(bufferMapping.holdingRegisters.mdCount.toString())
-    setMlCount(bufferMapping.holdingRegisters.mlCount.toString())
-    setQxBits(bufferMapping.coils.qxBits.toString())
-    setMxBits(bufferMapping.coils.mxBits.toString())
-    setIxBits(bufferMapping.discreteInputs.ixBits.toString())
-    setIwCount(bufferMapping.inputRegisters.iwCount.toString())
-  }, [])
+  const setBufferMappingState = useCallback(
+    (bufferMapping: ModbusBufferMapping | typeof DEFAULT_BUFFER_MAPPING = DEFAULT_BUFFER_MAPPING) => {
+      setQwCount(
+        (bufferMapping.holdingRegisters?.qwCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.qwCount).toString(),
+      )
+      setMwCount(
+        (bufferMapping.holdingRegisters?.mwCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.mwCount).toString(),
+      )
+      setMdCount(
+        (bufferMapping.holdingRegisters?.mdCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.mdCount).toString(),
+      )
+      setMlCount(
+        (bufferMapping.holdingRegisters?.mlCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.mlCount).toString(),
+      )
+      setQxBits((bufferMapping.coils?.qxBits ?? DEFAULT_BUFFER_MAPPING.coils.qxBits).toString())
+      setMxBits((bufferMapping.coils?.mxBits ?? DEFAULT_BUFFER_MAPPING.coils.mxBits).toString())
+      setIxBits((bufferMapping.discreteInputs?.ixBits ?? DEFAULT_BUFFER_MAPPING.discreteInputs.ixBits).toString())
+      setIwCount((bufferMapping.inputRegisters?.iwCount ?? DEFAULT_BUFFER_MAPPING.inputRegisters.iwCount).toString())
+    },
+    [],
+  )
 
   // Accordion state
   const [openSections, setOpenSections] = useState<string[]>(['holding-registers'])
@@ -213,56 +226,56 @@ const ModbusServerEditor = () => {
     'holdingRegisters',
     'qwCount',
     qwCount,
-    bufferMapping.holdingRegisters.qwCount,
+    bufferMapping.holdingRegisters?.qwCount,
     MAX_REGISTER_COUNT,
   )
   const handleMwCountBlur = createBufferMappingHandler(
     'holdingRegisters',
     'mwCount',
     mwCount,
-    bufferMapping.holdingRegisters.mwCount,
+    bufferMapping.holdingRegisters?.mwCount,
     MAX_REGISTER_COUNT,
   )
   const handleMdCountBlur = createBufferMappingHandler(
     'holdingRegisters',
     'mdCount',
     mdCount,
-    bufferMapping.holdingRegisters.mdCount,
+    bufferMapping.holdingRegisters?.mdCount,
     MAX_REGISTER_COUNT,
   )
   const handleMlCountBlur = createBufferMappingHandler(
     'holdingRegisters',
     'mlCount',
     mlCount,
-    bufferMapping.holdingRegisters.mlCount,
+    bufferMapping.holdingRegisters?.mlCount,
     MAX_REGISTER_COUNT,
   )
   const handleQxBitsBlur = createBufferMappingHandler(
     'coils',
     'qxBits',
     qxBits,
-    bufferMapping.coils.qxBits,
+    bufferMapping.coils?.qxBits,
     MAX_BIT_COUNT,
   )
   const handleMxBitsBlur = createBufferMappingHandler(
     'coils',
     'mxBits',
     mxBits,
-    bufferMapping.coils.mxBits,
+    bufferMapping.coils?.mxBits,
     MAX_BIT_COUNT,
   )
   const handleIxBitsBlur = createBufferMappingHandler(
     'discreteInputs',
     'ixBits',
     ixBits,
-    bufferMapping.discreteInputs.ixBits,
+    bufferMapping.discreteInputs?.ixBits,
     MAX_BIT_COUNT,
   )
   const handleIwCountBlur = createBufferMappingHandler(
     'inputRegisters',
     'iwCount',
     iwCount,
-    bufferMapping.inputRegisters.iwCount,
+    bufferMapping.inputRegisters?.iwCount,
     MAX_REGISTER_COUNT,
   )
 
@@ -383,10 +396,38 @@ const ModbusServerEditor = () => {
               </AccordionTrigger>
               <AccordionContent>
                 <div className='flex flex-col gap-3'>
-                  <BufferInput label='%QW' value={qwCount} onChange={setQwCount} onBlur={handleQwCountBlur} max={MAX_REGISTER_COUNT} description='Integer outputs' />
-                  <BufferInput label='%MW' value={mwCount} onChange={setMwCount} onBlur={handleMwCountBlur} max={MAX_REGISTER_COUNT} description='Integer memory' />
-                  <BufferInput label='%MD' value={mdCount} onChange={setMdCount} onBlur={handleMdCountBlur} max={MAX_REGISTER_COUNT} description='Double integer memory (2 regs each)' />
-                  <BufferInput label='%ML' value={mlCount} onChange={setMlCount} onBlur={handleMlCountBlur} max={MAX_REGISTER_COUNT} description='Long integer memory (4 regs each)' />
+                  <BufferInput
+                    label='%QW'
+                    value={qwCount}
+                    onChange={setQwCount}
+                    onBlur={handleQwCountBlur}
+                    max={MAX_REGISTER_COUNT}
+                    description='Integer outputs'
+                  />
+                  <BufferInput
+                    label='%MW'
+                    value={mwCount}
+                    onChange={setMwCount}
+                    onBlur={handleMwCountBlur}
+                    max={MAX_REGISTER_COUNT}
+                    description='Integer memory'
+                  />
+                  <BufferInput
+                    label='%MD'
+                    value={mdCount}
+                    onChange={setMdCount}
+                    onBlur={handleMdCountBlur}
+                    max={MAX_REGISTER_COUNT}
+                    description='Double integer memory (2 regs each)'
+                  />
+                  <BufferInput
+                    label='%ML'
+                    value={mlCount}
+                    onChange={setMlCount}
+                    onBlur={handleMlCountBlur}
+                    max={MAX_REGISTER_COUNT}
+                    description='Long integer memory (4 regs each)'
+                  />
                 </div>
               </AccordionContent>
             </AccordionItem>
@@ -398,8 +439,22 @@ const ModbusServerEditor = () => {
               </AccordionTrigger>
               <AccordionContent>
                 <div className='flex flex-col gap-3'>
-                  <BufferInput label='%QX' value={qxBits} onChange={setQxBits} onBlur={handleQxBitsBlur} max={MAX_BIT_COUNT} description='Boolean outputs' />
-                  <BufferInput label='%MX' value={mxBits} onChange={setMxBits} onBlur={handleMxBitsBlur} max={MAX_BIT_COUNT} description='Boolean memory' />
+                  <BufferInput
+                    label='%QX'
+                    value={qxBits}
+                    onChange={setQxBits}
+                    onBlur={handleQxBitsBlur}
+                    max={MAX_BIT_COUNT}
+                    description='Boolean outputs'
+                  />
+                  <BufferInput
+                    label='%MX'
+                    value={mxBits}
+                    onChange={setMxBits}
+                    onBlur={handleMxBitsBlur}
+                    max={MAX_BIT_COUNT}
+                    description='Boolean memory'
+                  />
                 </div>
               </AccordionContent>
             </AccordionItem>
@@ -411,7 +466,14 @@ const ModbusServerEditor = () => {
               </AccordionTrigger>
               <AccordionContent>
                 <div className='flex flex-col gap-3'>
-                  <BufferInput label='%IX' value={ixBits} onChange={setIxBits} onBlur={handleIxBitsBlur} max={MAX_BIT_COUNT} description='Boolean inputs' />
+                  <BufferInput
+                    label='%IX'
+                    value={ixBits}
+                    onChange={setIxBits}
+                    onBlur={handleIxBitsBlur}
+                    max={MAX_BIT_COUNT}
+                    description='Boolean inputs'
+                  />
                 </div>
               </AccordionContent>
             </AccordionItem>
@@ -423,7 +485,14 @@ const ModbusServerEditor = () => {
               </AccordionTrigger>
               <AccordionContent>
                 <div className='flex flex-col gap-3'>
-                  <BufferInput label='%IW' value={iwCount} onChange={setIwCount} onBlur={handleIwCountBlur} max={MAX_REGISTER_COUNT} description='Integer inputs' />
+                  <BufferInput
+                    label='%IW'
+                    value={iwCount}
+                    onChange={setIwCount}
+                    onBlur={handleIwCountBlur}
+                    max={MAX_REGISTER_COUNT}
+                    description='Integer inputs'
+                  />
                 </div>
               </AccordionContent>
             </AccordionItem>
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
index 2383dca7c..7b95fad79 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
@@ -1,9 +1,9 @@
-import { InputWithRef } from '../../../../../../_atoms/input'
-import { Label } from '../../../../../../_atoms/label'
-import { useOpenPLCStore } from '../../../../../../../store'
-import type { OpcUaNodeConfig, OpcUaServerConfig } from '../../../../../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '@root/frontend/store'
+import type { OpcUaNodeConfig, OpcUaServerConfig } from '@root/middleware/shared/ports/types'
 import { useCallback, useMemo, useState } from 'react'
 
+import { InputWithRef } from '../../../../../../_atoms/input'
+import { Label } from '../../../../../../_atoms/label'
 import {
   findTreeNodeById,
   getSelectableDescendantIds,
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
index 09907e423..bf4712671 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
@@ -1,9 +1,10 @@
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaTrustedCertificate } from '@root/middleware/shared/ports/types'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
 import { InputWithRef } from '../../../../../../_atoms/input'
 import { Label } from '../../../../../../_atoms/label'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../../../../../../_molecules/modal'
-import type { OpcUaTrustedCertificate } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
-import { useCallback, useEffect, useMemo, useState } from 'react'
 
 interface CertificateModalProps {
   isOpen: boolean
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
index df4d37755..b8974c6fe 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
@@ -1,10 +1,10 @@
-import { Label } from '../../../../../../_atoms/label'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
-import { useOpenPLCStore } from '../../../../../../../store'
-import type { OpcUaServerConfig, OpcUaTrustedCertificate } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
+import { useOpenPLCStore } from '@root/frontend/store'
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaServerConfig, OpcUaTrustedCertificate } from '@root/middleware/shared/ports/types'
 import { useCallback, useMemo, useState } from 'react'
 
+import { Label } from '../../../../../../_atoms/label'
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
 import { CertificateModal } from './certificate-modal'
 
 interface CertificatesTabProps {
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
index 3046ef508..93389338e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
@@ -1,12 +1,13 @@
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaSecurityProfile } from '@root/middleware/shared/ports/types'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { v4 as uuidv4 } from 'uuid'
+
 import { Checkbox } from '../../../../../../_atoms/checkbox'
 import { InputWithRef } from '../../../../../../_atoms/input'
 import { Label } from '../../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../../../../../../_molecules/modal'
-import type { OpcUaSecurityProfile } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { v4 as uuidv4 } from 'uuid'
 
 type SecurityPolicy = 'None' | 'Basic128Rsa15' | 'Basic256' | 'Basic256Sha256'
 type SecurityMode = 'None' | 'Sign' | 'SignAndEncrypt'
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
index 018ce484f..0315a564f 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
@@ -1,6 +1,6 @@
-import { useOpenPLCStore } from '../../../../../../../store'
-import type { OpcUaSecurityProfile, OpcUaServerConfig } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
+import { useOpenPLCStore } from '@root/frontend/store'
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaSecurityProfile, OpcUaServerConfig } from '@root/middleware/shared/ports/types'
 import { useCallback, useMemo, useState } from 'react'
 
 import { SecurityProfileModal } from './security-profile-modal'
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
index c03c2cfad..f74dc9a6d 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
@@ -1,4 +1,4 @@
-import type { OpcUaNodeConfig } from '../../../../../../../../middleware/shared/ports/types'
+import type { OpcUaNodeConfig } from '@root/middleware/shared/ports/types'
 
 interface SelectedVariablesListProps {
   nodes: OpcUaNodeConfig[]
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
index c571aed4e..533d199a1 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
@@ -1,13 +1,14 @@
-import ViewIcon from '../../../../../../../assets/icons/interface/View'
-import ViewHiddenIcon from '../../../../../../../assets/icons/interface/ViewHidden'
+import ViewIcon from '@root/frontend/assets/icons/interface/View'
+import ViewHiddenIcon from '@root/frontend/assets/icons/interface/ViewHidden'
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaTrustedCertificate, OpcUaUser } from '@root/middleware/shared/ports/types'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { v4 as uuidv4 } from 'uuid'
+
 import { InputWithRef } from '../../../../../../_atoms/input'
 import { Label } from '../../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../../../../../../_molecules/modal'
-import type { OpcUaTrustedCertificate, OpcUaUser } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { v4 as uuidv4 } from 'uuid'
 
 type AuthType = 'password' | 'certificate'
 type UserRole = 'viewer' | 'operator' | 'engineer'
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
index 1337db2d8..41d1340c7 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
@@ -1,6 +1,6 @@
-import { useOpenPLCStore } from '../../../../../../../store'
-import type { OpcUaServerConfig, OpcUaUser } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
+import { useOpenPLCStore } from '@root/frontend/store'
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaServerConfig, OpcUaUser } from '@root/middleware/shared/ports/types'
 import { useCallback, useMemo, useState } from 'react'
 
 import { UserModal } from './user-modal'
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
index bdb5d7fe0..2b0ecbbb5 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
@@ -1,12 +1,12 @@
+import { cn } from '@root/frontend/utils/cn'
+import type { OpcUaFieldConfig, OpcUaNodeConfig, OpcUaPermissions } from '@root/middleware/shared/ports/types'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { v4 as uuidv4 } from 'uuid'
+
 import { InputWithRef } from '../../../../../../_atoms/input'
 import { Label } from '../../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../../_atoms/select'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../../../../../../_molecules/modal'
-import type { OpcUaFieldConfig, OpcUaNodeConfig, OpcUaPermissions } from '../../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../../utils/cn'
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { v4 as uuidv4 } from 'uuid'
-
 import { isComplexType, type VariableTreeNode } from '../hooks/use-project-variables'
 
 interface VariableConfigModalProps {
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
index 534997b0a..05fc036a6 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
@@ -1,4 +1,4 @@
-import { cn } from '../../../../../../../utils/cn'
+import { cn } from '@root/frontend/utils/cn'
 import { useCallback, useState } from 'react'
 
 import type { VariableTreeNode } from '../hooks/use-project-variables'
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
similarity index 96%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
index eeadfeb4d..dc027931e 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
@@ -1,5 +1,4 @@
-import { useOpenPLCStore } from '../../../../../../../store'
-import type { PLCDataType, PLCPou, PLCVariable } from '../../../../../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '@root/frontend/store'
 import {
   findFunctionBlockVariables,
   findStructureVariables,
@@ -7,7 +6,8 @@ import {
   isEnumerationType,
   isFunctionBlockType,
   type PouVariable,
-} from '../../../../../../../utils/pou-helpers'
+} from '@root/frontend/utils/pou-helpers'
+import type { PLCDataType, PLCPou, PLCVariable } from '@root/middleware/shared/ports/types'
 import { useMemo } from 'react'
 
 /**
@@ -383,19 +383,19 @@ const buildVariableNodeFromPLC = (
  * Build a tree node for a program POU.
  */
 const buildProgramNode = (pou: PLCPou, dataTypes: PLCDataType[], pous: PLCPou[]): VariableTreeNode => {
-  if (pou.type !== 'program') {
+  if (pou.pouType !== 'program') {
     throw new Error('Expected program POU')
   }
 
-  const children = pou.data.variables
-    .map((v) => buildVariableNodeFromPLC(v, pou.data.name, dataTypes, pous))
+  const children = (pou.interface?.variables ?? [])
+    .map((v) => buildVariableNodeFromPLC(v, pou.name, dataTypes, pous))
     .filter((node): node is VariableTreeNode => node !== null)
 
   return {
-    id: `pou-${pou.data.name}`,
-    name: pou.data.name,
+    id: `pou-${pou.name}`,
+    name: pou.name,
     type: 'program',
-    pouName: pou.data.name,
+    pouName: pou.name,
     variablePath: '',
     isSelectable: false,
     children,
@@ -440,12 +440,12 @@ export const useProjectVariables = (): VariableTreeNode[] => {
     const nodes: VariableTreeNode[] = []
 
     for (const pou of projectData.pous) {
-      if (pou.type === 'program') {
+      if (pou.pouType === 'program') {
         nodes.push(buildProgramNode(pou, projectData.dataTypes, projectData.pous))
       }
     }
 
-    const globalVars = projectData.configuration.resource.globalVariables
+    const globalVars = projectData.configurations.resource.globalVariables
     if (globalVars && globalVars.length > 0) {
       nodes.push(
         buildGlobalVariablesNode(
@@ -457,7 +457,7 @@ export const useProjectVariables = (): VariableTreeNode[] => {
     }
 
     return nodes
-  }, [projectData.pous, projectData.dataTypes, projectData.configuration.resource.globalVariables])
+  }, [projectData.pous, projectData.dataTypes, projectData.configurations.resource.globalVariables])
 }
 
 // Helper exports for tree manipulation
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/index.tsx b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/index.tsx
similarity index 99%
rename from src2/frontend/components/_features/[workspace]/editor/server/opcua-server/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/opcua-server/index.tsx
index 14a5302f0..15ad54eb0 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/opcua-server/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/opcua-server/index.tsx
@@ -1,12 +1,12 @@
 import * as Tabs from '@radix-ui/react-tabs'
+import type { OpcUaServerConfig } from '@root/middleware/shared/ports/types'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
+import { useOpenPLCStore } from '../../../../../../store'
+import { cn } from '../../../../../../utils/cn'
 import { InputWithRef } from '../../../../../_atoms/input'
 import { Label } from '../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../_atoms/select'
-import { useOpenPLCStore } from '../../../../../../store'
-import type { OpcUaServerConfig } from '../../../../../../../middleware/shared/ports/types'
-import { cn } from '../../../../../../utils/cn'
-import { useCallback, useEffect, useMemo, useState } from 'react'
-
 import { AddressSpaceTab } from './components/address-space-tab'
 import { CertificatesTab } from './components/certificates-tab'
 import { SecurityProfilesTab } from './components/security-profiles-tab'
diff --git a/src2/frontend/components/_features/[workspace]/editor/server/s7comm-server/index.tsx b/src/frontend/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
similarity index 97%
rename from src2/frontend/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
rename to src/frontend/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
index a282c80c0..55a363f37 100644
--- a/src2/frontend/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
@@ -1,11 +1,12 @@
 import * as AccordionPrimitive from '@radix-ui/react-accordion'
 import { ChevronDownIcon, Pencil1Icon, PlusIcon, TrashIcon } from '@radix-ui/react-icons'
+import { forwardRef, useCallback, useEffect, useMemo, useState } from 'react'
+
+import { useOpenPLCStore } from '../../../../../../store'
+import { cn } from '../../../../../../utils/cn'
 import { InputWithRef } from '../../../../../_atoms/input'
 import { Label } from '../../../../../_atoms/label'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../../_atoms/select'
-import { useOpenPLCStore } from '../../../../../../store'
-import { cn } from '../../../../../../utils/cn'
-import { forwardRef, useCallback, useEffect, useMemo, useState } from 'react'
 
 // UI-specific types for S7Comm buffer mapping.
 // These differ from the middleware S7CommDataBlock which uses startByte/endByte/iecAddresses.
@@ -26,7 +27,7 @@ type S7CommBufferType =
   | 'lint_output'
   | 'lint_memory'
 
-type S7CommDataBlock = {
+type S7CommUIDataBlock = {
   dbNumber: number
   description: string
   sizeBytes: number
@@ -142,9 +143,9 @@ AccordionContent.displayName = 'AccordionContent'
 interface DataBlockModalProps {
   isOpen: boolean
   onClose: () => void
-  onSave: (dataBlock: S7CommDataBlock) => void
+  onSave: (dataBlock: S7CommUIDataBlock) => void
   existingDbNumbers: number[]
-  editingBlock?: S7CommDataBlock
+  editingBlock?: S7CommUIDataBlock
 }
 
 const DataBlockModal = ({ isOpen, onClose, onSave, existingDbNumbers, editingBlock }: DataBlockModalProps) => {
@@ -383,7 +384,7 @@ const S7CommServerEditor = () => {
 
   // Modal state
   const [isModalOpen, setIsModalOpen] = useState(false)
-  const [editingBlock, setEditingBlock] = useState<S7CommDataBlock | undefined>(undefined)
+  const [editingBlock, setEditingBlock] = useState<S7CommUIDataBlock | undefined>(undefined)
 
   // Sync state from config
   useEffect(() => {
@@ -500,17 +501,20 @@ const S7CommServerEditor = () => {
     setIsModalOpen(true)
   }, [])
 
-  const handleEditDataBlock = useCallback((dataBlock: S7CommDataBlock) => {
+  const handleEditDataBlock = useCallback((dataBlock: S7CommUIDataBlock) => {
     setEditingBlock(dataBlock)
     setIsModalOpen(true)
   }, [])
 
   const handleSaveDataBlock = useCallback(
-    (dataBlock: S7CommDataBlock) => {
+    (dataBlock: S7CommUIDataBlock) => {
+      // Cast UI data block to middleware type — the extra UI fields (startBuffer, bitAddressing) are ignored by the store
+      const middlewareBlock =
+        dataBlock as unknown as import('../../../../../../../middleware/shared/ports/types').S7CommDataBlock
       if (editingBlock) {
-        projectActions.updateS7CommDataBlock(serverName, editingBlock.dbNumber, dataBlock)
+        projectActions.updateS7CommDataBlock(serverName, editingBlock.dbNumber, middlewareBlock)
       } else {
-        projectActions.addS7CommDataBlock(serverName, dataBlock)
+        projectActions.addS7CommDataBlock(serverName, middlewareBlock)
       }
       handleFileAndWorkspaceSavedState(serverName)
     },
@@ -728,12 +732,14 @@ const S7CommServerEditor = () => {
                                 {db.sizeBytes} bytes
                               </td>
                               <td className='px-3 py-2 text-sm text-neutral-600 dark:text-neutral-400'>
-                                {BUFFER_TYPE_OPTIONS.find((o) => o.value === db.mapping.type)?.label || db.mapping.type}
+                                {BUFFER_TYPE_OPTIONS.find((o) => o.value === db.mapping.type)?.label ||
+                                  db.mapping.type ||
+                                  'Unknown'}
                               </td>
                               <td className='px-3 py-2 text-right'>
                                 <div className='flex justify-end gap-2'>
                                   <button
-                                    onClick={() => handleEditDataBlock(db)}
+                                    onClick={() => handleEditDataBlock(db as unknown as S7CommUIDataBlock)}
                                     className='rounded p-1 text-neutral-500 hover:bg-neutral-100 hover:text-neutral-700 dark:text-neutral-400 dark:hover:bg-neutral-800 dark:hover:text-neutral-200'
                                     title='Edit'
                                   >
diff --git a/src2/frontend/components/_features/[workspace]/search/display/tree-view.tsx b/src/frontend/components/_features/[workspace]/search/display/tree-view.tsx
similarity index 96%
rename from src2/frontend/components/_features/[workspace]/search/display/tree-view.tsx
rename to src/frontend/components/_features/[workspace]/search/display/tree-view.tsx
index 3528fdc19..02a0fdeb7 100644
--- a/src2/frontend/components/_features/[workspace]/search/display/tree-view.tsx
+++ b/src/frontend/components/_features/[workspace]/search/display/tree-view.tsx
@@ -1,13 +1,16 @@
-import { ArrayIcon } from '../../../../../assets/icons/project/Array'
+import { ComponentPropsWithoutRef, ReactNode, useCallback, useEffect, useState } from 'react'
+
 import { ArrowIcon } from '../../../../../assets/icons/interface/Arrow'
 import { CommentIcon } from '../../../../../assets/icons/interface/Comment'
+import ZapIcon from '../../../../../assets/icons/interface/Zap'
+import { ArrayIcon } from '../../../../../assets/icons/project/Array'
 import { CppIcon } from '../../../../../assets/icons/project/Cpp'
 import { DataTypeIcon } from '../../../../../assets/icons/project/DataType'
 import { DeviceIcon } from '../../../../../assets/icons/project/Device'
 import { EnumIcon } from '../../../../../assets/icons/project/Enum'
 import { FBDIcon } from '../../../../../assets/icons/project/FBD'
-import { FunctionBlockIcon } from '../../../../../assets/icons/project/FunctionBlock'
 import { FunctionIcon } from '../../../../../assets/icons/project/Function'
+import { FunctionBlockIcon } from '../../../../../assets/icons/project/FunctionBlock'
 import { ILIcon } from '../../../../../assets/icons/project/IL'
 import { LDIcon } from '../../../../../assets/icons/project/LD'
 import { PLCIcon } from '../../../../../assets/icons/project/PLC'
@@ -17,10 +20,8 @@ import { ResourceIcon } from '../../../../../assets/icons/project/Resource'
 import { SFCIcon } from '../../../../../assets/icons/project/SFC'
 import { STIcon } from '../../../../../assets/icons/project/ST'
 import { StructureIcon } from '../../../../../assets/icons/project/Structure'
-import ZapIcon from '../../../../../assets/icons/interface/Zap'
 import { useOpenPLCStore } from '../../../../../store'
 import { cn } from '../../../../../utils/cn'
-import { ComponentPropsWithoutRef, ReactNode, useCallback, useEffect, useState } from 'react'
 
 type IProjectSearchTreeRootProps = ComponentPropsWithoutRef<'ul'> & {
   label: string
@@ -83,16 +84,16 @@ const BranchSources = {
 const ProjectSearchTreeBranch = ({ branchTarget, children, ...res }: IProjectSearchTreeBranchProps) => {
   const {
     project: {
-      data: { pous, dataTypes, configuration },
+      data: { pous, dataTypes, configurations },
     },
   } = useOpenPLCStore()
   const [branchIsOpen, setBranchIsOpen] = useState(false)
   const { BranchIcon, label } = BranchSources[branchTarget]
   const handleBranchVisibility = useCallback(() => setBranchIsOpen(!branchIsOpen), [branchIsOpen])
   const hasAssociatedPou: boolean =
-    pous.some((pou) => pou.type === branchTarget) ||
+    pous.some((pou) => pou.pouType === branchTarget) ||
     (branchTarget === 'data-type' && dataTypes.length > 0) ||
-    (branchTarget === 'resource' && configuration !== null)
+    (branchTarget === 'resource' && configurations !== null)
   useEffect(() => setBranchIsOpen(hasAssociatedPou), [hasAssociatedPou])
 
   return (
@@ -234,7 +235,7 @@ const ProjectSearchTreeLeaf = ({ leafLang, label, ...res }: IProjectSearchTreeLe
     },
   } = useOpenPLCStore()
   const [leafIsSelected, setLeafIsSelected] = useState<boolean>(false)
-  const leafSource = LeafSources[leafLang as keyof typeof LeafSources] ?? LeafSources.st
+  const leafSource = LeafSources[leafLang] ?? LeafSources.st
   const { LeafIcon } = leafSource
 
   const handleLeafSelection = useCallback(() => setLeafIsSelected(!leafIsSelected), [leafIsSelected])
@@ -263,13 +264,14 @@ const ProjectSearchTreeLeaf = ({ leafLang, label, ...res }: IProjectSearchTreeLe
 const ProjectSearchTreeVariableBranch = ({ leafLang, label, children, ...res }: IProjectSearchTreeLeafProps) => {
   const {
     project: {
-      data: { pous, configuration },
+      data: { pous, configurations },
     },
   } = useOpenPLCStore()
   const [branchIsOpen, setBranchIsOpen] = useState<boolean>(false)
   const { LeafIcon } = LeafSources[leafLang]
   const handleBranchVisibility = useCallback(() => setBranchIsOpen(!branchIsOpen), [branchIsOpen])
-  const hasVariable: boolean = pous.some((pou) => pou.data.variables.length > 0) || configuration !== null
+  const hasVariable: boolean =
+    pous.some((pou) => (pou.interface?.variables ?? []).length > 0) || configurations !== null
   useEffect(() => setBranchIsOpen(hasVariable), [hasVariable])
 
   return (
diff --git a/src2/frontend/components/_features/[workspace]/search/index.tsx b/src/frontend/components/_features/[workspace]/search/index.tsx
similarity index 98%
rename from src2/frontend/components/_features/[workspace]/search/index.tsx
rename to src/frontend/components/_features/[workspace]/search/index.tsx
index b9fffbc66..c22a79285 100644
--- a/src2/frontend/components/_features/[workspace]/search/index.tsx
+++ b/src/frontend/components/_features/[workspace]/search/index.tsx
@@ -1,12 +1,17 @@
 import { CloseIcon } from '../../../../assets/icons/interface/Close'
-import { Accordion } from '../../../_atoms/accordion'
 import { useOpenPLCStore } from '../../../../store'
 import type { Project } from '../../../../store/slices/search'
+import { extractSearchQuery } from '../../../../store/slices/search/utils'
 import type { TabsProps } from '../../../../store/slices/tabs'
 import { CreateEditorObjectFromTab } from '../../../../store/slices/tabs/utils'
-import { extractSearchQuery } from '../../../../store/slices/search/utils'
-
-import { ProjectSearchTreeBranch, ProjectSearchTreeLeaf, ProjectSearchTreeRoot, ProjectSearchTreeVariableBranch, ProjectSearchTreeVariableLeaf, } from './display/tree-view'
+import { Accordion } from '../../../_atoms/accordion'
+import {
+  ProjectSearchTreeBranch,
+  ProjectSearchTreeLeaf,
+  ProjectSearchTreeRoot,
+  ProjectSearchTreeVariableBranch,
+  ProjectSearchTreeVariableLeaf,
+} from './display/tree-view'
 
 interface _SearchResult {
   searchID: string
diff --git a/src2/frontend/components/_molecules/breadcrumbs/index.tsx b/src/frontend/components/_molecules/breadcrumbs/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/breadcrumbs/index.tsx
rename to src/frontend/components/_molecules/breadcrumbs/index.tsx
index 9511b6af7..2e1031976 100644
--- a/src2/frontend/components/_molecules/breadcrumbs/index.tsx
+++ b/src/frontend/components/_molecules/breadcrumbs/index.tsx
@@ -1,18 +1,19 @@
 /**
  * This need to be refactored!!!!
  */
+import { startCase } from 'lodash'
+import { ComponentProps, useCallback, useMemo } from 'react'
+
+import type { FbInstanceInfo } from '../../../../middleware/shared/ports'
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { ConfigIcon } from '../../../assets/icons/interface/Config'
-import { PLCIcon } from '../../../assets/icons/project/PLC'
-import { LanguageIcon, LanguageIconType } from '../../../data/constants/language-icons'
-import { PouIcon, PouIconType } from '../../../data/constants/pou-icons'
 import { ArrayIcon } from '../../../assets/icons/project/Array'
 import { EnumIcon } from '../../../assets/icons/project/Enum'
+import { PLCIcon } from '../../../assets/icons/project/PLC'
 import { StructureIcon } from '../../../assets/icons/project/Structure'
+import { LanguageIcon, LanguageIconType } from '../../../data/constants/language-icons'
+import { PouIcon, PouIconType } from '../../../data/constants/pou-icons'
 import { useOpenPLCStore } from '../../../store'
-import type { FbInstanceInfo } from '../../../../middleware/shared/ports'
-import { startCase } from 'lodash'
-import { ComponentProps, useCallback, useMemo } from 'react'
 
 type INavigationPanelBreadcrumbsProps = ComponentProps<'ol'> & {
   crumb: {
diff --git a/src2/frontend/components/_molecules/charts/line-chart.tsx b/src/frontend/components/_molecules/charts/line-chart.tsx
similarity index 96%
rename from src2/frontend/components/_molecules/charts/line-chart.tsx
rename to src/frontend/components/_molecules/charts/line-chart.tsx
index 2ea717e7c..8100f3534 100644
--- a/src2/frontend/components/_molecules/charts/line-chart.tsx
+++ b/src/frontend/components/_molecules/charts/line-chart.tsx
@@ -107,9 +107,7 @@ const LineChart = ({ data, isBool = false, range, now, startTime, label }: LineC
 
   return (
     <div className='relative w-full'>
-      {label && (
-        <div className='absolute left-12 top-1 z-10 text-xs font-medium text-neutral-400'>{label}</div>
-      )}
+      {label && <div className='absolute left-12 top-1 z-10 text-xs font-medium text-neutral-400'>{label}</div>}
       <Chart options={chartOptions} series={chartSeries} type='line' height={150} />
     </div>
   )
diff --git a/src2/frontend/components/_molecules/data-types/array/header/base-type.tsx b/src/frontend/components/_molecules/data-types/array/header/base-type.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/data-types/array/header/base-type.tsx
rename to src/frontend/components/_molecules/data-types/array/header/base-type.tsx
index aa00c722c..bc6377ebd 100644
--- a/src2/frontend/components/_molecules/data-types/array/header/base-type.tsx
+++ b/src/frontend/components/_molecules/data-types/array/header/base-type.tsx
@@ -1,5 +1,5 @@
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../_atoms/select'
 import { baseTypeSchema } from '../../../../../../middleware/shared/ports/plc-schemas'
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../../_atoms/select'
 
 const DTBaseTypeContainer = () => {
   const baseTypes = baseTypeSchema.options
diff --git a/src/renderer/components/_molecules/data-types/array/header/initial-value.tsx b/src/frontend/components/_molecules/data-types/array/header/initial-value.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/array/header/initial-value.tsx
rename to src/frontend/components/_molecules/data-types/array/header/initial-value.tsx
diff --git a/src2/frontend/components/_molecules/data-types/array/index.tsx b/src/frontend/components/_molecules/data-types/array/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/data-types/array/index.tsx
rename to src/frontend/components/_molecules/data-types/array/index.tsx
index 0ef285a87..7132f3a61 100644
--- a/src2/frontend/components/_molecules/data-types/array/index.tsx
+++ b/src/frontend/components/_molecules/data-types/array/index.tsx
@@ -1,15 +1,15 @@
 import { ChangeEvent, ComponentPropsWithoutRef, useEffect, useState } from 'react'
 
+import { baseTypeSchema } from '../../../../../middleware/shared/ports/plc-schemas'
+import type { PLCDataType } from '../../../../../middleware/shared/ports/types'
 import { MinusIcon } from '../../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../../assets/icons/interface/StickArrow'
+import { usePouSnapshot } from '../../../../hooks/use-pou-snapshot'
+import { useOpenPLCStore } from '../../../../store'
 import { InputWithRef } from '../../../_atoms/input'
 import TableActions from '../../../_atoms/table-actions'
 import { TypeDropdownSelector } from '../../../_atoms/type-dropdown-selector'
-import { usePouSnapshot } from '../../../../hooks/use-pou-snapshot'
-import { useOpenPLCStore } from '../../../../store'
-import { baseTypeSchema } from '../../../../../middleware/shared/ports/plc-schemas'
-import type { PLCDataType } from '../../../../../middleware/shared/ports/types'
 import { DimensionsTable } from './table'
 
 type PLCArrayDatatype = Extract<PLCDataType, { derivation: 'array' }>
@@ -217,7 +217,7 @@ const ArrayDataType = ({ data, ...rest }: ArrayDatatypeProps) => {
         </div>
       </div>
 
-      <div className='w-[600px] gap-3 flex flex-col'>
+      <div className='flex w-[600px] flex-col gap-3'>
         <div aria-label='Array data type table actions container' className='flex h-fit items-center justify-between'>
           <p className='cursor-default select-none font-caption text-xs font-medium text-neutral-1000 dark:text-neutral-100'>
             Dimensions
diff --git a/src2/frontend/components/_molecules/data-types/array/table/editable-cell.tsx b/src/frontend/components/_molecules/data-types/array/table/editable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/data-types/array/table/editable-cell.tsx
rename to src/frontend/components/_molecules/data-types/array/table/editable-cell.tsx
index 3fbbf703f..e0e2789ff 100644
--- a/src2/frontend/components/_molecules/data-types/array/table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/data-types/array/table/editable-cell.tsx
@@ -1,8 +1,8 @@
 import { CellContext } from '@tanstack/react-table'
 import { useEffect, useRef, useState } from 'react'
 
-import { InputWithRef } from '../../../../_atoms/input'
 import { cn } from '../../../../../utils/cn'
+import { InputWithRef } from '../../../../_atoms/input'
 
 type EditableCellProps = CellContext<{ dimension: string }, unknown> & {
   id: string
diff --git a/src2/frontend/components/_molecules/data-types/array/table/index.tsx b/src/frontend/components/_molecules/data-types/array/table/index.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/data-types/array/table/index.tsx
rename to src/frontend/components/_molecules/data-types/array/table/index.tsx
index 19f942a92..ed76f2ce4 100644
--- a/src2/frontend/components/_molecules/data-types/array/table/index.tsx
+++ b/src/frontend/components/_molecules/data-types/array/table/index.tsx
@@ -1,13 +1,13 @@
 import { createColumnHelper, getCoreRowModel, useReactTable } from '@tanstack/react-table'
 import React, { useEffect, useRef } from 'react'
 
-import { GenericDataTypeTable } from '../../../../_atoms/generic-data-type-table'
-import { toast } from '../../../../_features/[app]/toast/use-toast'
+import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../../../store'
 import { arrayValidation } from '../../../../../store/slices/project/validation/variables'
-import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
 import { cn } from '../../../../../utils/cn'
+import { GenericDataTypeTable } from '../../../../_atoms/generic-data-type-table'
+import { toast } from '../../../../_features/[app]/toast/use-toast'
 import { DimensionCell } from './editable-cell'
 
 type PLCArrayDatatype = Extract<PLCDataType, { derivation: 'array' }>
diff --git a/src2/frontend/components/_molecules/data-types/enumerated/index.tsx b/src/frontend/components/_molecules/data-types/enumerated/index.tsx
similarity index 98%
rename from src2/frontend/components/_molecules/data-types/enumerated/index.tsx
rename to src/frontend/components/_molecules/data-types/enumerated/index.tsx
index 5a825dfb9..a407ea143 100644
--- a/src2/frontend/components/_molecules/data-types/enumerated/index.tsx
+++ b/src/frontend/components/_molecules/data-types/enumerated/index.tsx
@@ -1,13 +1,13 @@
 import { ComponentPropsWithoutRef, useEffect, useState } from 'react'
 
+import type { PLCDataType } from '../../../../../middleware/shared/ports/types'
 import { MinusIcon } from '../../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../../assets/icons/interface/StickArrow'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../_atoms/select'
-import TableActions from '../../../_atoms/table-actions'
 import { usePouSnapshot } from '../../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../../store'
-import type { PLCDataType } from '../../../../../middleware/shared/ports/types'
+import { Select, SelectContent, SelectItem, SelectTrigger } from '../../../_atoms/select'
+import TableActions from '../../../_atoms/table-actions'
 import { EnumeratedTable } from './table'
 
 type PLCEnumeratedDatatype = Extract<PLCDataType, { derivation: 'enumerated' }>
@@ -136,12 +136,12 @@ const EnumeratorDataType = ({ data, ...rest }: EnumDatatypeProps) => {
       className='flex h-full w-full flex-1 flex-row gap-4 overflow-hidden bg-transparent'
       {...rest}
     >
-      <div className='flex w-full gap-8 justify-between'>
+      <div className='flex w-full justify-between gap-8'>
         <div className='w-[600px]'>
           <div aria-label='Enumerated base type container' className='flex flex-col gap-3'></div>
           <div
             aria-label='Enum data type table actions container'
-            className='flex h-8 w-full items-center justify-between mb-3'
+            className='mb-3 flex h-8 w-full items-center justify-between'
           >
             <p className='cursor-default select-none font-caption text-xs font-medium text-neutral-1000 dark:text-neutral-100'>
               Description
diff --git a/src2/frontend/components/_molecules/data-types/enumerated/table/editable-cell.tsx b/src/frontend/components/_molecules/data-types/enumerated/table/editable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/data-types/enumerated/table/editable-cell.tsx
rename to src/frontend/components/_molecules/data-types/enumerated/table/editable-cell.tsx
index c55268d53..584477ac8 100644
--- a/src2/frontend/components/_molecules/data-types/enumerated/table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/data-types/enumerated/table/editable-cell.tsx
@@ -1,8 +1,8 @@
 import { CellContext } from '@tanstack/react-table'
 import { useEffect, useRef, useState } from 'react'
 
-import { InputWithRef } from '../../../../_atoms/input'
 import { cn } from '../../../../../utils/cn'
+import { InputWithRef } from '../../../../_atoms/input'
 
 type EditableCellProps = CellContext<{ description: string }, unknown> & {
   editable?: boolean
diff --git a/src2/frontend/components/_molecules/data-types/enumerated/table/index.tsx b/src/frontend/components/_molecules/data-types/enumerated/table/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/data-types/enumerated/table/index.tsx
rename to src/frontend/components/_molecules/data-types/enumerated/table/index.tsx
index c258c84d7..b647c0184 100644
--- a/src2/frontend/components/_molecules/data-types/enumerated/table/index.tsx
+++ b/src/frontend/components/_molecules/data-types/enumerated/table/index.tsx
@@ -1,13 +1,13 @@
 import { createColumnHelper, getCoreRowModel, useReactTable } from '@tanstack/react-table'
 import React, { useEffect, useRef } from 'react'
 
-import { GenericDataTypeTable } from '../../../../_atoms/generic-data-type-table'
-import { toast } from '../../../../_features/[app]/toast/use-toast'
+import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../../../store'
 import { enumeratedValidation } from '../../../../../store/slices/project/validation/variables'
-import type { PLCDataType } from '../../../../../../middleware/shared/ports/types'
 import { cn } from '../../../../../utils/cn'
+import { GenericDataTypeTable } from '../../../../_atoms/generic-data-type-table'
+import { toast } from '../../../../_features/[app]/toast/use-toast'
 import { DescriptionCell } from './editable-cell'
 
 type PLCEnumeratedDatatype = Extract<PLCDataType, { derivation: 'enumerated' }>
@@ -58,7 +58,6 @@ const EnumeratedTable = ({
         ),
       }),
     ],
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [values, name, selectedRow, initialValue],
   )
 
diff --git a/src2/frontend/components/_molecules/data-types/structure/index.tsx b/src/frontend/components/_molecules/data-types/structure/index.tsx
similarity index 98%
rename from src2/frontend/components/_molecules/data-types/structure/index.tsx
rename to src/frontend/components/_molecules/data-types/structure/index.tsx
index c952260fd..29ff54123 100644
--- a/src2/frontend/components/_molecules/data-types/structure/index.tsx
+++ b/src/frontend/components/_molecules/data-types/structure/index.tsx
@@ -1,14 +1,14 @@
 import { useEffect, useState } from 'react'
 
+import type { PLCDataType, PLCStructureVariable } from '../../../../../middleware/shared/ports/types'
 import { MinusIcon } from '../../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../../assets/icons/interface/StickArrow'
-import { toast } from '../../../_features/[app]/toast/use-toast'
-import TableActions from '../../../_atoms/table-actions'
 import { usePouSnapshot } from '../../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../../store'
 import type { StructureTableType } from '../../../../store/slices/editor/types'
-import type { PLCDataType, PLCStructureVariable } from '../../../../../middleware/shared/ports/types'
+import TableActions from '../../../_atoms/table-actions'
+import { toast } from '../../../_features/[app]/toast/use-toast'
 import { StructureTable } from './table'
 
 const StructureDataType = () => {
@@ -50,7 +50,6 @@ const StructureDataType = () => {
       const { description, selectedRow } = editor.structure
       setEditorStructure({ description: description, selectedRow: selectedRow })
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor])
 
   const handleRowClick = (row: HTMLTableRowElement) => {
@@ -106,7 +105,7 @@ const StructureDataType = () => {
           ...structureVariables,
           {
             name: getNextVariableName(baseName),
-            type: { definition: 'base-type', value: 'dint' },
+            type: { definition: 'base-type', value: 'DINT' },
             initialValue: { simpleValue: { value: '' } },
           },
         ],
diff --git a/src2/frontend/components/_molecules/data-types/structure/table/editable-cell.tsx b/src/frontend/components/_molecules/data-types/structure/table/editable-cell.tsx
similarity index 93%
rename from src2/frontend/components/_molecules/data-types/structure/table/editable-cell.tsx
rename to src/frontend/components/_molecules/data-types/structure/table/editable-cell.tsx
index 05c452135..459bb2482 100644
--- a/src2/frontend/components/_molecules/data-types/structure/table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/data-types/structure/table/editable-cell.tsx
@@ -1,11 +1,11 @@
 import type { CellContext, RowData } from '@tanstack/react-table'
 import { useEffect, useState } from 'react'
 
-import { InputWithRef } from '../../../../_atoms/input'
-import { useToast } from '../../../../_features/[app]/toast/use-toast'
-import type { ProjectResponse } from '../../../../../store/slices/project/types'
 import type { PLCStructureVariable } from '../../../../../../middleware/shared/ports/types'
+import type { ProjectResponse } from '../../../../../store/slices/project/types'
 import { cn } from '../../../../../utils/cn'
+import { InputWithRef } from '../../../../_atoms/input'
+import { useToast } from '../../../../_features/[app]/toast/use-toast'
 
 declare module '@tanstack/react-table' {
   // This is a helper interface that adds the `updateData` property to the table meta.
@@ -89,15 +89,8 @@ const EditableInitialValueCell = ({
 
   return (
     <InputWithRef
-      value={cellValue?.simpleValue.value ?? ''}
-      onChange={(e) =>
-        setCellValue((prev) => ({
-          ...prev,
-          simpleValue: {
-            value: e.target.value,
-          },
-        }))
-      }
+      value={cellValue ?? ''}
+      onChange={(e) => setCellValue(e.target.value)}
       onBlur={onBlur}
       className={cn(
         `flex w-full flex-1 bg-transparent p-2 text-center outline-none ${!editable ? 'pointer-events-none' : ''}`,
diff --git a/src2/frontend/components/_molecules/data-types/structure/table/elements/array-modal.tsx b/src/frontend/components/_molecules/data-types/structure/table/elements/array-modal.tsx
similarity index 93%
rename from src2/frontend/components/_molecules/data-types/structure/table/elements/array-modal.tsx
rename to src/frontend/components/_molecules/data-types/structure/table/elements/array-modal.tsx
index 40a04779f..20f99cb96 100644
--- a/src2/frontend/components/_molecules/data-types/structure/table/elements/array-modal.tsx
+++ b/src/frontend/components/_molecules/data-types/structure/table/elements/array-modal.tsx
@@ -1,12 +1,12 @@
+import { baseTypeSchema } from '@root/middleware/shared/ports/plc-schemas'
+import type { PLCDataType, PLCStructureVariable } from '@root/middleware/shared/ports/types'
 import { useEffect, useState } from 'react'
 import type { z } from 'zod'
 
-import { DimensionsModal } from '../../../../../_atoms/dimensions-modal'
-import { toast } from '../../../../../_features/[app]/toast/use-toast'
 import { useOpenPLCStore } from '../../../../../../store'
 import { arrayValidation } from '../../../../../../store/slices/project/validation/variables'
-import { baseTypeSchema } from '../../../../../../../middleware/shared/ports/plc-schemas'
-import type { PLCStructureVariable } from '../../../../../../../middleware/shared/ports/types'
+import { DimensionsModal } from '../../../../../_atoms/dimensions-modal'
+import { toast } from '../../../../../_features/[app]/toast/use-toast'
 
 type BaseType = z.infer<typeof baseTypeSchema>
 
@@ -78,7 +78,7 @@ export const ArrayModal = ({
     const variable = structure.variable.find((variable) => variable.name === variableName)
     if (!variable) return
 
-    if (variable.type.definition === 'array') {
+    if (variable.type.definition === 'array' && variable.type.data) {
       setDimensions(variable.type.data.dimensions.map((dimension) => dimension.dimension))
       setTypeValue(variable.type.data.baseType.value)
     }
@@ -109,7 +109,7 @@ export const ArrayModal = ({
     setSelectedInput((index + 1).toString())
   }
 
-  const handleUpdateType = (value: BaseType) => {
+  const handleUpdateType = (value: string) => {
     setTypeValue(value)
   }
 
@@ -155,7 +155,6 @@ export const ArrayModal = ({
       return
     }
 
-    // @ts-expect-error - This is a valid operation. This is being fixed.
     const updatedVariables: PLCStructureVariable[] = structure.variable.map((variable) => {
       if (variable.name === variableName) {
         const isBaseType = baseTypes.includes(typeValue as BaseType)
@@ -173,7 +172,7 @@ export const ArrayModal = ({
               dimensions: dimensionToSave.map((value) => ({ dimension: value })),
             },
           },
-          initialValue: variable.initialValue?.simpleValue?.value === '' ? undefined : variable.initialValue,
+          initialValue: (variable.initialValue ?? '') === '' ? undefined : variable.initialValue,
         }
       }
       return variable
@@ -182,7 +181,7 @@ export const ArrayModal = ({
     updateDatatype(name, {
       ...structure,
       variable: updatedVariables,
-    })
+    } as unknown as PLCDataType)
 
     setArrayModalIsOpen(false)
     closeContainer()
diff --git a/src2/frontend/components/_molecules/data-types/structure/table/index.tsx b/src/frontend/components/_molecules/data-types/structure/table/index.tsx
similarity index 95%
rename from src2/frontend/components/_molecules/data-types/structure/table/index.tsx
rename to src/frontend/components/_molecules/data-types/structure/table/index.tsx
index 4a38e4207..02d937f46 100644
--- a/src2/frontend/components/_molecules/data-types/structure/table/index.tsx
+++ b/src/frontend/components/_molecules/data-types/structure/table/index.tsx
@@ -1,14 +1,12 @@
 import { createColumnHelper } from '@tanstack/react-table'
 
-import { GenericTable } from '../../../../_atoms/generic-table'
+import type { PLCDataType, PLCStructureVariable } from '../../../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../../../store'
-import type { PLCDataType, PLCStructureVariable } from '../../../../../../middleware/shared/ports/types'
+import { GenericTable } from '../../../../_atoms/generic-table'
 import { EditableInitialValueCell, EditableNameCell } from './editable-cell'
 import { SelectableTypeCell } from './selectable-cell'
 
-type PLCStructureDatatype = Extract<PLCDataType, { derivation: 'structure' }>
-
 const columnHelper = createColumnHelper<PLCStructureVariable>()
 
 const columns = [
@@ -41,7 +39,7 @@ const columns = [
 ]
 
 type PLCStructureTableProps = {
-  tableData: PLCStructureDatatype['variable']
+  tableData: PLCStructureVariable[]
   selectedRow: number
   handleRowClick: (row: HTMLTableRowElement) => void
 }
diff --git a/src2/frontend/components/_molecules/data-types/structure/table/selectable-cell.tsx b/src/frontend/components/_molecules/data-types/structure/table/selectable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/data-types/structure/table/selectable-cell.tsx
rename to src/frontend/components/_molecules/data-types/structure/table/selectable-cell.tsx
index 5b4efd6ce..4820548b5 100644
--- a/src2/frontend/components/_molecules/data-types/structure/table/selectable-cell.tsx
+++ b/src/frontend/components/_molecules/data-types/structure/table/selectable-cell.tsx
@@ -3,12 +3,12 @@ import type { CellContext } from '@tanstack/react-table'
 import _ from 'lodash'
 import { useEffect, useState } from 'react'
 
-import { ArrowIcon } from '../../../../../assets/icons/interface/Arrow'
-import { InputWithRef } from '../../../../_atoms/input'
-import { useOpenPLCStore } from '../../../../../store'
 import { baseTypeSchema } from '../../../../../../middleware/shared/ports/plc-schemas'
 import type { PLCStructureVariable } from '../../../../../../middleware/shared/ports/types'
+import { ArrowIcon } from '../../../../../assets/icons/interface/Arrow'
+import { useOpenPLCStore } from '../../../../../store'
 import { cn } from '../../../../../utils/cn'
+import { InputWithRef } from '../../../../_atoms/input'
 import { ArrayModal } from './elements/array-modal'
 
 type ISelectableCellProps = CellContext<PLCStructureVariable, unknown> & { editable?: boolean }
diff --git a/src2/frontend/components/_molecules/file/file-label.tsx b/src/frontend/components/_molecules/file/file-label.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/file/file-label.tsx
rename to src/frontend/components/_molecules/file/file-label.tsx
diff --git a/src2/frontend/components/_molecules/file/file-root.tsx b/src/frontend/components/_molecules/file/file-root.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/file/file-root.tsx
rename to src/frontend/components/_molecules/file/file-root.tsx
index 949713ce1..04dddb9b4 100644
--- a/src2/frontend/components/_molecules/file/file-root.tsx
+++ b/src/frontend/components/_molecules/file/file-root.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { HTMLAttributes } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type FolderRootProps = HTMLAttributes<HTMLDivElement>
 
 export default function Root({ ...props }: FolderRootProps) {
diff --git a/src/renderer/components/_molecules/file/file-shape.tsx b/src/frontend/components/_molecules/file/file-shape.tsx
similarity index 100%
rename from src/renderer/components/_molecules/file/file-shape.tsx
rename to src/frontend/components/_molecules/file/file-shape.tsx
diff --git a/src/renderer/components/_molecules/file/index.ts b/src/frontend/components/_molecules/file/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/file/index.ts
rename to src/frontend/components/_molecules/file/index.ts
diff --git a/src2/frontend/components/_molecules/global-variables-table/editable-cell.tsx b/src/frontend/components/_molecules/global-variables-table/editable-cell.tsx
similarity index 98%
rename from src2/frontend/components/_molecules/global-variables-table/editable-cell.tsx
rename to src/frontend/components/_molecules/global-variables-table/editable-cell.tsx
index 1079183b1..b7034bb7f 100644
--- a/src2/frontend/components/_molecules/global-variables-table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/global-variables-table/editable-cell.tsx
@@ -1,22 +1,22 @@
 import * as PrimitivePopover from '@radix-ui/react-popover'
+import type { CellContext, RowData } from '@tanstack/react-table'
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import type { PLCGlobalVariable } from '../../../../middleware/shared/ports/types'
 import { pinSelectors, remoteDeviceSelectors } from '../../../hooks/use-store-selectors'
 import { useOpenPLCStore } from '../../../store'
 import type { ProjectResponse } from '../../../store/slices/project'
+import { cn } from '../../../utils/cn'
+import { isLegalIdentifier, sanitizeVariableInput } from '../../../utils/keywords'
 import { buildRemoteDeviceOptionGroups } from '../../../utils/remote-device-options'
 import {
   findAllReferencesToVariable,
   propagateVariableRename,
   type ReferenceImpactAnalysis,
 } from '../../../utils/variable-references'
-import type { PLCVariable } from '../../../../middleware/shared/ports/types'
-import { cn } from '../../../utils/cn'
-import { isLegalIdentifier, sanitizeVariableInput } from '../../../utils/keywords'
-import type { CellContext, RowData } from '@tanstack/react-table'
-import { useCallback, useEffect, useRef, useState } from 'react'
-
+import { GenericComboboxCell } from '../../_atoms/generic-table-inputs/generic-combobox-cell'
 import { HighlightedText } from '../../_atoms/highlighted-text'
 import { InputWithRef } from '../../_atoms/input'
-import { GenericComboboxCell } from '../../_atoms/generic-table-inputs/generic-combobox-cell'
 import { useToast } from '../../_features/[app]/toast/use-toast'
 import { RenameImpactModal } from '../rename-impact-modal'
 
@@ -28,7 +28,7 @@ declare module '@tanstack/react-table' {
   }
 }
 
-type IEditableCellProps = CellContext<PLCVariable, unknown> & { editable?: boolean }
+type IEditableCellProps = CellContext<PLCGlobalVariable, unknown> & { editable?: boolean }
 const EditableNameCell = ({ getValue, row: { index }, column: { id }, table, editable = true }: IEditableCellProps) => {
   const initialValue = getValue<string>()
   const { toast } = useToast()
diff --git a/src2/frontend/components/_molecules/global-variables-table/elements/array-modal.tsx b/src/frontend/components/_molecules/global-variables-table/elements/array-modal.tsx
similarity index 92%
rename from src2/frontend/components/_molecules/global-variables-table/elements/array-modal.tsx
rename to src/frontend/components/_molecules/global-variables-table/elements/array-modal.tsx
index 8d2cf99d9..6f95b2c99 100644
--- a/src2/frontend/components/_molecules/global-variables-table/elements/array-modal.tsx
+++ b/src/frontend/components/_molecules/global-variables-table/elements/array-modal.tsx
@@ -1,11 +1,10 @@
-import { DimensionsModal } from '../../../_atoms/dimensions-modal'
-import { toast } from '../../../_features/[app]/toast/use-toast'
-import { useOpenPLCStore } from '../../../../store'
-import { arrayValidation } from '../../../../store/slices/workspace/utils/variables'
-import { baseTypeSchema } from '../../../../../middleware/shared/ports'
 import { useEffect, useState } from 'react'
 
-type BaseType = (typeof baseTypeSchema.options)[number]
+import { baseTypeSchema } from '../../../../../middleware/shared/ports'
+import { useOpenPLCStore } from '../../../../store'
+import { arrayValidation } from '../../../../store/slices/workspace/utils/variables'
+import { DimensionsModal } from '../../../_atoms/dimensions-modal'
+import { toast } from '../../../_features/[app]/toast/use-toast'
 
 type ArrayModalProps = {
   variableName: string
@@ -73,9 +72,9 @@ export const GlobalArrayModal = ({
     const variable = globalVariables.find((variable) => variable.name === variableName)
     if (!variable) return
 
-    if (variable.type.definition === 'array') {
-      setDimensions(variable.type.data?.dimensions.map((dimension) => dimension.dimension) ?? [])
-      setTypeValue(variable.type.data?.baseType ?? 'dint')
+    if (variable.type.definition === 'array' && variable.type.data) {
+      setDimensions(variable.type.data.dimensions.map((dimension) => dimension.dimension))
+      setTypeValue(variable.type.data.baseType.value ?? 'dint')
     } else {
       setDimensions([])
       setTypeValue('dint')
@@ -111,7 +110,7 @@ export const GlobalArrayModal = ({
     setSelectedInput((index + 1).toString())
   }
 
-  const handleUpdateType = (value: BaseType) => {
+  const handleUpdateType = (value: string) => {
     setTypeValue(value)
   }
 
@@ -155,7 +154,10 @@ export const GlobalArrayModal = ({
           definition: 'array',
           value: formatArrayName,
           data: {
-            baseType: isBaseType ? typeValue : typeValue,
+            baseType: {
+              definition: isBaseType ? ('base-type' as const) : ('user-data-type' as const),
+              value: typeValue,
+            },
             dimensions: dimensionToSave.map((dimension) => ({ dimension: dimension })),
           },
         },
diff --git a/src2/frontend/components/_molecules/global-variables-table/index.tsx b/src/frontend/components/_molecules/global-variables-table/index.tsx
similarity index 94%
rename from src2/frontend/components/_molecules/global-variables-table/index.tsx
rename to src/frontend/components/_molecules/global-variables-table/index.tsx
index fa7969c6c..208ff4062 100644
--- a/src2/frontend/components/_molecules/global-variables-table/index.tsx
+++ b/src/frontend/components/_molecules/global-variables-table/index.tsx
@@ -1,6 +1,6 @@
-import type { PLCGlobalVariable } from '../../../../middleware/shared/ports/types'
 import { createColumnHelper } from '@tanstack/react-table'
 
+import type { PLCGlobalVariable } from '../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../store'
 import { GenericTable } from '../../_atoms/generic-table'
@@ -78,6 +78,7 @@ const GlobalVariablesTable = ({ tableData, selectedRow, handleRowClick }: PLCVar
       meta: { name },
     },
     projectActions: { updateVariable },
+    sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
   } = useOpenPLCStore()
 
   const { captureAndPush } = usePouSnapshot()
@@ -91,6 +92,9 @@ const GlobalVariablesTable = ({ tableData, selectedRow, handleRowClick }: PLCVar
       updateData={(rowIndex, columnId, value) => {
         captureAndPush(name)
         const result = updateVariable({ scope: 'global', rowId: rowIndex, data: { [columnId]: value } })
+        if (result.ok) {
+          handleFileAndWorkspaceSavedState('Resource')
+        }
         return result
       }}
       tableContext='Variables'
diff --git a/src2/frontend/components/_molecules/global-variables-table/selectable-cell.tsx b/src/frontend/components/_molecules/global-variables-table/selectable-cell.tsx
similarity index 98%
rename from src2/frontend/components/_molecules/global-variables-table/selectable-cell.tsx
rename to src/frontend/components/_molecules/global-variables-table/selectable-cell.tsx
index 6b57b76bd..f4aa9592c 100644
--- a/src2/frontend/components/_molecules/global-variables-table/selectable-cell.tsx
+++ b/src/frontend/components/_molecules/global-variables-table/selectable-cell.tsx
@@ -1,22 +1,22 @@
 import * as PrimitiveDropdown from '@radix-ui/react-dropdown-menu'
-import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
-import { DebuggerIcon } from '../../../assets/icons/interface/Debugger'
-import { useOpenPLCStore } from '../../../store'
-import { TypeChangeValidationResult, validateTypeChange, } from '../../../store/slices/project/validation/type-change'
-import { propagateVariableTypeChange } from '../../../utils/variable-references'
-import type { PLCGlobalVariable, PLCVariable } from '../../../../middleware/shared/ports/types'
-import { baseTypeSchema } from '../../../../middleware/shared/ports'
-import { cn } from '../../../utils/cn'
 import type { CellContext } from '@tanstack/react-table'
 import _ from 'lodash'
 import { useEffect, useState } from 'react'
 
+import { baseTypeSchema } from '../../../../middleware/shared/ports'
+import type { PLCGlobalVariable, PLCVariable } from '../../../../middleware/shared/ports/types'
+import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
+import { DebuggerIcon } from '../../../assets/icons/interface/Debugger'
+import { useOpenPLCStore } from '../../../store'
+import { TypeChangeValidationResult, validateTypeChange } from '../../../store/slices/project/validation/type-change'
+import { cn } from '../../../utils/cn'
+import { propagateVariableTypeChange } from '../../../utils/variable-references'
 import { InputWithRef } from '../../_atoms/input'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../_atoms/select'
 import { TypeChangeModal } from '../type-change-modal'
 import { GlobalArrayModal } from './elements/array-modal'
 
-type ISelectableCellProps = CellContext<PLCVariable, unknown> & { editable?: boolean }
+type ISelectableCellProps = CellContext<PLCGlobalVariable, unknown> & { editable?: boolean }
 
 const createVariableType = (
   definition: PLCVariable['type']['definition'],
diff --git a/src/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts b/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts
rename to src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts
diff --git a/src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts b/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
similarity index 100%
rename from src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
rename to src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
diff --git a/src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts b/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
similarity index 99%
rename from src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
rename to src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
index fd9000870..ec4f09af4 100644
--- a/src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
+++ b/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
@@ -1,11 +1,12 @@
-import { toast } from '../../../../_features/[app]/toast/use-toast'
+import { Edge, Node, ReactFlowInstance, XYPosition } from '@xyflow/react'
+import { useCallback, useEffect } from 'react'
+
 import { useOpenPLCStore } from '../../../../../store'
+import { ClipboardType } from '../../../../../store/slices/clipboard'
 import type { FBDRungState } from '../../../../../store/slices/fbd'
 import { pasteNodesAtFBD } from '../../../../../store/slices/fbd/utils'
 import { EdgeType, NodeType } from '../../../../../store/slices/react-flow'
-import { ClipboardType } from '../../../../../store/slices/clipboard'
-import { Edge, Node, ReactFlowInstance, XYPosition } from '@xyflow/react'
-import { useCallback, useEffect } from 'react'
+import { toast } from '../../../../_features/[app]/toast/use-toast'
 
 export const useFBDClipboard = ({
   mousePosition,
diff --git a/src2/frontend/components/_molecules/graphical-editor/fbd/index.tsx b/src/frontend/components/_molecules/graphical-editor/fbd/index.tsx
similarity index 92%
rename from src2/frontend/components/_molecules/graphical-editor/fbd/index.tsx
rename to src/frontend/components/_molecules/graphical-editor/fbd/index.tsx
index c37754221..cdac66b73 100644
--- a/src2/frontend/components/_molecules/graphical-editor/fbd/index.tsx
+++ b/src/frontend/components/_molecules/graphical-editor/fbd/index.tsx
@@ -1,16 +1,3 @@
-import { CustomFbdNodeTypes, customNodeTypes } from '../../../_atoms/graphical-editor/fbd'
-import { BasicNodeData, BlockNode } from '../../../_atoms/graphical-editor/fbd/utils/types'
-import { getVariableRestrictionType } from '../../../_atoms/graphical-editor/utils'
-import { ReactFlowPanel } from '../../../_atoms/react-flow'
-import { toast } from '../../../_features/[app]/toast/use-toast'
-import BlockElement from '../../../_features/[workspace]/editor/graphical/elements/fbd/block'
-import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
-import { usePouSnapshot } from '../../../../hooks/use-pou-snapshot'
-import { openPLCStoreBase, useOpenPLCStore } from '../../../../store'
-import type { FBDRungState } from '../../../../store/slices/fbd'
-import { getFunctionBlockVariablesToCleanup } from '../../../../utils/graphical/get-function-block-variables-to-cleanup'
-import { isFbdBlockDrag, getFbdBlockType } from '../../../../utils/graphical/drag-detection'
-import { newGraphicalEditorNodeID } from '../../../../utils/new-graphical-editor-node-id'
 import {
   addEdge,
   applyEdgeChanges,
@@ -28,6 +15,19 @@ import {
 import { debounce, isEqual } from 'lodash'
 import { DragEventHandler, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
+import { useDebugCompositeKey } from '../../../../hooks/use-debug-composite-key'
+import { usePouSnapshot } from '../../../../hooks/use-pou-snapshot'
+import { openPLCStoreBase, useOpenPLCStore } from '../../../../store'
+import type { FBDRungState } from '../../../../store/slices/fbd'
+import { getFbdBlockType, isFbdBlockDrag } from '../../../../utils/graphical/drag-detection'
+import { getFunctionBlockVariablesToCleanup } from '../../../../utils/graphical/get-function-block-variables-to-cleanup'
+import { newGraphicalEditorNodeID } from '../../../../utils/new-graphical-editor-node-id'
+import { CustomFbdNodeTypes, customNodeTypes } from '../../../_atoms/graphical-editor/fbd'
+import { BlockNode } from '../../../_atoms/graphical-editor/fbd/utils/types'
+import { getVariableRestrictionType } from '../../../_atoms/graphical-editor/utils'
+import { ReactFlowPanel } from '../../../_atoms/react-flow'
+import { toast } from '../../../_features/[app]/toast/use-toast'
+import BlockElement from '../../../_features/[workspace]/editor/graphical/elements/fbd/block'
 import { buildGenericNode } from './fbd-utils/nodes'
 import { useFBDClipboard } from './fbd-utils/useCopyPaste'
 
@@ -54,7 +54,7 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
   const { captureAndPush } = usePouSnapshot()
 
   const { pous } = project.data
-  const pouRef = pous.find((pou) => pou.data.name === editor.meta.name)
+  const pouRef = pous.find((pou) => pou.name === editor.meta.name)
   const getCompositeKey = useDebugCompositeKey()
   const [rungLocal, setRungLocal] = useState<FBDRungState>(rung)
   const [dragging, setDragging] = useState(false)
@@ -102,7 +102,9 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
       if (!variableName) return undefined
 
       if (!pouRef) return undefined
-      const variable = pouRef.data.variables.find((v) => v.name.toLowerCase() === variableName.toLowerCase())
+      const variable = (pouRef.interface?.variables ?? []).find(
+        (v) => v.name.toLowerCase() === variableName.toLowerCase(),
+      )
       if (!variable || variable.type.value.toUpperCase() !== 'BOOL') return undefined
 
       const compositeKey = getCompositeKey(variableName)
@@ -125,8 +127,8 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
       }
       if (!sourceHandle) return undefined
 
-      if (pouRef?.type !== 'function-block') {
-        const instances = project.data.configuration.resource.instances
+      if (pouRef?.pouType !== 'function-block') {
+        const instances = project.data.configurations.resource.instances
         const programInstance = instances.find((inst: { program: string }) => inst.program === editor.meta.name)
         if (!programInstance) return undefined
       }
@@ -228,7 +230,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
 
       return edge
     })
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     rungLocal.edges,
     rungLocal.nodes,
@@ -236,8 +237,8 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
     debugVariableValues,
     debugForcedVariables,
     editor.meta.name,
-    pouRef?.data.variables,
-    project.data.configuration.resource.instances,
+    pouRef?.interface?.variables,
+    project.data.configurations.resource.instances,
   ])
 
   const styledNodes = useMemo(() => {
@@ -265,8 +266,7 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
 
   const updateRungState = () => {
     const stripDivergence = (node: FlowNode) => {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { hasDivergence: _hd, ...cleanData } = node.data as Record<string, unknown>
+      const { hasDivergence: _hd, ...cleanData } = node.data
       return { ...node, data: cleanData }
     }
 
@@ -326,7 +326,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
     // updating ref when state changes
     // now, ref.current will have the latest sendRequest with access to the latest state
     debounceUpdateRungRef.current = updateRungState
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [dragging, rungLocal, rung])
   // creating debounced callback only once - on mount
   const debouncedUpdateRungStateCallback = useMemo(() => {
@@ -342,13 +341,11 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
 
   useEffect(() => {
     updateRungLocalFromStore()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [rung])
 
   useEffect(() => {
     debouncedUpdateRungStateCallback()
     return () => debouncedUpdateRungStateCallback.cancel()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [rungLocal])
 
   /**
@@ -368,7 +365,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
     )
 
     return () => unsub()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [reactFlowInstance])
 
   useEffect(() => {
@@ -377,7 +373,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
     setTimeout(() => {
       reactFlowInstance.setViewport(viewport, { duration: 0 })
     }, 0)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [reactFlowInstance, editor.meta.name])
 
   /**
@@ -401,33 +396,33 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
 
       if (blockLibraryType === 'user') {
         const library = libraries.user.find((library) => library.name === blockLibrary)
-        const pou = pous.find((pou) => pou.data.name === library?.name)
+        const pou = pous.find((pou) => pou.name === library?.name)
         if (!pou) return
-        const variables = pou.data.variables.map((variable) => ({
+        const variables = (pou.interface?.variables ?? []).map((variable) => ({
           id: variable.id,
           name: variable.name,
           class: variable.class,
           type: { definition: variable.type.definition, value: variable.type.value.toUpperCase() },
         }))
 
-        if (pou.type === 'function') {
-          const variable = getVariableRestrictionType(pou.data.returnType)
+        if (pou.pouType === 'function') {
+          const variable = getVariableRestrictionType(pou.interface?.returnType ?? '')
           variables.push({
             id: 'OUT',
             name: 'OUT',
             class: 'output',
             type: {
               definition: (variable.definition as 'array' | 'base-type' | 'user-data-type' | 'derived') ?? 'derived',
-              value: pou.data.returnType.toUpperCase(),
+              value: (pou.interface?.returnType ?? '').toUpperCase(),
             },
           })
         }
 
         pouLibrary = {
-          name: pou.data.name,
-          type: pou.type,
+          name: pou.name,
+          type: pou.pouType,
           variables: variables,
-          documentation: pou.data.documentation,
+          documentation: pou.documentation,
           extensible: false,
         }
       }
@@ -479,7 +474,7 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
       })
 
       if (pouRef && nodes.length > 0) {
-        const allVariables = pouRef.data.variables
+        const allVariables = pouRef.interface?.variables ?? []
         const allRungs = [rung]
 
         const variablesToDelete = getFunctionBlockVariablesToCleanup(nodes, allRungs, allVariables)
@@ -584,7 +579,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
         }
       })
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rungLocal, dragging],
   )
 
@@ -595,14 +589,13 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
         edges: applyEdgeChanges(changes, rung.edges),
       }))
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rungLocal, dragging],
   )
 
   const onNodeDragStart = useCallback(() => {
+    captureAndPush(editor.meta.name)
     setDragging(true)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [rungLocal, dragging])
+  }, [rungLocal, dragging, captureAndPush, editor.meta.name])
 
   /**
    * When the node drag stops, update the fbd rung state
@@ -619,7 +612,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
         },
       })
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rungLocal, dragging],
   )
 
@@ -635,7 +627,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
         return
       }
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [reactFlowViewportRef],
   )
 
@@ -701,7 +692,6 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
 
       handleAddElementByDropping(position, blockType as CustomFbdNodeTypes, library)
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rung, reactFlowInstance],
   )
 
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx b/src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
similarity index 94%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
index c9f821d47..662b43c90 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
@@ -1,20 +1,20 @@
-import { getVariableRestrictionType } from '../../../../_atoms/graphical-editor/utils'
+import type { CoordinateExtent, Node as FlowNode, OnNodesChange, ReactFlowInstance } from '@xyflow/react'
+import { applyNodeChanges, getNodesBounds } from '@xyflow/react'
+import { differenceWith, isEqual, parseInt } from 'lodash'
+import { DragEventHandler, MouseEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
+import type { PLCVariable } from '../../../../../../middleware/shared/ports/types'
 import { useDebugCompositeKey } from '../../../../../hooks/use-debug-composite-key'
 import { usePouSnapshot } from '../../../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../../../store'
 import type { RungLadderState } from '../../../../../store/slices/ladder'
-import type { PLCVariable } from '../../../../../../middleware/shared/ports/types'
 import { cn } from '../../../../../utils/cn'
 import { getLadderBlockType, isLadderBlockDrag } from '../../../../../utils/graphical/drag-detection'
-import { syncNodesWithVariables } from '../../../../../utils/graphical/sync-nodes-with-variables'
 import { getFunctionBlockVariablesToCleanup } from '../../../../../utils/graphical/get-function-block-variables-to-cleanup'
-import type { CoordinateExtent, Node as FlowNode, OnNodesChange, ReactFlowInstance } from '@xyflow/react'
-import { applyNodeChanges, getNodesBounds } from '@xyflow/react'
-import { differenceWith, isEqual, parseInt } from 'lodash'
-import { DragEventHandler, MouseEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react'
-
+import { syncNodesWithVariables } from '../../../../../utils/graphical/sync-nodes-with-variables'
 import { customNodeTypes } from '../../../../_atoms/graphical-editor/ladder'
 import type { BasicNodeData } from '../../../../_atoms/graphical-editor/ladder/utils/types'
+import { getVariableRestrictionType } from '../../../../_atoms/graphical-editor/utils'
 import { ReactFlowPanel } from '../../../../_atoms/react-flow'
 import { toast } from '../../../../_features/[app]/toast/use-toast'
 import { addNewElement, removeElements } from './ladder-utils/elements'
@@ -85,7 +85,7 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
 
   const { captureAndPush } = usePouSnapshot()
   const { pous } = project.data
-  const pouRef = pous.find((pou) => pou.data.name === editor.meta.name)
+  const pouRef = pous.find((pou) => pou.name === editor.meta.name)
   const getCompositeKey = useDebugCompositeKey()
   const nodeTypes = useMemo(() => customNodeTypes, [])
 
@@ -183,8 +183,8 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
       }
       if (!sourceHandle) return undefined
 
-      if (pouRef?.type !== 'function-block') {
-        const instances = project.data.configuration.resource.instances
+      if (pouRef?.pouType !== 'function-block') {
+        const instances = project.data.configurations.resource.instances
         const programInstance = instances.find((inst) => inst.program === editor.meta.name)
         if (!programInstance) return undefined
       }
@@ -270,7 +270,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
 
       return edge
     })
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     rungLocal.edges,
     rungLocal.nodes,
@@ -350,7 +349,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
     }
 
     return baseNodes
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     rungLocal.edges,
     rungLocal.nodes,
@@ -374,7 +372,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
       })),
     })
     updateReactFlowPanelExtent(rung)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [rung.nodes])
 
   /**
@@ -395,7 +392,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
       rungId: rung.id,
       nodes: rungLocal.selectedNodes,
     })
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [rungLocal.selectedNodes])
 
   useEffect(() => {
@@ -426,7 +422,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
     } else {
       setSearchNodePosition({ x: 0, y: 0 })
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [searchQuery, rungLocal, reactFlowInstance])
 
   /**
@@ -471,32 +466,32 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
 
       if (blockLibraryType === 'user') {
         const library = libraries.user.find((library) => library.name === blockLibrary)
-        const pou = pous.find((pou) => pou.data.name === library?.name)
+        const pou = pous.find((pou) => pou.name === library?.name)
         if (!pou) return
-        const variables = pou.data.variables.map((variable) => ({
+        const variables = (pou.interface?.variables ?? []).map((variable) => ({
           id: variable.id,
           name: variable.name,
           class: variable.class,
           type: { definition: variable.type.definition, value: variable.type.value.toUpperCase() },
         }))
-        if (pou.type === 'function') {
-          const variable = getVariableRestrictionType(pou.data.returnType)
+        if (pou.pouType === 'function') {
+          const variable = getVariableRestrictionType(pou.interface?.returnType ?? '')
           variables.push({
             id: 'OUT',
             name: 'OUT',
             class: 'output',
             type: {
               definition: (variable.definition as 'array' | 'base-type' | 'user-data-type' | 'derived') ?? 'derived',
-              value: pou.data.returnType.toUpperCase(),
+              value: (pou.interface?.returnType ?? '').toUpperCase(),
             },
           })
         }
 
         pouLibrary = {
-          name: pou.data.name,
-          type: pou.type,
+          name: pou.name,
+          type: pou.pouType,
           variables: variables,
-          documentation: pou.data.documentation,
+          documentation: pou.documentation,
           extensible: false,
         }
       }
@@ -531,7 +526,12 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
       })
 
     if (pouRef) {
-      syncNodesWithVariables(pouRef.data.variables, ladderFlows, ladderFlowActions.updateNode, editor.meta.name)
+      syncNodesWithVariables(
+        pouRef.interface?.variables ?? [],
+        ladderFlows,
+        ladderFlowActions.updateNode,
+        editor.meta.name,
+      )
     }
   }
 
@@ -566,9 +566,11 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
     const blockNodes = nodes.filter((node) => node.type === 'block')
     if (blockNodes.length > 0) {
       let variables: PLCVariable[] = []
-      if (pouRef) variables = [...pouRef.data.variables] as PLCVariable[]
+      if (pouRef) variables = [...(pouRef.interface?.variables ?? [])] as PLCVariable[]
 
-      const variablesToCleanup = getFunctionBlockVariablesToCleanup(blockNodes, variables, ladderFlows)
+      const currentFlow = ladderFlows.find((f) => f.name === editor.meta.name)
+      const allRungs = currentFlow?.rungs ?? []
+      const variablesToCleanup = getFunctionBlockVariablesToCleanup(blockNodes, allRungs, variables)
 
       variablesToCleanup.forEach((variableName) => {
         deleteVariable({
@@ -601,7 +603,12 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
     }
 
     if (pouRef) {
-      syncNodesWithVariables(pouRef.data.variables, ladderFlows, ladderFlowActions.updateNode, editor.meta.name)
+      syncNodesWithVariables(
+        pouRef.interface?.variables ?? [],
+        ladderFlows,
+        ladderFlowActions.updateNode,
+        editor.meta.name,
+      )
     }
   }
 
@@ -652,7 +659,12 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
     ladderFlowActions.setEdges({ editorName: editor.meta.name, rungId: rungLocal.id, edges: result.edges })
 
     if (pouRef) {
-      syncNodesWithVariables(pouRef.data.variables, ladderFlows, ladderFlowActions.updateNode, editor.meta.name)
+      syncNodesWithVariables(
+        pouRef.interface?.variables ?? [],
+        ladderFlows,
+        ladderFlowActions.updateNode,
+        editor.meta.name,
+      )
     }
   }
 
@@ -710,7 +722,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
         selectedNodes: selectedNodes,
       }))
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rungLocal, rung, dragging],
   )
 
@@ -746,7 +757,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
         setRungLocal((rung) => ({ ...rung, nodes }))
       }
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rung, rungLocal, setReactFlowPanelExtent, reactFlowPanelExtent, dragging, isDebuggerActive],
   )
 
@@ -788,7 +798,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
       const nodes = removePlaceholderElements(rungLocal.nodes)
       setRungLocal((rung) => ({ ...rung, nodes }))
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rung, rungLocal, setReactFlowPanelExtent, reactFlowPanelExtent, dragging, isDebuggerActive],
   )
 
@@ -826,7 +835,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
         }),
       }))
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rung, rungLocal, isDebuggerActive],
   )
 
@@ -857,7 +865,6 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
       // Then add the node to the rung
       handleAddNode(blockType, library)
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     [rung, rungLocal, setReactFlowPanelExtent, reactFlowPanelExtent, isDebuggerActive],
   )
 
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx b/src/frontend/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/header.tsx b/src/frontend/components/_molecules/graphical-editor/ladder/rung/header.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/header.tsx
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/header.tsx
index ec804bcbe..5e6f3d53f 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/header.tsx
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/header.tsx
@@ -10,9 +10,9 @@ import { CloseIcon } from '../../../../../assets/icons/interface/Close'
 import { DragHandleIcon } from '../../../../../assets/icons/interface/DragHandle'
 import { DuplicateIcon } from '../../../../../assets/icons/interface/Duplicate'
 import { StickArrowIcon } from '../../../../../assets/icons/interface/StickArrow'
-import { cn } from '../../../../../utils/cn'
 import { useOpenPLCStore } from '../../../../../store'
 import type { RungLadderState } from '../../../../../store/slices/ladder'
+import { cn } from '../../../../../utils/cn'
 import { HighlightedTextArea } from '../../../../_atoms/highlighted-textarea'
 
 type RungHeaderProps = {
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
similarity index 100%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
index f0741e323..177873a38 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
@@ -1,7 +1,7 @@
-import type { BasicNodeData, ParallelNode } from '../../../../../_atoms/graphical-editor/ladder/utils/types'
-import type { RungLadderState } from '../../../../../../store/slices/ladder'
 import type { Edge, Node } from '@xyflow/react'
 
+import type { RungLadderState } from '../../../../../../store/slices/ladder'
+import type { BasicNodeData, ParallelNode } from '../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { isNodeOfType } from './nodes'
 
 type ConnectionOptions = {
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
similarity index 99%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
index 2dd1e5ff2..b8f959463 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
@@ -1,11 +1,11 @@
-import { defaultCustomNodesStyles } from '../../../../../../../_atoms/graphical-editor/ladder'
-import type { CustomHandleProps } from '../../../../../../../_atoms/graphical-editor/ladder/handle'
-import type { BasicNodeData, ParallelNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 // import type { VariableNode } from '../../../../../../../_atoms/graphical-editor/ladder/variable'
-import type { RungLadderState } from '../../../../../../../../store/slices'
+import type { RungLadderState } from '@root/frontend/store/slices'
 import type { Edge, Node } from '@xyflow/react'
 import { Position } from '@xyflow/react'
 
+import type { CustomHandleProps } from '../../../../../../../_atoms/graphical-editor/ladder/handle'
+import { defaultCustomNodesStyles } from '../../../../../../../_atoms/graphical-editor/ladder/node-builders'
+import type { BasicNodeData, ParallelNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { getDefaultNodeStyle, isNodeOfType } from '../../nodes'
 import {
   findAllParallelsDepthAndNodes,
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
similarity index 98%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
index 528128ada..46dbfcba4 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
@@ -1,7 +1,8 @@
-import type { RungLadderState } from '../../../../../../../../store/slices'
+import type { RungLadderState } from '@root/frontend/store/slices'
 import type { Edge, Node, ReactFlowInstance } from '@xyflow/react'
 import { toInteger } from 'lodash'
 
+import { PlaceholderNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { isNodeOfType } from '../../nodes'
 import { removeElement } from '..'
 import { updateDiagramElementsPosition } from '../diagram'
@@ -10,7 +11,6 @@ import { removePlaceholderElements } from '../placeholder'
 import { renderPlaceholderElements, searchNearestPlaceholder } from '../placeholder'
 import { appendSerialConnection } from '../serial'
 import { removeVariableBlock } from '../variable-block'
-import { PlaceholderNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 
 export const onElementDragStart = (rung: RungLadderState, draggedNode: Node) => {
   /**
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
similarity index 98%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
index 249c1cb60..ce0dece9d 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
@@ -1,7 +1,7 @@
-import type { BasicNodeData, PlaceholderNode } from '../../../../../../_atoms/graphical-editor/ladder/utils/types'
-import type { RungLadderState } from '../../../../../../../store/slices'
+import type { RungLadderState } from '@root/frontend/store/slices'
 import type { Edge, Node } from '@xyflow/react'
 
+import type { BasicNodeData, PlaceholderNode } from '../../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { disconnectNodes } from '../edges'
 import { isNodeOfType, removeNode } from '../nodes'
 import { updateDiagramElementsPosition } from './diagram'
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
similarity index 98%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
index 45a50bdec..f71f337da 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
@@ -1,14 +1,14 @@
-import { checkIfElementIsNode, nodesBuilder } from '../../../../../../../_atoms/graphical-editor/ladder'
+import type { RungLadderState } from '@root/frontend/store/slices'
+import { newGraphicalEditorNodeID } from '@root/frontend/utils/new-graphical-editor-node-id'
+import type { Edge, Node } from '@xyflow/react'
+
+import { checkIfElementIsNode, nodesBuilder } from '../../../../../../../_atoms/graphical-editor/ladder/node-builders'
 import type {
   BasicNodeData,
   BlockNodeData,
   ParallelNode,
   PlaceholderNode,
 } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
-import type { RungLadderState } from '../../../../../../../../store/slices'
-import type { Edge, Node } from '@xyflow/react'
-
-import { newGraphicalEditorNodeID } from '../../../../../../../../utils/new-graphical-editor-node-id'
 import { buildEdge, connectNodes, removeEdge } from '../../edges'
 import { buildGenericNode, isNodeOfType, removeNode } from '../../nodes'
 import { removePlaceholderElements } from '../placeholder'
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
similarity index 96%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
index a446e966e..344a2950d 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
@@ -1,8 +1,8 @@
-import { nodesBuilder } from '../../../../../../../_atoms/graphical-editor/ladder'
-import type { RungLadderState } from '../../../../../../../../store/slices'
+import type { RungLadderState } from '@root/frontend/store/slices'
+import { newGraphicalEditorNodeID } from '@root/frontend/utils/new-graphical-editor-node-id'
 import type { Node, ReactFlowInstance } from '@xyflow/react'
 
-import { newGraphicalEditorNodeID } from '../../../../../../../../utils/new-graphical-editor-node-id'
+import { nodesBuilder } from '../../../../../../../_atoms/graphical-editor/ladder/node-builders'
 import { getDeepestNodesInsideParallels, getNodesInsideAllParallels, getPlaceholderPositionBasedOnNode } from '../utils'
 
 export const removePlaceholderElements = (nodes: Node[]) => {
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
similarity index 94%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
index 6bc830859..6a0b785df 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
@@ -1,13 +1,13 @@
-import { checkIfElementIsNode } from '../../../../../../../_atoms/graphical-editor/ladder'
-import type { RungLadderState } from '../../../../../../../../store/slices'
+import type { RungLadderState } from '@root/frontend/store/slices'
+import { newGraphicalEditorNodeID } from '@root/frontend/utils/new-graphical-editor-node-id'
 import type { Edge, Node } from '@xyflow/react'
 
-import { newGraphicalEditorNodeID } from '../../../../../../../../utils/new-graphical-editor-node-id'
+import { checkIfElementIsNode } from '../../../../../../../_atoms/graphical-editor/ladder/node-builders'
+import { ParallelNode, PlaceholderNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 import { connectNodes } from '../../edges'
 import { buildGenericNode, isNodeOfType } from '../../nodes'
 import { removePlaceholderElements } from '../placeholder'
 import { getElementPositionBasedOnPlaceholderElement, getPreviousElement, getPreviousElementsByEdge } from '../utils'
-import { ParallelNode, PlaceholderNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
 
 export const appendSerialConnection = <T>(
   rung: RungLadderState,
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
similarity index 99%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
index 70e0d3f90..2ab82738c 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
@@ -1,9 +1,9 @@
-import type { CustomHandleProps } from '../../../../../../../_atoms/graphical-editor/ladder/handle'
-import type { RungLadderState } from '../../../../../../../../store/slices'
+import type { RungLadderState } from '@root/frontend/store/slices'
 import type { Edge, Node } from '@xyflow/react'
 
-import { getDefaultNodeStyle, isNodeOfType } from '../../nodes'
+import type { CustomHandleProps } from '../../../../../../../_atoms/graphical-editor/ladder/handle'
 import { BasicNodeData, ParallelNode } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
+import { getDefaultNodeStyle, isNodeOfType } from '../../nodes'
 
 /**
  * Get the previous element by searching with edge in the rung
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
similarity index 88%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
index befabcf06..c3626ef08 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
@@ -1,10 +1,13 @@
-import { defaultCustomNodesStyles, nodesBuilder } from '../../../../../../../_atoms/graphical-editor/ladder'
-import { RungLadderState } from '../../../../../../../../store/slices'
+import { RungLadderState } from '@root/frontend/store/slices'
+import { newGraphicalEditorNodeID } from '@root/frontend/utils/new-graphical-editor-node-id'
 import { Edge, Node } from '@xyflow/react'
 
-import { newGraphicalEditorNodeID } from '../../../../../../../../utils/new-graphical-editor-node-id'
-import { buildEdge } from '../../edges'
+import {
+  defaultCustomNodesStyles,
+  nodesBuilder,
+} from '../../../../../../../_atoms/graphical-editor/ladder/node-builders'
 import { BlockNode, BlockVariant } from '../../../../../../../_atoms/graphical-editor/ladder/utils/types'
+import { buildEdge } from '../../edges'
 
 export const renderVariableBlock = <T extends BlockVariant>(rung: RungLadderState, block: Node) => {
   const variableElements: Node[] = []
@@ -24,7 +27,9 @@ export const renderVariableBlock = <T extends BlockVariant>(rung: RungLadderStat
       : []
 
   inputHandles.forEach((inputHandle) => {
-    const connectedVariable = blockElement.data.connectedVariables.find((variable) => {
+    const connectedVariable = (
+      Array.isArray(blockElement.data.connectedVariables) ? blockElement.data.connectedVariables : []
+    ).find((variable) => {
       return variable.type === 'input' && variable.handleId === inputHandle.id
     })
 
@@ -64,7 +69,9 @@ export const renderVariableBlock = <T extends BlockVariant>(rung: RungLadderStat
   })
 
   outputHandles.forEach((outputHandle) => {
-    const connectedVariable = blockElement.data.connectedVariables.find((variable) => {
+    const connectedVariable = (
+      Array.isArray(blockElement.data.connectedVariables) ? blockElement.data.connectedVariables : []
+    ).find((variable) => {
       return variable.type === 'output' && variable.handleId === outputHandle.id
     })
 
diff --git a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
similarity index 97%
rename from src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
rename to src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
index a165f466a..a25ed80f2 100644
--- a/src2/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
@@ -1,8 +1,9 @@
-import { defaultCustomNodesStyles, nodesBuilder } from '../../../../../_atoms/graphical-editor/ladder'
-import type { BuilderBasicProps } from '../../../../../_atoms/graphical-editor/ladder/utils/types'
-import type { RungLadderState } from '../../../../../../store/slices/ladder'
 import type { Node } from '@xyflow/react'
 
+import type { RungLadderState } from '../../../../../../store/slices/ladder'
+import { defaultCustomNodesStyles, nodesBuilder } from '../../../../../_atoms/graphical-editor/ladder/node-builders'
+import type { BuilderBasicProps } from '../../../../../_atoms/graphical-editor/ladder/utils/types'
+
 export const findNode = (
   rung: RungLadderState,
   nodeId: string,
diff --git a/src2/frontend/components/_molecules/input-field/index.tsx b/src/frontend/components/_molecules/input-field/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/input-field/index.tsx
rename to src/frontend/components/_molecules/input-field/index.tsx
index 00887753a..e5dcf0e6e 100644
--- a/src2/frontend/components/_molecules/input-field/index.tsx
+++ b/src/frontend/components/_molecules/input-field/index.tsx
@@ -1,5 +1,4 @@
 import { cn } from '../../../utils/cn'
-
 import { InputWithRef } from '../../_atoms/input'
 
 type InputFieldProps = {
diff --git a/src2/frontend/components/_molecules/instances-table/editable-cell.tsx b/src/frontend/components/_molecules/instances-table/editable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/instances-table/editable-cell.tsx
rename to src/frontend/components/_molecules/instances-table/editable-cell.tsx
index d78c1bb49..3270b37f7 100644
--- a/src2/frontend/components/_molecules/instances-table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/instances-table/editable-cell.tsx
@@ -1,10 +1,10 @@
-import type { PLCInstance } from '../../../../middleware/shared/ports/types'
-import type { ProjectResponse } from '../../../store/slices/project'
-import { useOpenPLCStore } from '../../../store'
-import { cn } from '../../../utils/cn'
 import type { CellContext, RowData } from '@tanstack/react-table'
 import { useEffect, useState } from 'react'
 
+import type { PLCInstance } from '../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '../../../store'
+import type { ProjectResponse } from '../../../store/slices/project'
+import { cn } from '../../../utils/cn'
 import { HighlightedText } from '../../_atoms/highlighted-text'
 import { InputWithRef } from '../../_atoms/input'
 import { useToast } from '../../_features/[app]/toast/use-toast'
diff --git a/src2/frontend/components/_molecules/instances-table/index.tsx b/src/frontend/components/_molecules/instances-table/index.tsx
similarity index 96%
rename from src2/frontend/components/_molecules/instances-table/index.tsx
rename to src/frontend/components/_molecules/instances-table/index.tsx
index 7f7aea42b..e992e1423 100644
--- a/src2/frontend/components/_molecules/instances-table/index.tsx
+++ b/src/frontend/components/_molecules/instances-table/index.tsx
@@ -1,6 +1,6 @@
-import type { PLCInstance } from '../../../../middleware/shared/ports/types'
 import { createColumnHelper } from '@tanstack/react-table'
 
+import type { PLCInstance } from '../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../store'
 import { GenericTable } from '../../_atoms/generic-table'
@@ -17,7 +17,7 @@ const columns = [
     maxSize: 150,
     cell: EditableNameCell,
   }),
-  columnHelper.accessor('pouName', {
+  columnHelper.accessor('program', {
     header: 'Program',
     size: 768,
     minSize: 150,
@@ -25,7 +25,7 @@ const columns = [
     enableResizing: true,
     cell: SelectableProgramCell,
   }),
-  columnHelper.accessor('taskName', {
+  columnHelper.accessor('task', {
     header: ' Task',
     enableResizing: true,
     size: 768,
diff --git a/src2/frontend/components/_molecules/instances-table/selectable-cell.tsx b/src/frontend/components/_molecules/instances-table/selectable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/instances-table/selectable-cell.tsx
rename to src/frontend/components/_molecules/instances-table/selectable-cell.tsx
index 3c3e4c997..b8c9c07cf 100644
--- a/src2/frontend/components/_molecules/instances-table/selectable-cell.tsx
+++ b/src/frontend/components/_molecules/instances-table/selectable-cell.tsx
@@ -1,10 +1,10 @@
-import type { PLCInstance } from '../../../../middleware/shared/ports/types'
-import { useOpenPLCStore } from '../../../store'
-import { cn } from '../../../utils/cn'
 import { CellContext } from '@tanstack/react-table'
 import _ from 'lodash'
 import { useEffect, useState } from 'react'
 
+import type { PLCInstance } from '../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '../../../store'
+import { cn } from '../../../utils/cn'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../_atoms/select'
 
 type ISelectableCellProps = CellContext<PLCInstance, unknown> & { editable?: boolean }
diff --git a/src2/frontend/components/_molecules/library-tree/index.tsx b/src/frontend/components/_molecules/library-tree/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/library-tree/index.tsx
rename to src/frontend/components/_molecules/library-tree/index.tsx
index 8b2ad9444..3ae1af3f9 100644
--- a/src2/frontend/components/_molecules/library-tree/index.tsx
+++ b/src/frontend/components/_molecules/library-tree/index.tsx
@@ -1,9 +1,10 @@
+import { ComponentPropsWithoutRef, ReactNode, useCallback, useEffect, useState } from 'react'
+
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { LibraryCloseFolderIcon } from '../../../assets/icons/library/CloseFolder'
 import { LibraryFileIcon } from '../../../assets/icons/library/File'
 import { LibraryOpenFolderIcon } from '../../../assets/icons/library/OpenFolder'
 import { cn } from '../../../utils/cn'
-import { ComponentPropsWithoutRef, ReactNode, useCallback, useEffect, useState } from 'react'
 
 type ILibraryRootProps = ComponentPropsWithoutRef<'ul'> & {
   children: ReactNode
diff --git a/src/renderer/components/_molecules/menu-bar/constants.ts b/src/frontend/components/_molecules/menu-bar/constants.ts
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/constants.ts
rename to src/frontend/components/_molecules/menu-bar/constants.ts
diff --git a/src2/frontend/components/_molecules/menu-bar/index.tsx b/src/frontend/components/_molecules/menu-bar/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/menu-bar/index.tsx
rename to src/frontend/components/_molecules/menu-bar/index.tsx
index c69af9ea4..60a74f914 100644
--- a/src2/frontend/components/_molecules/menu-bar/index.tsx
+++ b/src/frontend/components/_molecules/menu-bar/index.tsx
@@ -1,7 +1,6 @@
 import * as MenuPrimitive from '@radix-ui/react-menubar'
 
 import { cn } from '../../../utils/cn'
-
 import { MenuClasses } from './constants'
 import { DisplayMenu } from './menus/display'
 import { EditMenu } from './menus/edit'
diff --git a/src/frontend/components/_molecules/menu-bar/menus/display.tsx b/src/frontend/components/_molecules/menu-bar/menus/display.tsx
new file mode 100644
index 000000000..17492f0ad
--- /dev/null
+++ b/src/frontend/components/_molecules/menu-bar/menus/display.tsx
@@ -0,0 +1,106 @@
+import * as MenuPrimitive from '@radix-ui/react-menubar'
+import { useEffect, useState } from 'react'
+
+import { i18n } from '../../../../locales/i18n'
+import { useOpenPLCStore } from '../../../../store'
+import { MenuClasses } from '../constants'
+
+interface FullscreenElement extends HTMLElement {
+  webkitRequestFullscreen?: () => Promise<void>
+  msRequestFullscreen?: () => Promise<void>
+}
+
+function getThemePreference(): 'light' | 'dark' {
+  const stored = localStorage.getItem('theme')
+  if (stored === 'dark' || stored === 'light') return stored
+  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'
+}
+
+export const DisplayMenu = () => {
+  const {
+    workspaceActions: { setSystemConfigs, toggleCollapse },
+  } = useOpenPLCStore()
+
+  const { TRIGGER, CONTENT, ITEM, ACCELERATOR, SEPARATOR } = MenuClasses
+
+  const [theme, setTheme] = useState(getThemePreference())
+
+  useEffect(() => {
+    document.documentElement.classList.add(theme)
+    setSystemConfigs({ shouldUseDarkMode: theme === 'dark' })
+    return () => {
+      document.documentElement.classList.remove(theme)
+    }
+  }, [theme, setSystemConfigs])
+
+  const toggleTheme = () => {
+    const newTheme = theme === 'light' ? 'dark' : 'light'
+    setTheme(newTheme)
+    localStorage.setItem('theme', newTheme)
+  }
+
+  const switchPerspective = () => {
+    toggleCollapse()
+  }
+
+  return (
+    <MenuPrimitive.Menu>
+      <MenuPrimitive.Trigger className={TRIGGER}>{i18n.t('menu:display.label')}</MenuPrimitive.Trigger>
+      <MenuPrimitive.Portal>
+        <MenuPrimitive.Content sideOffset={16} className={CONTENT}>
+          <MenuPrimitive.Item className={ITEM} onClick={() => window.location.reload()}>
+            <span>{i18n.t('menu:display.submenu.refresh')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + R'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:display.submenu.clearErrors')}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:display.submenu.zoomIn')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + +'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:display.submenu.zoomOut')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + -'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} onClick={switchPerspective}>
+            <span>{i18n.t('menu:display.submenu.switchPerspective')}</span>
+            <span className={ACCELERATOR}>{'F12'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:display.submenu.resetPerspective')}</span>
+            <span className={ACCELERATOR}>{'Shift + F12'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item
+            className={ITEM}
+            onClick={() => {
+              const elem = document.documentElement as FullscreenElement
+              if (elem.requestFullscreen) {
+                elem.requestFullscreen()
+              } else if (elem.webkitRequestFullscreen) {
+                elem.webkitRequestFullscreen()
+              } else if (elem.msRequestFullscreen) {
+                elem.msRequestFullscreen()
+              }
+            }}
+          >
+            <span>{i18n.t('menu:display.submenu.fullScreen')}</span>
+            <span className={ACCELERATOR}>{'F11'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:display.submenu.sortAlpha')}</span>
+            <span className={ACCELERATOR}>{'F10'}</span>
+          </MenuPrimitive.Item>
+          <div onClick={toggleTheme}>
+            <MenuPrimitive.Item className={ITEM}>
+              <span>{i18n.t('menu:display.submenu.theme')}</span>
+              <span className={ACCELERATOR}>{theme === 'light' ? 'dark' : 'light'}</span>
+            </MenuPrimitive.Item>
+          </div>
+        </MenuPrimitive.Content>
+      </MenuPrimitive.Portal>
+    </MenuPrimitive.Menu>
+  )
+}
diff --git a/src/frontend/components/_molecules/menu-bar/menus/edit.tsx b/src/frontend/components/_molecules/menu-bar/menus/edit.tsx
new file mode 100644
index 000000000..7dc0a2614
--- /dev/null
+++ b/src/frontend/components/_molecules/menu-bar/menus/edit.tsx
@@ -0,0 +1,93 @@
+import * as MenuPrimitive from '@radix-ui/react-menubar'
+import { useEffect } from 'react'
+
+import { useHandleRemoveTab } from '../../../../hooks/use-remove-tab'
+import { i18n } from '../../../../locales/i18n'
+import { useOpenPLCStore } from '../../../../store'
+import { MenuClasses } from '../constants'
+
+export const EditMenu = () => {
+  const {
+    editor,
+    workspaceActions: { setModalOpen },
+    modalActions: { openModal },
+  } = useOpenPLCStore()
+  const { setSelectedTab } = useHandleRemoveTab()
+  const { TRIGGER, CONTENT, ITEM, ACCELERATOR, SEPARATOR } = MenuClasses
+
+  useEffect(() => {
+    setSelectedTab(editor.meta.name)
+    return () => {
+      setSelectedTab('')
+    }
+  }, [editor])
+
+  const handleFindInProject = () => {
+    setModalOpen('findInProject', true)
+  }
+
+  const handleConfirmDeleteElement = () => {
+    openModal('confirm-delete-element', null)
+  }
+
+  return (
+    <MenuPrimitive.Menu>
+      <MenuPrimitive.Trigger className={TRIGGER}>{i18n.t('menu:edit.label')}</MenuPrimitive.Trigger>
+      <MenuPrimitive.Portal>
+        <MenuPrimitive.Content sideOffset={16} className={CONTENT}>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.undo')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Z'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.redo')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Y'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.cut')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + X'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.copy')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + C'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.paste')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + V'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.find')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + F'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.findNext')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + K'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.findPrevious')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Shift + K'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} onClick={handleFindInProject}>
+            <span>{i18n.t('menu:edit.submenu.findInProject')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Shift + F'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.addElement.label')}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:edit.submenu.selectAll')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + A'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} onClick={handleConfirmDeleteElement}>
+            <span>{i18n.t('menu:edit.submenu.deletePou')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Backspace'}</span>
+          </MenuPrimitive.Item>
+        </MenuPrimitive.Content>
+      </MenuPrimitive.Portal>
+    </MenuPrimitive.Menu>
+  )
+}
diff --git a/src/frontend/components/_molecules/menu-bar/menus/file.tsx b/src/frontend/components/_molecules/menu-bar/menus/file.tsx
new file mode 100644
index 000000000..0f4c1e2bf
--- /dev/null
+++ b/src/frontend/components/_molecules/menu-bar/menus/file.tsx
@@ -0,0 +1,155 @@
+import * as MenuPrimitive from '@radix-ui/react-menubar'
+import { useCallback, useEffect } from 'react'
+
+import { useCapabilities, useProject } from '../../../../../middleware/shared/providers'
+import { useHandleRemoveTab } from '../../../../hooks/use-remove-tab'
+import { i18n } from '../../../../locales/i18n'
+import { useOpenPLCStore } from '../../../../store'
+import { prepareSavePayload } from '../../../../utils/save-project'
+import { toast } from '../../../_features/[app]/toast/use-toast'
+import { MenuClasses } from '../constants'
+
+export const FileMenu = () => {
+  const projectPort = useProject()
+  const capabilities = useCapabilities()
+  const {
+    project,
+    editor: activeEditor,
+    editors,
+    deviceDefinitions,
+    workspace: { editingState },
+    workspaceActions: { setEditingState },
+    sharedWorkspaceActions: { closeProject },
+    fileActions: { setAllToSaved },
+    snapshotActions: { markAllSaved },
+  } = useOpenPLCStore()
+
+  const { handleRemoveTab, selectedTab, setSelectedTab } = useHandleRemoveTab()
+
+  useEffect(() => {
+    setSelectedTab(activeEditor.meta.name)
+  }, [activeEditor])
+
+  const { TRIGGER, CONTENT, ITEM, ACCELERATOR, SEPARATOR } = MenuClasses
+
+  const isSaving = editingState === 'save-request'
+
+  const executeSave = useCallback(async () => {
+    setEditingState('save-request')
+    toast({
+      title: 'Save changes',
+      description: 'Trying to save the changes in the project file.',
+      variant: 'warn',
+    })
+
+    try {
+      const params = prepareSavePayload({
+        projectPath: project.meta.path,
+        projectName: project.meta.name,
+        projectData: project.data,
+        deviceConfiguration: deviceDefinitions.configuration,
+        devicePinMapping: deviceDefinitions.pinMapping.pins,
+        editors,
+        activeEditor,
+      })
+
+      const res = await projectPort.saveProject(params)
+      if (res.success) {
+        setEditingState('saved')
+        setAllToSaved()
+        markAllSaved()
+        toast({
+          title: 'Changes saved!',
+          description: 'The project was saved successfully!',
+          variant: 'default',
+        })
+      } else {
+        setEditingState('unsaved')
+        toast({
+          title: 'Error in the save request!',
+          description: res.error ?? 'Save failed',
+          variant: 'fail',
+        })
+      }
+    } catch {
+      setEditingState('unsaved')
+      toast({
+        title: 'Error in the save request!',
+        description: 'An unexpected error occurred while saving.',
+        variant: 'fail',
+      })
+    }
+  }, [project, deviceDefinitions, editors, activeEditor, projectPort, setEditingState, setAllToSaved])
+
+  const handleSave = () => {
+    if (activeEditor.meta.name && !isSaving) {
+      void executeSave()
+    }
+  }
+
+  const handleSaveProject = () => {
+    if (!isSaving) {
+      void executeSave()
+    }
+  }
+
+  const handleCloseTab = () => {
+    handleRemoveTab(selectedTab)
+  }
+
+  const handleCloseProject = () => {
+    closeProject()
+  }
+
+  return (
+    <MenuPrimitive.Menu>
+      <MenuPrimitive.Trigger className={TRIGGER}>{i18n.t('menu:file.label')}</MenuPrimitive.Trigger>
+      <MenuPrimitive.Portal>
+        <MenuPrimitive.Content sideOffset={16} className={CONTENT}>
+          <MenuPrimitive.Item className={ITEM} onClick={handleSave} disabled={isSaving}>
+            <span>{i18n.t('menu:file.submenu.save')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + S'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} onClick={handleSaveProject} disabled={isSaving}>
+            <span>{i18n.t('menu:file.submenu.saveProject')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Shift + S'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} onClick={handleCloseTab}>
+            <span>{i18n.t('menu:file.submenu.closeTab')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + W'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} onClick={handleCloseProject}>
+            <span>{i18n.t('menu:file.submenu.closeProject')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Shift + W'}</span>
+          </MenuPrimitive.Item>
+          {capabilities.hasProjectExport && (
+            <>
+              <MenuPrimitive.Separator className={SEPARATOR} />
+              <MenuPrimitive.Item className={ITEM} disabled>
+                <span>{i18n.t('menu:file.submenu.exportToPLCOpenXml')}</span>
+              </MenuPrimitive.Item>
+            </>
+          )}
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:file.submenu.pageSetup')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Alt + P'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:file.submenu.preview')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + Shift + P'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:file.submenu.print')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + P'}</span>
+          </MenuPrimitive.Item>
+          <MenuPrimitive.Separator className={SEPARATOR} />
+          <MenuPrimitive.Item className={ITEM} disabled>
+            <span>{i18n.t('menu:file.submenu.updates')}</span>
+            <span className={ACCELERATOR}>{'Ctrl + U'}</span>
+          </MenuPrimitive.Item>
+        </MenuPrimitive.Content>
+      </MenuPrimitive.Portal>
+    </MenuPrimitive.Menu>
+  )
+}
diff --git a/src/frontend/components/_molecules/menu-bar/menus/help.tsx b/src/frontend/components/_molecules/menu-bar/menus/help.tsx
new file mode 100644
index 000000000..66b55a6bb
--- /dev/null
+++ b/src/frontend/components/_molecules/menu-bar/menus/help.tsx
@@ -0,0 +1,45 @@
+import * as MenuPrimitive from '@radix-ui/react-menubar'
+
+import { useCapabilities } from '../../../../../middleware/shared/providers'
+import { i18n } from '../../../../locales/i18n'
+import { useOpenPLCStore } from '../../../../store'
+import { MenuClasses } from '../constants'
+
+export const HelpMenu = () => {
+  const capabilities = useCapabilities()
+  const {
+    workspaceActions: { setModalOpen },
+  } = useOpenPLCStore()
+  const { TRIGGER, CONTENT, ITEM, ACCELERATOR } = MenuClasses
+
+  const handleOpenCommunitySupport = () => {
+    try {
+      window.open('https://openplc.discussion.community/', '_blank')
+    } catch (error) {
+      console.error('Error opening link:', error)
+    }
+  }
+
+  const handleOpenAboutModal = () => {
+    setModalOpen('aboutOpenPlc', true)
+  }
+
+  return (
+    <MenuPrimitive.Menu>
+      <MenuPrimitive.Trigger className={TRIGGER}>{i18n.t('menu:help.label')}</MenuPrimitive.Trigger>
+      <MenuPrimitive.Portal>
+        <MenuPrimitive.Content sideOffset={16} className={CONTENT}>
+          <MenuPrimitive.Item className={ITEM} onClick={handleOpenCommunitySupport}>
+            <span>{i18n.t('menu:help.submenu.communitySupport')}</span>
+            <span className={ACCELERATOR}>{'F1'}</span>
+          </MenuPrimitive.Item>
+          {capabilities.hasAboutDialog && (
+            <MenuPrimitive.Item className={ITEM} onClick={handleOpenAboutModal}>
+              <span>{i18n.t('menu:help.submenu.about')}</span>
+            </MenuPrimitive.Item>
+          )}
+        </MenuPrimitive.Content>
+      </MenuPrimitive.Portal>
+    </MenuPrimitive.Menu>
+  )
+}
diff --git a/src/frontend/components/_molecules/menu-bar/menus/recent.tsx b/src/frontend/components/_molecules/menu-bar/menus/recent.tsx
new file mode 100644
index 000000000..243aabc1e
--- /dev/null
+++ b/src/frontend/components/_molecules/menu-bar/menus/recent.tsx
@@ -0,0 +1,27 @@
+import * as MenuPrimitive from '@radix-ui/react-menubar'
+
+import { cn } from '../../../../utils/cn'
+import { MenuClasses } from '../constants'
+
+export const RecentMenu = () => {
+  const { TRIGGER, CONTENT, ITEM } = MenuClasses
+
+  return (
+    <MenuPrimitive.Menu>
+      <MenuPrimitive.Trigger className={TRIGGER}>Recent</MenuPrimitive.Trigger>
+      <MenuPrimitive.Portal>
+        <MenuPrimitive.Content sideOffset={16} className={CONTENT}>
+          <MenuPrimitive.Item
+            className={cn(
+              ITEM,
+              'flex items-center justify-normal gap-2 !overflow-hidden text-xs font-medium text-neutral-900 dark:text-neutral-50',
+            )}
+            disabled
+          >
+            <span className='flex-1 overflow-hidden text-xs opacity-50'>No recent projects</span>
+          </MenuPrimitive.Item>
+        </MenuPrimitive.Content>
+      </MenuPrimitive.Portal>
+    </MenuPrimitive.Menu>
+  )
+}
diff --git a/src2/frontend/components/_molecules/modal/index.tsx b/src/frontend/components/_molecules/modal/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/modal/index.tsx
rename to src/frontend/components/_molecules/modal/index.tsx
index d4f77f33c..7007200d7 100644
--- a/src2/frontend/components/_molecules/modal/index.tsx
+++ b/src/frontend/components/_molecules/modal/index.tsx
@@ -1,8 +1,9 @@
-import { CloseIcon } from '../../../assets/icons/interface/Close'
 import * as PrimitiveDialog from '@radix-ui/react-dialog'
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef, ElementRef, forwardRef } from 'react'
 
+import { CloseIcon } from '../../../assets/icons/interface/Close'
+import { cn } from '../../../utils/cn'
+
 const Modal = PrimitiveDialog.Root
 
 const ModalTrigger = PrimitiveDialog.Trigger
diff --git a/src2/frontend/components/_molecules/pin-mapping-table/combobox-input.tsx b/src/frontend/components/_molecules/pin-mapping-table/combobox-input.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/pin-mapping-table/combobox-input.tsx
rename to src/frontend/components/_molecules/pin-mapping-table/combobox-input.tsx
index 038c5adf8..6fd007945 100644
--- a/src2/frontend/components/_molecules/pin-mapping-table/combobox-input.tsx
+++ b/src/frontend/components/_molecules/pin-mapping-table/combobox-input.tsx
@@ -1,8 +1,8 @@
 import { CellContext } from '@tanstack/react-table'
 import { useCallback, useEffect, useState } from 'react'
 
-import { boardSelectors, pinSelectors } from '../../../hooks/use-store-selectors'
 import type { DevicePin } from '../../../../middleware/shared/ports/types'
+import { boardSelectors, pinSelectors } from '../../../hooks/use-store-selectors'
 import { GenericComboboxCell } from '../../_atoms/generic-table-inputs/generic-combobox-cell'
 import { toast } from '../../_features/[app]/toast/use-toast'
 
diff --git a/src2/frontend/components/_molecules/pin-mapping-table/select-input.tsx b/src/frontend/components/_molecules/pin-mapping-table/select-input.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/pin-mapping-table/select-input.tsx
rename to src/frontend/components/_molecules/pin-mapping-table/select-input.tsx
index 7f30f9ae2..24d8b401f 100644
--- a/src2/frontend/components/_molecules/pin-mapping-table/select-input.tsx
+++ b/src/frontend/components/_molecules/pin-mapping-table/select-input.tsx
@@ -1,8 +1,8 @@
-import type { DevicePin, PinType } from '../../../../middleware/shared/ports/types'
 import { CellContext } from '@tanstack/react-table'
 import { startCase } from 'lodash'
 import { useCallback, useEffect, useState } from 'react'
 
+import type { DevicePin, PinType } from '../../../../middleware/shared/ports/types'
 import { GenericSelectCell } from '../../_atoms/generic-table-inputs/generic-select-cell'
 import { toast } from '../../_features/[app]/toast/use-toast'
 
diff --git a/src2/frontend/components/_molecules/pin-mapping-table/text-input.tsx b/src/frontend/components/_molecules/pin-mapping-table/text-input.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/pin-mapping-table/text-input.tsx
rename to src/frontend/components/_molecules/pin-mapping-table/text-input.tsx
index 28aa97688..9a59954d1 100644
--- a/src2/frontend/components/_molecules/pin-mapping-table/text-input.tsx
+++ b/src/frontend/components/_molecules/pin-mapping-table/text-input.tsx
@@ -1,7 +1,7 @@
-import type { DevicePin } from '../../../../middleware/shared/ports/types'
 import { CellContext } from '@tanstack/react-table'
 import { useEffect, useState } from 'react'
 
+import type { DevicePin } from '../../../../middleware/shared/ports/types'
 import { GenericTextCell } from '../../_atoms/generic-table-inputs/generic-text-cell'
 import { toast } from '../../_features/[app]/toast/use-toast'
 
diff --git a/src2/frontend/components/_molecules/project-tree/index.tsx b/src/frontend/components/_molecules/project-tree/index.tsx
similarity index 96%
rename from src2/frontend/components/_molecules/project-tree/index.tsx
rename to src/frontend/components/_molecules/project-tree/index.tsx
index 20b476f66..0e6136a57 100644
--- a/src2/frontend/components/_molecules/project-tree/index.tsx
+++ b/src/frontend/components/_molecules/project-tree/index.tsx
@@ -1,8 +1,11 @@
 import * as Popover from '@radix-ui/react-popover'
+import { ComponentPropsWithoutRef, ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { CloseIcon } from '../../../assets/icons/interface/Close'
 import { ConfigIcon } from '../../../assets/icons/interface/Config'
 import { DeviceTransferIcon } from '../../../assets/icons/interface/DeviceTransfer'
+import { DuplicateIcon } from '../../../assets/icons/interface/Duplicate'
 import { MoreOptionsIcon } from '../../../assets/icons/interface/MoreOptions'
 import { PencilIcon } from '../../../assets/icons/interface/Pencil'
 import { ArrayIcon } from '../../../assets/icons/project/Array'
@@ -15,22 +18,20 @@ import { FunctionIcon } from '../../../assets/icons/project/Function'
 import { FunctionBlockIcon } from '../../../assets/icons/project/FunctionBlock'
 import { ILIcon } from '../../../assets/icons/project/IL'
 import { LDIcon } from '../../../assets/icons/project/LD'
+import { OrchestratorIcon } from '../../../assets/icons/project/Orchestrator'
 import { PLCIcon } from '../../../assets/icons/project/PLC'
 import { ProgramIcon } from '../../../assets/icons/project/Program'
 import { PythonIcon } from '../../../assets/icons/project/Python'
 import { RemoteDeviceIcon } from '../../../assets/icons/project/RemoteDevice'
 import { ResourceIcon } from '../../../assets/icons/project/Resource'
+import { ServerIcon } from '../../../assets/icons/project/Server'
 import { SFCIcon } from '../../../assets/icons/project/SFC'
 import { STIcon } from '../../../assets/icons/project/ST'
-import { ServerIcon } from '../../../assets/icons/project/Server'
 import { StructureIcon } from '../../../assets/icons/project/Structure'
-import { DuplicateIcon } from '../../../assets/icons/interface/Duplicate'
 import { useOpenPLCStore } from '../../../store'
 import { WorkspaceProjectTreeLeafType } from '../../../store/slices/workspace/types'
 import { cn } from '../../../utils/cn'
 import { isUnsaved, unsavedLabel } from '../../../utils/unsaved-label'
-import { ComponentPropsWithoutRef, ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react'
-
 import { toast } from '../../_features/[app]/toast/use-toast'
 
 const pousAllLanguages = ['il', 'st', 'python', 'cpp', 'ld', 'sfc', 'fbd'] as const
@@ -114,7 +115,7 @@ const ProjectTreeBranch = ({ branchTarget, children, ...res }: ProjectTreeBranch
   const { BranchIcon, label } = BranchSources[branchTarget]
   const handleBranchVisibility = useCallback(() => setBranchIsOpen(!branchIsOpen), [branchIsOpen])
   const hasAssociatedPou =
-    pous.some((pou) => pou.type === branchTarget) ||
+    pous.some((pou) => pou.pouType === branchTarget) ||
     branchTarget === 'device' ||
     (branchTarget === 'data-type' && dataTypes.length > 0) ||
     (branchTarget === 'server' && servers !== undefined && servers.length > 0) ||
@@ -252,6 +253,7 @@ type IProjectTreeLeafProps = ComponentPropsWithoutRef<'li'> & {
     | 'res'
     | 'devConfig'
     | 'devPin'
+    | 'devOrchestrators'
     | 'server'
     | 'remoteDevice'
   leafType: WorkspaceProjectTreeLeafType
@@ -272,6 +274,7 @@ const LeafSources = {
   res: { LeafIcon: ResourceIcon },
   devConfig: { LeafIcon: ConfigIcon },
   devPin: { LeafIcon: DeviceTransferIcon },
+  devOrchestrators: { LeafIcon: OrchestratorIcon },
   server: { LeafIcon: ServerIcon },
   remoteDevice: { LeafIcon: RemoteDeviceIcon },
 }
@@ -320,7 +323,7 @@ const ProjectTreeLeaf = ({ leafLang, leafType, label, onClick: handleLeafClick,
     setSelectedProjectTreeLeaf({ label, type: leafType })
   }
 
-  const handleRenameFile = async (newLabel: string) => {
+  const handleRenameFile = (newLabel: string) => {
     setIsEditing(false)
 
     if (!isAPou && !isDatatype && !isServer && !isRemoteDevice) {
@@ -342,39 +345,39 @@ const ProjectTreeLeaf = ({ leafLang, leafType, label, onClick: handleLeafClick,
     }
 
     if (isAPou) {
-      const res = await renamePou(label, newLabel)
-      if (!res.success) {
+      const res = renamePou(label, newLabel)
+      if (!res.ok) {
         setNewLabel(label || '')
       }
       return
     }
 
     if (isDatatype) {
-      const res = await renameDatatype(label, newLabel)
-      if (!res.success) {
+      const res = renameDatatype(label, newLabel)
+      if (!res.ok) {
         setNewLabel(label || '')
       }
       return
     }
 
     if (isServer) {
-      const res = await renameServer(label, newLabel)
-      if (!res.success) {
+      const res = renameServer(label, newLabel)
+      if (!res.ok) {
         setNewLabel(label || '')
       }
       return
     }
 
     if (isRemoteDevice) {
-      const res = await renameRemoteDevice(label, newLabel)
-      if (!res.success) {
+      const res = renameRemoteDevice(label, newLabel)
+      if (!res.ok) {
         setNewLabel(label || '')
       }
       return
     }
   }
 
-  const handleDuplicateFile = async () => {
+  const handleDuplicateFile = () => {
     if (!isAPou && !isDatatype) {
       toast({
         title: 'Error',
@@ -394,12 +397,12 @@ const ProjectTreeLeaf = ({ leafLang, leafType, label, onClick: handleLeafClick,
     }
 
     if (isAPou) {
-      await duplicatePou(label)
+      duplicatePou(label, `${label}_copy`)
       return
     }
 
     if (isDatatype) {
-      await duplicateDatatype(label)
+      duplicateDatatype(label, `${label}_copy`)
       return
     }
 
diff --git a/src2/frontend/components/_molecules/rename-impact-modal/index.tsx b/src/frontend/components/_molecules/rename-impact-modal/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/rename-impact-modal/index.tsx
rename to src/frontend/components/_molecules/rename-impact-modal/index.tsx
index ece6d93e2..6ccd2d5d7 100644
--- a/src2/frontend/components/_molecules/rename-impact-modal/index.tsx
+++ b/src/frontend/components/_molecules/rename-impact-modal/index.tsx
@@ -1,5 +1,4 @@
 import type { ReferenceImpactAnalysis } from '../../../utils/variable-reference-types'
-
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../modal'
 
 type RenameImpactModalProps = {
diff --git a/src2/frontend/components/_molecules/search/index.tsx b/src/frontend/components/_molecules/search/index.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/search/index.tsx
rename to src/frontend/components/_molecules/search/index.tsx
index d41e3fda1..1f70cb096 100644
--- a/src2/frontend/components/_molecules/search/index.tsx
+++ b/src/frontend/components/_molecules/search/index.tsx
@@ -1,6 +1,6 @@
-import { MagnifierIcon } from '../../../assets/icons/interface/Magnifier'
 import { ComponentPropsWithoutRef, createRef } from 'react'
 
+import { MagnifierIcon } from '../../../assets/icons/interface/Magnifier'
 import { InputWithRef } from '../../_atoms/input'
 
 type ISearchProps = ComponentPropsWithoutRef<'form'>
diff --git a/src2/frontend/components/_molecules/select-field/index.tsx b/src/frontend/components/_molecules/select-field/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/select-field/index.tsx
rename to src/frontend/components/_molecules/select-field/index.tsx
index 167259401..3167cd75f 100644
--- a/src2/frontend/components/_molecules/select-field/index.tsx
+++ b/src/frontend/components/_molecules/select-field/index.tsx
@@ -1,5 +1,4 @@
 import { cn } from '../../../utils/cn'
-
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../_atoms/select'
 
 const SelectField = ({
diff --git a/src/frontend/components/_molecules/tabs/index.tsx b/src/frontend/components/_molecules/tabs/index.tsx
new file mode 100644
index 000000000..890f4516a
--- /dev/null
+++ b/src/frontend/components/_molecules/tabs/index.tsx
@@ -0,0 +1,77 @@
+import { useEffect, useRef } from 'react'
+
+import { useHandleRemoveTab } from '../../../hooks/use-remove-tab'
+import { useOpenPLCStore } from '../../../store'
+import type { TabsProps } from '../../../store/slices/tabs'
+import { CreateEditorObjectFromTab } from '../../../store/slices/tabs/utils'
+import { Tab } from '../../_atoms/tab'
+import { TabList } from '../../_atoms/tab-list'
+
+const Tabs = () => {
+  const {
+    tabs,
+    editor,
+    tabsActions: { sortTabs },
+    editorActions: { setEditor, getEditorFromEditors },
+  } = useOpenPLCStore()
+  const { handleRemoveTab, selectedTab, setSelectedTab } = useHandleRemoveTab()
+  const hasTabs = tabs.length > 0
+  const dndTab = useRef<number>(0)
+  const replaceTab = useRef<number>(0)
+
+  const handleSort = () => {
+    const tabClone = [...tabs]
+    const draggedTab = tabClone[dndTab.current]
+    tabClone.splice(dndTab.current, 1)
+    tabClone.splice(replaceTab.current, 0, draggedTab)
+    sortTabs(tabClone)
+  }
+  /**
+   * Todo: this tab handler should be refactored to fit all possibles cases
+   * @param tab the selected tab
+   */
+  const handleClickedTab = (tab: TabsProps) => {
+    if (tab.name === selectedTab) return
+    setSelectedTab(tab.name)
+    const candidate = getEditorFromEditors(tab.name)
+    if (!candidate) {
+      setEditor(CreateEditorObjectFromTab(tab))
+      return
+    }
+    setEditor(candidate)
+  }
+
+  const handleDragStart = ({ tab, idx }: { tab: TabsProps; idx: number }) => {
+    dndTab.current = idx
+    setSelectedTab(tab.name)
+    setEditor(CreateEditorObjectFromTab(tab))
+  }
+  const handleDragEnter = (idx: number) => {
+    replaceTab.current = idx
+  }
+
+  useEffect(() => {
+    setSelectedTab(editor.meta.name)
+  }, [editor.meta.name, setSelectedTab])
+
+  return (
+    <TabList>
+      {hasTabs &&
+        tabs.map((element, idx) => (
+          <Tab
+            onDragStart={() => handleDragStart({ tab: element, idx })}
+            onDragEnter={() => handleDragEnter(idx)}
+            onDragEnd={() => handleSort()}
+            onDragOver={(e) => e.preventDefault()}
+            handleClickedTab={() => handleClickedTab(element)}
+            handleDeleteTab={() => handleRemoveTab(element.name)}
+            key={element.name}
+            fileName={element.name}
+            fileDerivation={element.elementType}
+            currentTab={selectedTab === element.name}
+          />
+        ))}
+    </TabList>
+  )
+}
+export { Tabs }
diff --git a/src2/frontend/components/_molecules/task-table/editable-cell.tsx b/src/frontend/components/_molecules/task-table/editable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/task-table/editable-cell.tsx
rename to src/frontend/components/_molecules/task-table/editable-cell.tsx
index 0e2ba7796..59277cdce 100644
--- a/src2/frontend/components/_molecules/task-table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/task-table/editable-cell.tsx
@@ -1,10 +1,10 @@
-import type { PLCTask } from '../../../../middleware/shared/ports/types'
-import type { ProjectResponse } from '../../../store/slices/project'
-import { useOpenPLCStore } from '../../../store'
-import { cn } from '../../../utils/cn'
 import type { CellContext, RowData } from '@tanstack/react-table'
 import { useEffect, useState } from 'react'
 
+import type { PLCTask } from '../../../../middleware/shared/ports/types'
+import { useOpenPLCStore } from '../../../store'
+import type { ProjectResponse } from '../../../store/slices/project'
+import { cn } from '../../../utils/cn'
 import { HighlightedText } from '../../_atoms/highlighted-text'
 import { InputWithRef } from '../../_atoms/input'
 import { useToast } from '../../_features/[app]/toast/use-toast'
diff --git a/src2/frontend/components/_molecules/task-table/index.tsx b/src/frontend/components/_molecules/task-table/index.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/task-table/index.tsx
rename to src/frontend/components/_molecules/task-table/index.tsx
index 99cec1f8b..23237074f 100644
--- a/src2/frontend/components/_molecules/task-table/index.tsx
+++ b/src/frontend/components/_molecules/task-table/index.tsx
@@ -1,6 +1,6 @@
-import type { PLCTask } from '../../../../middleware/shared/ports/types'
 import { createColumnHelper } from '@tanstack/react-table'
 
+import type { PLCTask } from '../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../store'
 import { GenericTable } from '../../_atoms/generic-table'
diff --git a/src2/frontend/components/_molecules/task-table/selectable-cell.tsx b/src/frontend/components/_molecules/task-table/selectable-cell.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/task-table/selectable-cell.tsx
rename to src/frontend/components/_molecules/task-table/selectable-cell.tsx
index 2b4ca0cfd..03c0656c9 100644
--- a/src2/frontend/components/_molecules/task-table/selectable-cell.tsx
+++ b/src/frontend/components/_molecules/task-table/selectable-cell.tsx
@@ -1,12 +1,12 @@
-import type { PLCTask } from '../../../../middleware/shared/ports/types'
-import { cn } from '../../../utils/cn'
 import type { CellContext } from '@tanstack/react-table'
 import _ from 'lodash'
 import { useEffect, useMemo, useState } from 'react'
 
+import type { PLCTask } from '../../../../middleware/shared/ports/types'
+import { cn } from '../../../utils/cn'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../_atoms/select'
-import { Modal, ModalContent, ModalTitle, ModalTrigger } from '../modal'
 import ArrowButtonGroup from '../../_features/[workspace]/editor/graphical/elements/arrow-button-group'
+import { Modal, ModalContent, ModalTitle, ModalTrigger } from '../modal'
 
 type ISelectableCellProps = CellContext<PLCTask, unknown> & { editable?: boolean }
 
diff --git a/src/renderer/components/_molecules/toast/index.tsx b/src/frontend/components/_molecules/toast/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/toast/index.tsx
rename to src/frontend/components/_molecules/toast/index.tsx
diff --git a/src2/frontend/components/_molecules/type-change-modal/index.tsx b/src/frontend/components/_molecules/type-change-modal/index.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/type-change-modal/index.tsx
rename to src/frontend/components/_molecules/type-change-modal/index.tsx
index 4d84e5156..a918676aa 100644
--- a/src2/frontend/components/_molecules/type-change-modal/index.tsx
+++ b/src/frontend/components/_molecules/type-change-modal/index.tsx
@@ -1,6 +1,5 @@
-import type { TypeChangeValidationResult } from '../../../store/slices/project/validation/type-change'
 import type { PLCVariable } from '../../../../middleware/shared/ports/types'
-
+import type { TypeChangeValidationResult } from '../../../store/slices/project/validation/type-change'
 import { Modal, ModalContent, ModalFooter, ModalHeader, ModalTitle } from '../modal'
 
 type TypeChangeModalProps = {
diff --git a/src2/frontend/components/_molecules/variables-panel/index.tsx b/src/frontend/components/_molecules/variables-panel/index.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/variables-panel/index.tsx
rename to src/frontend/components/_molecules/variables-panel/index.tsx
index 95877656a..f9f5bccd1 100644
--- a/src2/frontend/components/_molecules/variables-panel/index.tsx
+++ b/src/frontend/components/_molecules/variables-panel/index.tsx
@@ -1,9 +1,9 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
 
+import type { DebugTreeNode } from '../../../../middleware/shared/ports/types'
 import ViewIcon from '../../../assets/icons/interface/View'
 import ZapIcon from '../../../assets/icons/interface/Zap'
-import type { DebugTreeNode } from '../../../../middleware/shared/ports/types'
 import { cn } from '../../../utils/cn'
 import {
   floatToBuffer,
diff --git a/src2/frontend/components/_molecules/variables-table/editable-cell.tsx b/src/frontend/components/_molecules/variables-table/editable-cell.tsx
similarity index 98%
rename from src2/frontend/components/_molecules/variables-table/editable-cell.tsx
rename to src/frontend/components/_molecules/variables-table/editable-cell.tsx
index 12ca65c57..dfc6f4d70 100644
--- a/src2/frontend/components/_molecules/variables-table/editable-cell.tsx
+++ b/src/frontend/components/_molecules/variables-table/editable-cell.tsx
@@ -1,22 +1,22 @@
 import * as PrimitivePopover from '@radix-ui/react-popover'
+import type { CellContext, RowData } from '@tanstack/react-table'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
 import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import { pinSelectors, remoteDeviceSelectors } from '../../../hooks/use-store-selectors'
 import { useOpenPLCStore } from '../../../store'
 import { ProjectResponse } from '../../../store/slices/project'
+import { cn } from '../../../utils/cn'
+import { isLegalIdentifier, sanitizeVariableInput } from '../../../utils/keywords'
 import { buildRemoteDeviceOptionGroups } from '../../../utils/remote-device-options'
 import {
   findAllReferencesToVariable,
   propagateVariableRename,
   type ReferenceImpactAnalysis,
 } from '../../../utils/variable-references'
-import { cn } from '../../../utils/cn'
-import { isLegalIdentifier, sanitizeVariableInput } from '../../../utils/keywords'
-import type { CellContext, RowData } from '@tanstack/react-table'
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-
+import { GenericComboboxCell } from '../../_atoms/generic-table-inputs/generic-combobox-cell'
 import { HighlightedText } from '../../_atoms/highlighted-text'
 import { InputWithRef } from '../../_atoms/input'
-import { GenericComboboxCell } from '../../_atoms/generic-table-inputs/generic-combobox-cell'
 import { useToast } from '../../_features/[app]/toast/use-toast'
 import { RenameImpactModal } from '../rename-impact-modal'
 
@@ -49,7 +49,7 @@ const EditableNameCell = ({
     searchQuery,
     projectActions: { getVariable, updatePou, updateVariable },
     project: {
-      data: { pous, configuration },
+      data: { pous, configurations },
     },
     workspace: { isDebuggerVisible },
   } = useOpenPLCStore()
@@ -61,7 +61,7 @@ const EditableNameCell = ({
   const [impactAnalysis, setImpactAnalysis] = useState<ReferenceImpactAnalysis | null>(null)
   const confirmResolveRef = useRef<(v: boolean) => void>()
 
-  const globalVariables = configuration.resource.globalVariables
+  const globalVariables = configurations.resource.globalVariables
 
   const isExternalVariable = variable?.class === 'external'
 
@@ -248,7 +248,7 @@ const EditableNameCell = ({
   useEffect(() => {
     setVariable(
       getVariable({
-        variableId: table.options.data[index].id,
+        rowId: index,
         scope,
         associatedPou: editor.meta.name,
       }),
@@ -389,7 +389,7 @@ const EditableInitialValueCell = ({
   useEffect(() => {
     setVariable(
       getVariable({
-        variableId: table.options.data[index].id,
+        rowId: index,
         scope,
         associatedPou: editor.meta.name,
       }),
@@ -478,7 +478,7 @@ const EditableLocationCell = ({
   useEffect(() => {
     setVariable(
       getVariable({
-        variableId: table.options.data[index].id,
+        rowId: index,
         scope,
         associatedPou: editor.meta.name,
       }),
diff --git a/src2/frontend/components/_molecules/variables-table/elements/array-modal.tsx b/src/frontend/components/_molecules/variables-table/elements/array-modal.tsx
similarity index 95%
rename from src2/frontend/components/_molecules/variables-table/elements/array-modal.tsx
rename to src/frontend/components/_molecules/variables-table/elements/array-modal.tsx
index fdc6727f6..7db33b2ea 100644
--- a/src2/frontend/components/_molecules/variables-table/elements/array-modal.tsx
+++ b/src/frontend/components/_molecules/variables-table/elements/array-modal.tsx
@@ -1,11 +1,11 @@
 import { useEffect, useState } from 'react'
 import type { z } from 'zod'
 
-import { DimensionsModal } from '../../../_atoms/dimensions-modal'
-import { toast } from '../../../_features/[app]/toast/use-toast'
+import { baseTypeSchema } from '../../../../../middleware/shared/ports/plc-schemas'
 import { useOpenPLCStore } from '../../../../store'
 import { arrayValidation } from '../../../../store/slices/project/validation/variables'
-import { baseTypeSchema } from '../../../../../middleware/shared/ports/plc-schemas'
+import { DimensionsModal } from '../../../_atoms/dimensions-modal'
+import { toast } from '../../../_features/[app]/toast/use-toast'
 
 type BaseType = z.infer<typeof baseTypeSchema>
 
@@ -88,11 +88,11 @@ export const ArrayModal = ({
 
   useEffect(() => {
     const variable = pous
-      .find((pou) => pou.data.name === name)
-      ?.data.variables.find((variable) => variable.name === variableName)
+      .find((pou) => pou.name === name)
+      ?.interface?.variables?.find((variable) => variable.name === variableName)
     if (!variable) return
 
-    if (variable.type.definition === 'array') {
+    if (variable.type.definition === 'array' && variable.type.data) {
       setDimensions(variable.type.data.dimensions.map((dimension) => dimension.dimension))
       setTypeValue(variable.type.data.baseType.value)
     } else {
@@ -130,7 +130,7 @@ export const ArrayModal = ({
     setSelectedInput((index + 1).toString())
   }
 
-  const handleUpdateType = (value: BaseType) => {
+  const handleUpdateType = (value: string) => {
     setTypeValue(value)
   }
 
@@ -175,7 +175,6 @@ export const ArrayModal = ({
           definition: 'array',
           value: formatArrayName,
           data: {
-            // @ts-expect-error - This is a valid operation. This is being fixed.
             baseType: {
               definition: isBaseType ? 'base-type' : 'user-data-type',
               value: typeValue,
diff --git a/src2/frontend/components/_molecules/variables-table/index.tsx b/src/frontend/components/_molecules/variables-table/index.tsx
similarity index 94%
rename from src2/frontend/components/_molecules/variables-table/index.tsx
rename to src/frontend/components/_molecules/variables-table/index.tsx
index 1de9647af..25c9be4d2 100644
--- a/src2/frontend/components/_molecules/variables-table/index.tsx
+++ b/src/frontend/components/_molecules/variables-table/index.tsx
@@ -1,6 +1,6 @@
-import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import { ColumnFiltersState, createColumnHelper, OnChangeFn } from '@tanstack/react-table'
 
+import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import { usePouSnapshot } from '../../../hooks/use-pou-snapshot'
 import { useOpenPLCStore } from '../../../store'
 import { GenericTable } from '../../_atoms/generic-table'
@@ -138,6 +138,7 @@ const VariablesTable = ({
       data: { pous },
     },
     projectActions: { updateVariable },
+    sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
   } = useOpenPLCStore()
   const { captureAndPush } = usePouSnapshot()
 
@@ -159,14 +160,18 @@ const VariablesTable = ({
           }
         }
 
-        return updateVariable({
+        const result = updateVariable({
           scope: 'local',
           associatedPou: name,
-          variableId: tableData[rowIndex].id,
+          rowId: rowIndex,
           data: {
             [columnId]: value,
           },
         })
+        if (result.ok) {
+          handleFileAndWorkspaceSavedState(name)
+        }
+        return result
       }}
       tableContext='Variables'
       columnFilters={columnFilters}
diff --git a/src2/frontend/components/_molecules/variables-table/selectable-cell.tsx b/src/frontend/components/_molecules/variables-table/selectable-cell.tsx
similarity index 97%
rename from src2/frontend/components/_molecules/variables-table/selectable-cell.tsx
rename to src/frontend/components/_molecules/variables-table/selectable-cell.tsx
index 45e681db1..7af575a2f 100644
--- a/src2/frontend/components/_molecules/variables-table/selectable-cell.tsx
+++ b/src/frontend/components/_molecules/variables-table/selectable-cell.tsx
@@ -1,16 +1,16 @@
 import * as PrimitiveDropdown from '@radix-ui/react-dropdown-menu'
-import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
-import { DebuggerIcon } from '../../../assets/icons/interface/Debugger'
-import { useOpenPLCStore } from '../../../store'
-import { TypeChangeValidationResult, validateTypeChange, } from '../../../store/slices/project/validation/type-change'
-import { syncNodesWithVariables, syncNodesWithVariablesFBD } from '../../../utils/graphical/sync-nodes-with-variables'
-import type { PLCVariable } from '../../../../middleware/shared/ports/types'
-import { baseTypeSchema } from '../../../../middleware/shared/ports/plc-schemas'
-import { cn } from '../../../utils/cn'
 import type { CellContext } from '@tanstack/react-table'
 import _ from 'lodash'
 import { useEffect, useState } from 'react'
 
+import { baseTypeSchema } from '../../../../middleware/shared/ports/plc-schemas'
+import type { PLCVariable } from '../../../../middleware/shared/ports/types'
+import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
+import { DebuggerIcon } from '../../../assets/icons/interface/Debugger'
+import { useOpenPLCStore } from '../../../store'
+import { TypeChangeValidationResult, validateTypeChange } from '../../../store/slices/project/validation/type-change'
+import { cn } from '../../../utils/cn'
+import { syncNodesWithVariables, syncNodesWithVariablesFBD } from '../../../utils/graphical/sync-nodes-with-variables'
 import { InputWithRef } from '../../_atoms/input'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../_atoms/select'
 import { TypeChangeModal } from '../type-change-modal'
@@ -74,7 +74,7 @@ const SelectableTypeCell = ({
     {
       definition: 'system',
       values: sliceLibraries.system.flatMap((library) =>
-        library.pous.filter((pou) => pou.pouType === 'function-block').map((pou) => pou.name.toUpperCase()),
+        library.pous.filter((pou) => pou.type === 'function-block').map((pou) => pou.name.toUpperCase()),
       ),
     },
     {
@@ -82,11 +82,11 @@ const SelectableTypeCell = ({
       values: sliceLibraries.user
         .filter((userLibrary) => userLibrary.name !== editor.meta.name)
         .flatMap((userLibrary) =>
-          'pous' in userLibrary && Array.isArray((userLibrary as { pous: { pouType: string; name: string }[] }).pous)
-            ? (userLibrary as { pous: { pouType: string; name: string }[] }).pous
-                .filter((pou) => pou.pouType === 'function-block')
+          'pous' in userLibrary && Array.isArray((userLibrary as { pous: { type: string; name: string }[] }).pous)
+            ? (userLibrary as { pous: { type: string; name: string }[] }).pous
+                .filter((pou) => pou.type === 'function-block')
                 .map((pou) => pou.name.toUpperCase())
-            : userLibrary.pouType === 'function-block'
+            : userLibrary.type === 'function-block'
               ? [userLibrary.name.toUpperCase()]
               : [],
         ),
@@ -271,10 +271,7 @@ const SelectableTypeCell = ({
         />
       )}
       <PrimitiveDropdown.Root onOpenChange={setPoppoverIsOpen} open={poppoverIsOpen}>
-        <PrimitiveDropdown.Trigger
-          asChild
-          disabled={isDebuggerVisible}
-        >
+        <PrimitiveDropdown.Trigger asChild disabled={isDebuggerVisible}>
           <div
             className={cn('flex h-full w-full cursor-pointer justify-center p-2 outline-none', {
               'pointer-events-none': !selected || isDebuggerVisible,
diff --git a/src2/frontend/components/_molecules/window-controls/index.tsx b/src/frontend/components/_molecules/window-controls/index.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/window-controls/index.tsx
rename to src/frontend/components/_molecules/window-controls/index.tsx
index 558d7a9fb..4f0360428 100644
--- a/src2/frontend/components/_molecules/window-controls/index.tsx
+++ b/src/frontend/components/_molecules/window-controls/index.tsx
@@ -1,10 +1,10 @@
+import { useWindow } from '../../../../middleware/shared/providers'
 import { CloseWindowIcon } from '../../../assets/icons/window-controls/Close'
 import { ExitMaximizeIcon } from '../../../assets/icons/window-controls/Exit-Maximize'
 import { MaximizeIcon } from '../../../assets/icons/window-controls/Maximize'
 import { MinimizeIcon } from '../../../assets/icons/window-controls/Minimize'
-import { WindowControlButton } from '../../_atoms/buttons/window-control'
 import { useOpenPLCStore } from '../../../store'
-import { useWindow } from '../../../../middleware/shared/providers'
+import { WindowControlButton } from '../../_atoms/buttons/window-control'
 
 const MinimizeButton = () => {
   const windowPort = useWindow()
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/chat.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/chat.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/default/chat.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/default/chat.tsx
index c9c3570d5..2e76ff302 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/chat.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/chat.tsx
@@ -1,6 +1,5 @@
 import { useOpenPLCStore } from '../../../../store'
 import { cn } from '../../../../utils/cn'
-
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
 
 export const ChatButton = () => {
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/debugger.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/debugger.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/default/debugger.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/default/debugger.tsx
index f136097c3..6791c971d 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/debugger.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/debugger.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import { DebuggerIcon } from '../../../../assets/icons/interface/Debugger'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 type DebuggerButtonProps = ComponentPropsWithoutRef<typeof ActivityBarButton> & {
   isActive?: boolean
diff --git a/src/frontend/components/_molecules/workspace-activity-bar/default/download.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/download.tsx
new file mode 100644
index 000000000..1544144ff
--- /dev/null
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/download.tsx
@@ -0,0 +1,14 @@
+import { DownloadIcon } from '../../../../assets/icons/interface/Download'
+import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
+
+type DownloadButtonProps = { onClick?: () => void; disabled?: boolean; className?: string }
+
+const DownloadButton = ({ onClick, disabled, className }: DownloadButtonProps) => {
+  return (
+    <ActivityBarButton aria-label='Download' onClick={onClick} disabled={disabled} className={className}>
+      <DownloadIcon />
+    </ActivityBarButton>
+  )
+}
+
+export { DownloadButton }
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/exit.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/exit.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/default/exit.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/default/exit.tsx
index a240e76d3..5704e5956 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/exit.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/exit.tsx
@@ -1,7 +1,8 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import { CloseFilledIcon } from '../../../../assets/icons/interface/Close'
 import { StickArrowIcon } from '../../../../assets/icons/interface/StickArrow'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const ExitButton = ({ onClick }: ComponentPropsWithoutRef<'button'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/play.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/play.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/default/play.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/default/play.tsx
index 998200a8a..f39fd155e 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/play.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/play.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react'
+
 import { PlayIcon } from '../../../../assets/icons/interface/Play'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef, ReactNode } from 'react'
 
 type PlayButtonProps = ComponentPropsWithoutRef<typeof ActivityBarButton> & {
   children?: ReactNode
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/search.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/search.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/default/search.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/default/search.tsx
index 8605a444e..c44a22379 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/search.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/search.tsx
@@ -1,6 +1,5 @@
 import { SearchIcon } from '../../../../assets/icons/interface/Search'
 import { useOpenPLCStore } from '../../../../store'
-
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
 import SearchInProject from '../../../_features/[workspace]/editor/search-in-project'
 import { Modal, ModalContent, ModalTitle, ModalTrigger } from '../../modal'
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/zoom.tsx b/src/frontend/components/_molecules/workspace-activity-bar/default/zoom.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/workspace-activity-bar/default/zoom.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/default/zoom.tsx
index 685d667fe..8ebde914b 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/zoom.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/default/zoom.tsx
@@ -1,6 +1,6 @@
-import { ZoomInOut } from '../../../../assets/icons/interface/ZoomInOut'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { ZoomInOut } from '../../../../assets/icons/interface/ZoomInOut'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
 
 export const ZoomButton = (props: ComponentPropsWithoutRef<'button'>) => {
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/block.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/block.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/block.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/block.tsx
index e900d0a37..dc6370777 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/block.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/block.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import BlockIcon from '../../../../assets/icons/project/fbd/Block'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const BlockButton = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/comment.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/comment.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/comment.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/comment.tsx
index 361093ba9..cf9683dba 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/comment.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/comment.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import CommentIcon from '../../../../assets/icons/project/fbd/Comment'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const Comment = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/connector.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/connector.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/connector.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/connector.tsx
index 7fa7c063f..5ff55b169 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/connector.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/connector.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import ConnectorIcon from '../../../../assets/icons/project/fbd/Connector'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const Connector = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/continuation.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
index 4c857a127..c477ebfbd 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import ContinuationIcon from '../../../../assets/icons/project/fbd/Continuation'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const Continuation = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
index 33a0d919b..fe5611738 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import VariableInOutIcon from '../../../../assets/icons/project/fbd/VariableInOut'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const InOutVariable = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
index 3d9227afc..00b9150fc 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import VariableInIcon from '../../../../assets/icons/project/fbd/VariableIn'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const InputVariable = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
index 5ffe93f14..ff2691eb1 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import VariableOutIcon from '../../../../assets/icons/project/fbd/VariableOut'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const OutVariable = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/block.tsx b/src/frontend/components/_molecules/workspace-activity-bar/ladder/block.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/ladder/block.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/ladder/block.tsx
index e4d0aaa0d..0efd224bb 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/block.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/ladder/block.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import BlockIcon from '../../../../assets/icons/project/ladder/Block'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const BlockButton = ({ onDragStart, onDragEnd }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/coil.tsx b/src/frontend/components/_molecules/workspace-activity-bar/ladder/coil.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/ladder/coil.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/ladder/coil.tsx
index 26eb0dbca..0ba3d519f 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/coil.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/ladder/coil.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import CoilIcon from '../../../../assets/icons/project/ladder/Coil'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const CoilButton = ({ onDragStart }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/contact.tsx b/src/frontend/components/_molecules/workspace-activity-bar/ladder/contact.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/ladder/contact.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/ladder/contact.tsx
index 58e72af6d..584f690a5 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/contact.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/ladder/contact.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import ContactIcon from '../../../../assets/icons/project/ladder/Contact'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const ContactButton = ({ onDragStart }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/parallel.tsx b/src/frontend/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
similarity index 99%
rename from src2/frontend/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
index ed0cb218f..a302733da 100644
--- a/src2/frontend/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
+++ b/src/frontend/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
@@ -1,6 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react'
+
 import LoopIcon from '../../../../assets/icons/project/Loop'
 import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-import { ComponentPropsWithoutRef } from 'react'
 
 export const ParallelButton = ({ onDragStart }: ComponentPropsWithoutRef<'div'>) => {
   return (
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/tooltip-button.tsx b/src/frontend/components/_molecules/workspace-activity-bar/tooltip-button.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/tooltip-button.tsx
rename to src/frontend/components/_molecules/workspace-activity-bar/tooltip-button.tsx
diff --git a/src2/frontend/components/_organisms/about-modal/index.tsx b/src/frontend/components/_organisms/about-modal/index.tsx
similarity index 92%
rename from src2/frontend/components/_organisms/about-modal/index.tsx
rename to src/frontend/components/_organisms/about-modal/index.tsx
index 4f7b735f8..755979700 100644
--- a/src2/frontend/components/_organisms/about-modal/index.tsx
+++ b/src/frontend/components/_organisms/about-modal/index.tsx
@@ -1,8 +1,8 @@
-import openPlcLogo from '../../../assets/icons/about/logo.svg'
-import { useOpenPLCStore } from '../../../store'
-import { useAccelerator, useSystem } from '../../../../middleware/shared/providers'
 import { useEffect, useState } from 'react'
 
+import { useAccelerator, useCapabilities, useSystem } from '../../../../middleware/shared/providers'
+import openPlcLogo from '../../../assets/icons/about/logo.svg'
+import { useOpenPLCStore } from '../../../store'
 import { Modal, ModalContent } from '../../_molecules/modal'
 
 const AboutModal = () => {
@@ -10,6 +10,7 @@ const AboutModal = () => {
     workspaceActions: { setModalOpen },
     workspace: { isModalOpen },
   } = useOpenPLCStore()
+  const capabilities = useCapabilities()
   const system = useSystem()
   const accelerator = useAccelerator()
 
@@ -44,11 +45,12 @@ const AboutModal = () => {
   }
 
   useEffect(() => {
+    if (!capabilities.hasAboutDialog) return
     const unsubscribe = accelerator.onAbout(() => {
       openAboutModal()
     })
     return unsubscribe
-  }, [])
+  }, [capabilities.hasAboutDialog])
 
   return (
     <Modal onOpenChange={handleOpenChange} open={isAboutModalOpen}>
diff --git a/src2/frontend/components/_organisms/console/__tests__/log.test.tsx b/src/frontend/components/_organisms/console/__tests__/log.test.tsx
similarity index 98%
rename from src2/frontend/components/_organisms/console/__tests__/log.test.tsx
rename to src/frontend/components/_organisms/console/__tests__/log.test.tsx
index b9a42eb3e..046bf9dc9 100644
--- a/src2/frontend/components/_organisms/console/__tests__/log.test.tsx
+++ b/src/frontend/components/_organisms/console/__tests__/log.test.tsx
@@ -1,6 +1,6 @@
 import { render, screen } from '@testing-library/react'
 
-import { LogComponent, type LogLevel } from '../log'
+import { LogComponent } from '../log'
 
 describe('LogComponent', () => {
   it('renders message text', () => {
diff --git a/src2/frontend/components/_organisms/console/filters.tsx b/src/frontend/components/_organisms/console/filters.tsx
similarity index 97%
rename from src2/frontend/components/_organisms/console/filters.tsx
rename to src/frontend/components/_organisms/console/filters.tsx
index 92edec6b2..b9a0d19dc 100644
--- a/src2/frontend/components/_organisms/console/filters.tsx
+++ b/src/frontend/components/_organisms/console/filters.tsx
@@ -1,9 +1,10 @@
+import { ChevronDown, Download, Filter, Search, X } from 'lucide-react'
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
 import { useOpenPLCStore } from '../../../store'
 import { TimestampFormat } from '../../../store/slices/console/types'
 import { cn } from '../../../utils/cn'
 import formatTimestamp from '../../../utils/format-timestamp'
-import { ChevronDown, Download, Filter, Search, X } from 'lucide-react'
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
 type LogLevel = 'debug' | 'info' | 'warning' | 'error'
 type ExportFormat = 'txt' | 'csv' | 'json'
@@ -123,7 +124,7 @@ const ConsoleFilters = memo(() => {
       if (filters.searchTerm) {
         const searchLower = filters.searchTerm.toLowerCase()
         const messageMatch = log.message.toLowerCase().includes(searchLower)
-        const timestampMatch = log.tstamp.toISOString().includes(searchLower)
+        const timestampMatch = log.tstamp?.toISOString().includes(searchLower) ?? false
         if (!messageMatch && !timestampMatch) return false
       }
       return true
@@ -141,7 +142,7 @@ const ConsoleFilters = memo(() => {
         case 'json':
           content = JSON.stringify(
             filteredLogs.map((log) => ({
-              timestamp: log.tstamp.toISOString(),
+              timestamp: (log.tstamp ?? new Date()).toISOString(),
               level: log.level || 'info',
               message: log.message,
             })),
@@ -156,7 +157,7 @@ const ConsoleFilters = memo(() => {
           content += filteredLogs
             .map((log) => {
               const escapedMessage = `"${log.message.replace(/"/g, '""')}"`
-              return `${log.tstamp.toISOString()},${log.level || 'info'},${escapedMessage}`
+              return `${(log.tstamp ?? new Date()).toISOString()},${log.level || 'info'},${escapedMessage}`
             })
             .join('\n')
           mimeType = 'text/csv'
@@ -166,7 +167,7 @@ const ConsoleFilters = memo(() => {
           content = filteredLogs
             .map(
               (log) =>
-                `[${formatTimestamp(log.tstamp, 'full')}] [${(log.level || 'info').toUpperCase()}]: ${log.message}`,
+                `[${formatTimestamp(log.tstamp ?? new Date(), 'full')}] [${(log.level || 'info').toUpperCase()}]: ${log.message}`,
             )
             .join('\n')
           mimeType = 'text/plain'
diff --git a/src2/frontend/components/_organisms/console/index.tsx b/src/frontend/components/_organisms/console/index.tsx
similarity index 93%
rename from src2/frontend/components/_organisms/console/index.tsx
rename to src/frontend/components/_organisms/console/index.tsx
index 627ea7c53..a4a896a7b 100644
--- a/src2/frontend/components/_organisms/console/index.tsx
+++ b/src/frontend/components/_organisms/console/index.tsx
@@ -1,8 +1,8 @@
-import { useOpenPLCStore } from '../../../store'
-import formatTimestamp from '../../../utils/format-timestamp'
 import { debounce } from 'lodash'
 import { memo, useEffect, useMemo, useRef } from 'react'
 
+import { useOpenPLCStore } from '../../../store'
+import formatTimestamp from '../../../utils/format-timestamp'
 import { LogComponent } from './log'
 
 const Console = memo(() => {
@@ -23,7 +23,7 @@ const Console = memo(() => {
       if (filters.searchTerm) {
         const searchLower = filters.searchTerm.toLowerCase()
         const messageMatch = log.message.toLowerCase().includes(searchLower)
-        const timestampMatch = log.tstamp.toISOString().includes(searchLower)
+        const timestampMatch = log.tstamp?.toISOString().includes(searchLower) ?? false
         if (!messageMatch && !timestampMatch) return false
       }
 
@@ -82,7 +82,7 @@ const Console = memo(() => {
             key={log.id}
             level={log.level}
             message={log.message}
-            tstamp={formatTimestamp(log.tstamp, filters.timestampFormat)}
+            tstamp={formatTimestamp(log.tstamp ?? new Date(), filters.timestampFormat)}
             searchTerm={filters.searchTerm}
           />
         ))}
diff --git a/src2/frontend/components/_organisms/console/log.tsx b/src/frontend/components/_organisms/console/log.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/console/log.tsx
rename to src/frontend/components/_organisms/console/log.tsx
index 280b16893..e780ef492 100644
--- a/src2/frontend/components/_organisms/console/log.tsx
+++ b/src/frontend/components/_organisms/console/log.tsx
@@ -1,7 +1,8 @@
-import { cn } from '../../../utils/cn'
 import { Copy } from 'lucide-react'
 import { ComponentPropsWithoutRef, useCallback, useEffect, useRef, useState } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const messageClasses = {
   debug: 'text-neutral-500 dark:text-neutral-400',
   warning: 'text-yellow-600',
diff --git a/src2/frontend/components/_organisms/debugger/index.tsx b/src/frontend/components/_organisms/debugger/index.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/debugger/index.tsx
rename to src/frontend/components/_organisms/debugger/index.tsx
index ba50d1506..5814e90da 100644
--- a/src2/frontend/components/_organisms/debugger/index.tsx
+++ b/src/frontend/components/_organisms/debugger/index.tsx
@@ -1,10 +1,10 @@
 import * as Select from '@radix-ui/react-select'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { PauseIcon } from '../../../assets/icons/interface/Pause'
 import { PlayIcon } from '../../../assets/icons/interface/Play'
 import { useOpenPLCStore } from '../../../store'
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-
 import { Button } from '../../_atoms/buttons/default'
 import { LineChart } from '../../_molecules/charts/line-chart'
 
@@ -181,7 +181,7 @@ const Debugger = ({ graphList }: DebuggerData) => {
           {renderSeries.series.map(({ name, points, isBool }) => (
             <LineChart
               key={name}
-              data={points}
+              data={points.map((p) => ({ x: p.t, y: p.y }))}
               isBool={isBool}
               range={range}
               now={renderSeries.now}
diff --git a/src2/frontend/components/_organisms/display-recent-projects/index.tsx b/src/frontend/components/_organisms/display-recent-projects/index.tsx
similarity index 83%
rename from src2/frontend/components/_organisms/display-recent-projects/index.tsx
rename to src/frontend/components/_organisms/display-recent-projects/index.tsx
index 5651ba3af..43f7df591 100644
--- a/src2/frontend/components/_organisms/display-recent-projects/index.tsx
+++ b/src/frontend/components/_organisms/display-recent-projects/index.tsx
@@ -1,9 +1,10 @@
-import { File as FileElement } from '../../_atoms/file'
-import { toast } from '../../_features/[app]/toast/use-toast'
-import { useOpenPLCStore } from '../../../store'
-import { useSystem, useProject } from '../../../../middleware/shared/providers'
 import { ComponentProps, useEffect, useRef, useState } from 'react'
 
+import { useProject, useSystem } from '../../../../middleware/shared/providers'
+import { useOpenPLCStore } from '../../../store'
+import { File } from '../../_atoms/file'
+import { toast } from '../../_features/[app]/toast/use-toast'
+
 export type IDisplayRecentProjectProps = ComponentProps<'section'> & {
   searchNameFilterValue: string
 }
@@ -12,6 +13,7 @@ const DisplayRecentProjects = ({ searchNameFilterValue, ...props }: IDisplayRece
   const {
     workspace: { recent },
     workspaceActions: { setRecent },
+    sharedWorkspaceActions: { handleOpenProjectResponse },
   } = useOpenPLCStore()
 
   const system = useSystem()
@@ -91,15 +93,17 @@ const DisplayRecentProjects = ({ searchNameFilterValue, ...props }: IDisplayRece
   }
 
   const handleOpenProjectByPath = async (projectPath: string) => {
-    const result = await project.openProject(projectPath)
-    if (!result.ok) {
-      void updateUserRecentProjects()
-      toast({
-        title: 'Cannot open the project.',
-        description: result.message ?? `The path ${projectPath} does not exist on this computer.`,
-        variant: 'fail',
-      })
+    const result = await project.openProjectByPath(projectPath)
+    if (result.success && result.data) {
+      handleOpenProjectResponse(result.data)
+      return
     }
+    void updateUserRecentProjects()
+    toast({
+      title: 'Cannot open the project.',
+      description: result.error?.description ?? `The path ${projectPath} does not exist on this computer.`,
+      variant: 'fail',
+    })
   }
 
   return (
@@ -112,18 +116,14 @@ const DisplayRecentProjects = ({ searchNameFilterValue, ...props }: IDisplayRece
       </h2>
       <div className='scroll-area flex h-auto w-full flex-wrap  gap-[25px] overflow-y-auto'>
         {recentProjects.map((proj) => (
-          <FileElement.Root
+          <File
             onClick={() => void handleOpenProjectByPath(proj.path)}
-            className='overflow-hidden '
+            className='overflow-hidden'
             key={proj.path}
-          >
-            <FileElement.Label
-              projectName={proj.name}
-              projectPath={proj.path}
-              lastModified={projectTimes[proj.path]}
-            />
-            <FileElement.Shape />
-          </FileElement.Root>
+            projectName={proj.name}
+            projectPath={proj.path}
+            lastModified={projectTimes[proj.path]}
+          />
         ))}
       </div>
     </section>
diff --git a/src2/frontend/components/_organisms/explorer/__tests__/info.test.tsx b/src/frontend/components/_organisms/explorer/__tests__/info.test.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/explorer/__tests__/info.test.tsx
rename to src/frontend/components/_organisms/explorer/__tests__/info.test.tsx
diff --git a/src2/frontend/components/_organisms/explorer/index.tsx b/src/frontend/components/_organisms/explorer/index.tsx
similarity index 95%
rename from src2/frontend/components/_organisms/explorer/index.tsx
rename to src/frontend/components/_organisms/explorer/index.tsx
index 4ca641a18..5cf03414d 100644
--- a/src2/frontend/components/_organisms/explorer/index.tsx
+++ b/src/frontend/components/_organisms/explorer/index.tsx
@@ -1,7 +1,7 @@
-import { useOpenPLCStore } from '../../../store'
 import { LegacyRef, ReactElement, useState } from 'react'
 import { ImperativePanelHandle } from 'react-resizable-panels'
 
+import { useOpenPLCStore } from '../../../store'
 import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from '../panel'
 import { Info } from './info'
 import { Library } from './library'
@@ -47,7 +47,7 @@ const Explorer = ({ collapse }: ExplorerProps): ReactElement => {
 
   // System Libraries filtering with type and text filter
   const filteredLibraries = system.filter((library) =>
-    pous.find((pou) => pou.data.name === editor.meta.name)?.type === 'function'
+    pous.find((pou) => pou.name === editor.meta.name)?.pouType === 'function'
       ? library.pous.some((pou) => pou.name.toLowerCase().includes(filterText) && pou.type === 'function')
       : library.pous.some((pou) => pou.name.toLowerCase().includes(filterText)),
   )
@@ -69,14 +69,14 @@ const Explorer = ({ collapse }: ExplorerProps): ReactElement => {
       className="flex h-full w-[200px] max-w-lg flex-col overflow-auto rounded-lg border-2 border-inherit border-neutral-200 bg-white data-[panel-size='0.0']:hidden dark:border-neutral-850 dark:bg-neutral-950"
     >
       <ResizablePanelGroup id='explorerPanelGroup' direction='vertical' className='h-full flex-1'>
-        <ResizablePanel id='projectExplorerPanel' order={1} defaultSize={40} minSize={25} collapsible>
+        <ResizablePanel id='projectExplorerPanel' order={1} defaultSize={50} minSize={25} collapsible>
           <Project />
         </ResizablePanel>
         <ResizableHandle
           style={{ height: '1px' }}
           className={`bg-neutral-200 transition-colors duration-200 data-[resize-handle-active='pointer']:bg-brand-light data-[resize-handle-state='hover']:bg-brand-light dark:bg-neutral-850 data-[resize-handle-active='pointer']:dark:bg-neutral-700  data-[resize-handle-state='hover']:dark:bg-neutral-700 `}
         />
-        <ResizablePanel id='libraryExplorerPanel' order={2} defaultSize={40} collapsible minSize={20}>
+        <ResizablePanel id='libraryExplorerPanel' order={2} defaultSize={50} collapsible minSize={20}>
           <Library
             filterText={filterText}
             setFilterText={setFilterText}
diff --git a/src/renderer/components/_organisms/explorer/info.tsx b/src/frontend/components/_organisms/explorer/info.tsx
similarity index 100%
rename from src/renderer/components/_organisms/explorer/info.tsx
rename to src/frontend/components/_organisms/explorer/info.tsx
diff --git a/src2/frontend/components/_organisms/explorer/library.tsx b/src/frontend/components/_organisms/explorer/library.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/explorer/library.tsx
rename to src/frontend/components/_organisms/explorer/library.tsx
index 2d21ad306..fd1f2ec01 100644
--- a/src2/frontend/components/_organisms/explorer/library.tsx
+++ b/src/frontend/components/_organisms/explorer/library.tsx
@@ -1,9 +1,9 @@
+import { ReactNode, useEffect, useRef, useState } from 'react'
+
 import { BookIcon } from '../../../assets/icons/interface/Book'
 import { CloseIcon } from '../../../assets/icons/interface/Close'
 import { MagnifierIcon } from '../../../assets/icons/interface/Magnifier'
 import { useOpenPLCStore } from '../../../store'
-import { ReactNode, useEffect, useRef, useState } from 'react'
-
 import { InputWithRef } from '../../_atoms/input'
 import { LibraryFile, LibraryFolder, LibraryRoot } from '../../_molecules/library-tree'
 
diff --git a/src2/frontend/components/_organisms/explorer/project.tsx b/src/frontend/components/_organisms/explorer/project.tsx
similarity index 71%
rename from src2/frontend/components/_organisms/explorer/project.tsx
rename to src/frontend/components/_organisms/explorer/project.tsx
index 9faad6849..b4603f8d6 100644
--- a/src2/frontend/components/_organisms/explorer/project.tsx
+++ b/src/frontend/components/_organisms/explorer/project.tsx
@@ -1,17 +1,21 @@
-import { ProjectTreeBranch, ProjectTreeLeaf, ProjectTreeRoot } from '../../_molecules/project-tree'
+import { useEffect, useState } from 'react'
+
+import { useCapabilities } from '../../../../middleware/shared/providers'
 import { FolderIcon } from '../../../assets/icons/interface/Folder'
 import { useOpenPLCStore } from '../../../store'
+import { extractSearchQuery } from '../../../store/slices/search/utils'
 import type { TabsProps } from '../../../store/slices/tabs'
 import { CreateEditorObjectFromTab } from '../../../store/slices/tabs/utils'
-import { extractSearchQuery } from '../../../store/slices/search/utils'
-import { useEffect, useState } from 'react'
-
 import { CreatePLCElement } from '../../_features/[workspace]/create-element'
+import { ProjectTreeBranch, ProjectTreeLeaf, ProjectTreeRoot } from '../../_molecules/project-tree'
+
+type PouLeafLang = 'il' | 'st' | 'ld' | 'sfc' | 'fbd' | 'python' | 'cpp'
 
 const Project = () => {
+  const capabilities = useCapabilities()
   const {
     project: {
-      data: { pous, dataTypes, configuration, servers, remoteDevices },
+      data: { pous, dataTypes, configurations, servers, remoteDevices },
       meta: { name },
     },
     projectActions: { updateMetaName },
@@ -95,19 +99,19 @@ const Project = () => {
           {/* Project Functions tree branch */}
           <ProjectTreeBranch branchTarget='function'>
             {pous
-              ?.filter(({ type }) => type === 'function')
-              .sort((a, b) => a.data.name.localeCompare(b.data.name))
-              .map(({ data }) => (
+              ?.filter((pou) => pou.pouType === 'function')
+              .sort((a, b) => a.name.localeCompare(b.name))
+              .map((pou) => (
                 <ProjectTreeLeaf
-                  key={data.name}
-                  leafLang={data.language}
+                  key={pou.name}
+                  leafLang={pou.body.language as PouLeafLang}
                   leafType='function'
-                  label={searchQuery ? extractSearchQuery(data.name, searchQuery) : data.name}
+                  label={searchQuery ? extractSearchQuery(pou.name, searchQuery) : pou.name}
                   onClick={() =>
                     handleCreateTab({
-                      name: data.name,
-                      path: `/data/pous/function/${data.name}`,
-                      elementType: { type: 'function', language: data.language },
+                      name: pou.name,
+                      path: `/data/pous/function/${pou.name}`,
+                      elementType: { type: 'function', language: pou.body.language as PouLeafLang },
                     })
                   }
                 />
@@ -117,19 +121,19 @@ const Project = () => {
           {/* Project Function Blocks tree branch */}
           <ProjectTreeBranch branchTarget='function-block'>
             {pous
-              ?.filter(({ type }) => type === 'function-block')
-              .sort((a, b) => a.data.name.localeCompare(b.data.name))
-              .map(({ data }) => (
+              ?.filter((pou) => pou.pouType === 'function-block')
+              .sort((a, b) => a.name.localeCompare(b.name))
+              .map((pou) => (
                 <ProjectTreeLeaf
-                  key={data.name}
-                  leafLang={data.language}
+                  key={pou.name}
+                  leafLang={pou.body.language as PouLeafLang}
                   leafType='function-block'
-                  label={searchQuery ? extractSearchQuery(data.name, searchQuery) : data.name}
+                  label={searchQuery ? extractSearchQuery(pou.name, searchQuery) : pou.name}
                   onClick={() =>
                     handleCreateTab({
-                      name: data.name,
-                      path: `/data/pous/function-block/${data.name}`,
-                      elementType: { type: 'function-block', language: data.language },
+                      name: pou.name,
+                      path: `/data/pous/function-block/${pou.name}`,
+                      elementType: { type: 'function-block', language: pou.body.language as PouLeafLang },
                     })
                   }
                 />
@@ -139,19 +143,19 @@ const Project = () => {
           {/* Project Programs tree branch */}
           <ProjectTreeBranch branchTarget='program'>
             {pous
-              ?.filter(({ type }) => type === 'program')
-              .sort((a, b) => a.data.name.localeCompare(b.data.name))
-              .map(({ data }) => (
+              ?.filter((pou) => pou.pouType === 'program')
+              .sort((a, b) => a.name.localeCompare(b.name))
+              .map((pou) => (
                 <ProjectTreeLeaf
-                  key={data.name}
-                  leafLang={data.language}
+                  key={pou.name}
+                  leafLang={pou.body.language as PouLeafLang}
                   leafType='program'
-                  label={searchQuery ? extractSearchQuery(data.name, searchQuery) : data.name}
+                  label={searchQuery ? extractSearchQuery(pou.name, searchQuery) : pou.name}
                   onClick={() =>
                     handleCreateTab({
-                      name: data.name,
-                      path: `/data/pous/program/${data.name}`,
-                      elementType: { type: 'program', language: data.language },
+                      name: pou.name,
+                      path: `/data/pous/program/${pou.name}`,
+                      elementType: { type: 'program', language: pou.body.language as PouLeafLang },
                     })
                   }
                 />
@@ -165,7 +169,6 @@ const Project = () => {
               .sort((a, b) => a.name.localeCompare(b.name))
               .map(({ name }) => (
                 <ProjectTreeLeaf
-                  nested={true}
                   key={name}
                   leafLang='arr'
                   leafType='data-type'
@@ -184,7 +187,6 @@ const Project = () => {
               .sort((a, b) => a.name.localeCompare(b.name))
               .map(({ name }) => (
                 <ProjectTreeLeaf
-                  nested={true}
                   key={name}
                   leafLang='enum'
                   leafType='data-type'
@@ -204,7 +206,6 @@ const Project = () => {
               .sort((a, b) => a.name.localeCompare(b.name))
               .map(({ name }) => (
                 <ProjectTreeLeaf
-                  nested={true}
                   key={name}
                   leafLang='str'
                   leafType='data-type'
@@ -226,7 +227,7 @@ const Project = () => {
             branchTarget='resource'
             onClick={() => {
               handleCreateTab({
-                configuration: configuration,
+                configuration: configurations,
                 name: 'Resource',
                 path: `/data/configuration/resource`,
                 elementType: { type: 'resource' },
@@ -240,53 +241,59 @@ const Project = () => {
 
           {/* Project Device tree branch */}
           <ProjectTreeBranch branchTarget='device'>
-            <ProjectTreeLeaf
-              key='Configuration'
-              leafLang='devConfig'
-              leafType='device'
-              label='Configuration'
-              onClick={() =>
-                handleCreateTab({
-                  name: 'Configuration',
-                  path: `/device/configuration`,
-                  elementType: { type: 'device', derivation: 'configuration' },
-                })
-              }
-            />
-            <ProjectTreeLeaf
-              leafLang='devOrchestrators'
-              leafType='device'
-              label='Orchestrators'
-              onClick={() =>
-                handleCreateTab({
-                  name: 'Orchestrators',
-                  path: `/device/orchestrators`,
-                  elementType: { type: 'device', derivation: 'orchestrators' },
-                })
-              }
-            />
+            {capabilities.hasLocalSerialPorts && (
+              <ProjectTreeLeaf
+                key='Configuration'
+                leafLang='devConfig'
+                leafType='device'
+                label='Configuration'
+                onClick={() =>
+                  handleCreateTab({
+                    name: 'Configuration',
+                    path: `/device/configuration`,
+                    elementType: { type: 'device', derivation: 'configuration' },
+                  })
+                }
+              />
+            )}
+            {capabilities.hasOrchestratorDevices && (
+              <ProjectTreeLeaf
+                leafLang='devOrchestrators'
+                leafType='device'
+                label='Orchestrators'
+                onClick={() =>
+                  handleCreateTab({
+                    name: 'Orchestrators',
+                    path: `/device/orchestrators`,
+                    elementType: { type: 'device', derivation: 'orchestrators' },
+                  })
+                }
+              />
+            )}
           </ProjectTreeBranch>
 
           {/* Project Servers tree branch */}
-          <ProjectTreeBranch branchTarget='server'>
-            {[...(servers || [])]
-              .sort((a, b) => a.name.localeCompare(b.name))
-              .map((server) => (
-                <ProjectTreeLeaf
-                  key={server.name}
-                  leafLang='server'
-                  leafType='server'
-                  label={searchQuery ? extractSearchQuery(server.name, searchQuery) : server.name}
-                  onClick={() =>
-                    handleCreateTab({
-                      name: server.name,
-                      path: `/servers/${server.name}`,
-                      elementType: { type: 'server', protocol: server.protocol },
-                    })
-                  }
-                />
-              ))}
-          </ProjectTreeBranch>
+          {capabilities.hasLocalSerialPorts && (
+            <ProjectTreeBranch branchTarget='server'>
+              {[...(servers || [])]
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map((server) => (
+                  <ProjectTreeLeaf
+                    key={server.name}
+                    leafLang='server'
+                    leafType='server'
+                    label={searchQuery ? extractSearchQuery(server.name, searchQuery) : server.name}
+                    onClick={() =>
+                      handleCreateTab({
+                        name: server.name,
+                        path: `/servers/${server.name}`,
+                        elementType: { type: 'server', protocol: server.protocol },
+                      })
+                    }
+                  />
+                ))}
+            </ProjectTreeBranch>
+          )}
 
           {/* Project Remote Devices tree branch */}
           <ProjectTreeBranch branchTarget='remote-device'>
diff --git a/src2/frontend/components/_organisms/global-variables-editor/index.tsx b/src/frontend/components/_organisms/global-variables-editor/index.tsx
similarity index 91%
rename from src2/frontend/components/_organisms/global-variables-editor/index.tsx
rename to src/frontend/components/_organisms/global-variables-editor/index.tsx
index 67d70a410..8eb31492f 100644
--- a/src2/frontend/components/_organisms/global-variables-editor/index.tsx
+++ b/src/frontend/components/_organisms/global-variables-editor/index.tsx
@@ -1,20 +1,20 @@
 // import * as PrimitiveSwitch from '@radix-ui/react-switch'
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import type { PLCGlobalVariable } from '../../../../middleware/shared/ports/types'
+import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { MinusIcon } from '../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../assets/icons/interface/StickArrow'
-import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { TableIcon } from '../../../assets/icons/interface/TableIcon'
 import { useOpenPLCStore } from '../../../store'
 import type { GlobalVariablesTableType } from '../../../store/slices/editor'
-import { PLCGlobalVariable } from '../../../../middleware/shared/ports/types'
 import { cn } from '../../../utils/cn'
-import { useEffect, useRef, useState } from 'react'
-
+import { parseIecStringToVariables } from '../../../utils/generate-iec-string-to-variables'
+import { generateIecVariablesToString } from '../../../utils/generate-iec-variables-to-string'
 import TableActions from '../../_atoms/table-actions'
 import { toast } from '../../_features/[app]/toast/use-toast'
 import { GlobalVariablesTable } from '../../_molecules/global-variables-table'
-import { parseIecStringToVariables } from '../../../utils/generate-iec-string-to-variables'
-import { generateIecVariablesToString } from '../../../utils/generate-iec-variables-to-string'
 import { VariablesCodeEditor } from '../variables-code-editor'
 
 const GlobalVariablesEditor = () => {
@@ -26,15 +26,36 @@ const GlobalVariablesEditor = () => {
     },
     project: {
       data: {
-        configuration: {
+        configurations: {
           resource: { globalVariables },
         },
       },
     },
     editorActions: { updateModelVariables, updateModelVariablesForName },
-    projectActions: { createVariable, deleteVariable, rearrangeVariables, setGlobalVariables, pushToHistory },
+    projectActions: { createVariable, deleteVariable, rearrangeVariables, setGlobalVariables },
     sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
+    workspaceActions: { removeDebugVariable },
+  } = useOpenPLCStore()
+
+  const {
+    project: {
+      data: { pous: snapshotPous, configurations },
+    },
+    snapshotActions: { pushToHistory: rawPushToHistory },
   } = useOpenPLCStore()
+
+  const pushToHistory = useCallback(
+    (pouName: string) => {
+      const pou = snapshotPous.find((p) => p.name === pouName)
+      if (!pou) return
+      rawPushToHistory(pouName, {
+        variables: pou.interface?.variables ?? [],
+        body: pou.body.value,
+        globalVariables: configurations.resource.globalVariables,
+      })
+    },
+    [snapshotPous, configurations.resource.globalVariables, rawPushToHistory],
+  )
   /**
    * Table data and column filters states to keep track of the table data and column filters
    */
@@ -61,7 +82,7 @@ const GlobalVariablesEditor = () => {
    */
   useEffect(() => {
     const variablesToTable = globalVariables.filter((variable) => variable.name)
-    setTableData(variablesToTable)
+    setTableData(variablesToTable as PLCGlobalVariable[])
   }, [editor, globalVariables])
 
   useEffect(() => {
@@ -194,7 +215,7 @@ const GlobalVariablesEditor = () => {
         scope: 'global',
         data: {
           name: 'GlobalVar',
-          type: { definition: 'base-type', value: 'dint' },
+          type: { definition: 'base-type', value: 'DINT' },
           class: 'global',
           location: '',
           documentation: '',
@@ -210,8 +231,9 @@ const GlobalVariablesEditor = () => {
       return
     }
 
-    const variable: PLCGlobalVariable =
+    const variable = (
       selectedRow === ROWS_NOT_SELECTED ? variables[variables.length - 1] : variables[selectedRow]
+    ) as PLCGlobalVariable
 
     if (selectedRow === ROWS_NOT_SELECTED) {
       createVariable({ scope: 'global', data: { ...variable } })
@@ -241,6 +263,10 @@ const GlobalVariablesEditor = () => {
     pushToHistory(editor.meta.name)
 
     const selectedRow = parseInt(editorVariables.selectedRow)
+    const variableToDelete = globalVariables.filter((v) => v.name)[selectedRow]
+    if (variableToDelete) {
+      removeDebugVariable(`resource:${variableToDelete.name}`)
+    }
     deleteVariable({ scope: 'global', rowId: selectedRow })
 
     const variables = globalVariables.filter((variable) => variable.name)
@@ -301,7 +327,7 @@ const GlobalVariablesEditor = () => {
           {editorVariables.display === 'table' && (
             <div
               aria-label='Variables editor table actions container'
-              className='flex h-full w-28 items-center justify-evenly *:rounded-md *:p-1 mr-2'
+              className='mr-2 flex h-full w-28 items-center justify-evenly *:rounded-md *:p-1'
             >
               <TableActions
                 actions={[
diff --git a/src2/frontend/components/_organisms/graphical-editor/ladder/rung/index.tsx b/src/frontend/components/_organisms/graphical-editor/ladder/rung/index.tsx
similarity index 95%
rename from src2/frontend/components/_organisms/graphical-editor/ladder/rung/index.tsx
rename to src/frontend/components/_organisms/graphical-editor/ladder/rung/index.tsx
index 5c3cd958c..05ed0934c 100644
--- a/src2/frontend/components/_organisms/graphical-editor/ladder/rung/index.tsx
+++ b/src/frontend/components/_organisms/graphical-editor/ladder/rung/index.tsx
@@ -4,12 +4,13 @@
  */
 import { useSortable } from '@dnd-kit/sortable'
 import { CSS } from '@dnd-kit/utilities'
-import { RungBody } from '../../../../_molecules/graphical-editor/ladder/rung/body'
-import { RungHeader } from '../../../../_molecules/graphical-editor/ladder/rung/header'
+import { useEffect, useState } from 'react'
+
 import { useOpenPLCStore } from '../../../../../store'
 import type { RungLadderState } from '../../../../../store/slices/ladder'
 import { cn } from '../../../../../utils/cn'
-import { useEffect, useState } from 'react'
+import { RungBody } from '../../../../_molecules/graphical-editor/ladder/rung/body'
+import { RungHeader } from '../../../../_molecules/graphical-editor/ladder/rung/header'
 
 type RungProps = {
   className?: string
@@ -38,12 +39,10 @@ export const Rung = ({ className, index, id, rung, nodeDivergences, isDebuggerAc
 
   useEffect(() => {
     updateModelLadder({ openRung: { rungId: rung.id, open: isOpen } })
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   useEffect(() => {
     setIsOpen(getIsRungOpen({ rungId: rung.id }))
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [rung])
 
   const style = {
diff --git a/src2/frontend/components/_organisms/instances-editor/index.tsx b/src/frontend/components/_organisms/instances-editor/index.tsx
similarity index 93%
rename from src2/frontend/components/_organisms/instances-editor/index.tsx
rename to src/frontend/components/_organisms/instances-editor/index.tsx
index f0cef44c7..936476251 100644
--- a/src2/frontend/components/_organisms/instances-editor/index.tsx
+++ b/src/frontend/components/_organisms/instances-editor/index.tsx
@@ -1,16 +1,16 @@
+import { useCallback, useEffect, useState } from 'react'
+
+import type { PLCInstance } from '../../../../middleware/shared/ports/types'
+import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { MinusIcon } from '../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../assets/icons/interface/StickArrow'
-import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { TableIcon } from '../../../assets/icons/interface/TableIcon'
 import { useOpenPLCStore } from '../../../store'
 import type { InstanceType } from '../../../store/slices/editor'
-import type { PLCInstance } from '../../../../middleware/shared/ports/types'
 import { cn } from '../../../utils/cn'
 import { parseResourceConfigurationToString } from '../../../utils/parse-resource-configuration-to-string'
 import { parseResourceStringToConfiguration } from '../../../utils/parse-resource-string-to-configuration'
-import { useEffect, useState } from 'react'
-
 import TableActions from '../../_atoms/table-actions'
 import { toast } from '../../_features/[app]/toast/use-toast'
 import { InstancesTable } from '../../_molecules/instances-table'
@@ -26,16 +26,36 @@ const InstancesEditor = () => {
     },
     project: {
       data: {
-        configuration: {
+        configurations: {
           resource: { instances, tasks },
         },
       },
     },
     editorActions: { updateModelInstances },
-    projectActions: { createInstance, rearrangeInstances, deleteInstance, setInstances, setTasks, pushToHistory },
+    projectActions: { createInstance, rearrangeInstances, deleteInstance, setInstances, setTasks },
     sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
   } = useOpenPLCStore()
 
+  const {
+    project: {
+      data: { pous: snapshotPous, configurations },
+    },
+    snapshotActions: { pushToHistory: rawPushToHistory },
+  } = useOpenPLCStore()
+
+  const pushToHistory = useCallback(
+    (pouName: string) => {
+      const pou = snapshotPous.find((p) => p.name === pouName)
+      if (!pou) return
+      rawPushToHistory(pouName, {
+        variables: pou.interface?.variables ?? [],
+        body: pou.body.value,
+        globalVariables: configurations.resource.globalVariables,
+      })
+    },
+    [snapshotPous, configurations.resource.globalVariables, rawPushToHistory],
+  )
+
   const [instanceData, setInstanceData] = useState<PLCInstance[]>([])
   const [editorCode, setEditorCode] = useState(() => parseResourceConfigurationToString(tasks, instanceData))
   const [parseError, setParseError] = useState<string | null>(null)
@@ -91,7 +111,6 @@ const InstancesEditor = () => {
         selectedRow: editorInstances.display === 'table' ? parseInt(editorInstances.selectedRow) : ROWS_NOT_SELECTED,
       })
     } else {
-      // @ts-expect-error: 'selectedRow' is not required when display is 'code'
       updateModelInstances({
         display: 'code',
       })
@@ -126,8 +145,8 @@ const InstancesEditor = () => {
       createInstance({
         data: {
           name: 'instance0',
-          pouName: '',
-          taskName: '',
+          program: '',
+          task: '',
         },
       })
       updateModelInstances({
diff --git a/src2/frontend/components/_organisms/modals/confirm-device-switch-modal.tsx b/src/frontend/components/_organisms/modals/confirm-device-switch-modal.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/modals/confirm-device-switch-modal.tsx
rename to src/frontend/components/_organisms/modals/confirm-device-switch-modal.tsx
index 05a4ae3a3..15743c701 100644
--- a/src2/frontend/components/_organisms/modals/confirm-device-switch-modal.tsx
+++ b/src/frontend/components/_organisms/modals/confirm-device-switch-modal.tsx
@@ -1,6 +1,5 @@
 import { WarningIcon } from '../../../assets/icons/interface/Warning'
 import { useOpenPLCStore } from '../../../store'
-
 import { Modal, ModalContent } from '../../_molecules/modal'
 
 const ConfirmDeviceSwitchModal = () => {
diff --git a/src2/frontend/components/_organisms/modals/debugger-ip-input-modal.tsx b/src/frontend/components/_organisms/modals/debugger-ip-input-modal.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/modals/debugger-ip-input-modal.tsx
rename to src/frontend/components/_organisms/modals/debugger-ip-input-modal.tsx
index 1e6d34145..7b31360d5 100644
--- a/src2/frontend/components/_organisms/modals/debugger-ip-input-modal.tsx
+++ b/src/frontend/components/_organisms/modals/debugger-ip-input-modal.tsx
@@ -1,6 +1,6 @@
-import { useOpenPLCStore } from '../../../store'
 import { useEffect, useState } from 'react'
 
+import { useOpenPLCStore } from '../../../store'
 import { Label } from '../../_atoms/label'
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
diff --git a/src2/frontend/components/_organisms/modals/debugger-message-modal.tsx b/src/frontend/components/_organisms/modals/debugger-message-modal.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/modals/debugger-message-modal.tsx
rename to src/frontend/components/_organisms/modals/debugger-message-modal.tsx
index e4afbfdf0..d12f9d65a 100644
--- a/src2/frontend/components/_organisms/modals/debugger-message-modal.tsx
+++ b/src/frontend/components/_organisms/modals/debugger-message-modal.tsx
@@ -1,5 +1,4 @@
 import { useOpenPLCStore } from '../../../store'
-
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
 const DebuggerMessageModal = () => {
diff --git a/src2/frontend/components/_organisms/modals/delete-confirmation-modal.tsx b/src/frontend/components/_organisms/modals/delete-confirmation-modal.tsx
similarity index 97%
rename from src2/frontend/components/_organisms/modals/delete-confirmation-modal.tsx
rename to src/frontend/components/_organisms/modals/delete-confirmation-modal.tsx
index 5a965d4d2..15c2e6b07 100644
--- a/src2/frontend/components/_organisms/modals/delete-confirmation-modal.tsx
+++ b/src/frontend/components/_organisms/modals/delete-confirmation-modal.tsx
@@ -1,10 +1,9 @@
-import { BasicNodeData } from '../../_atoms/graphical-editor/ladder/utils/types'
-import { toast } from '../../_features/[app]/toast/use-toast'
-import { useOpenPLCStore } from '../../../store'
-import type { RungLadderState } from '../../../store/slices/ladder'
 import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import { WarningIcon } from '../../../assets/icons/interface/Warning'
-
+import { useOpenPLCStore } from '../../../store'
+import type { RungLadderState } from '../../../store/slices/ladder'
+import { BasicNodeData } from '../../_atoms/graphical-editor/ladder/utils/types'
+import { toast } from '../../_features/[app]/toast/use-toast'
 import { Modal, ModalContent } from '../../_molecules/modal'
 
 type ConfirmDeleteElementProps = {
@@ -29,7 +28,9 @@ const compareVariableTypes = (type1: PLCVariable['type'], type2: PLCVariable['ty
  * Resolve the element name and type from modal data.
  * Handles both the new format `{ name, elementType }` and the legacy format `{ leafLang, label }`.
  */
-function resolveDeleteTarget(data: unknown): { name: string; elementType: 'pou' | 'datatype' | 'server' | 'remote-device' } | null {
+function resolveDeleteTarget(
+  data: unknown,
+): { name: string; elementType: 'pou' | 'datatype' | 'server' | 'remote-device' } | null {
   if (!data || typeof data !== 'object') return null
 
   // New format from shared slice deleteRequest actions
@@ -108,7 +109,7 @@ const ConfirmDeleteElementModal = ({ rung, isOpen, ...rest }: ConfirmDeleteEleme
           variableIndex = variables.findIndex((variable) => {
             if (variable.name.toLowerCase() !== variableData.name.toLowerCase()) return false
             if ('type' in variableData && variableData.type) {
-              return compareVariableTypes(variable.type, variableData.type as PLCVariable['type'])
+              return compareVariableTypes(variable.type, variableData.type)
             }
             return true
           })
diff --git a/src/frontend/components/_organisms/modals/index.ts b/src/frontend/components/_organisms/modals/index.ts
new file mode 100644
index 000000000..7eaaf7ed2
--- /dev/null
+++ b/src/frontend/components/_organisms/modals/index.ts
@@ -0,0 +1,2 @@
+export { RuntimeCreateUserModal } from './runtime-create-user-modal'
+export { RuntimeLoginModal } from './runtime-login-modal'
diff --git a/src2/frontend/components/_organisms/modals/quit-application-modal.tsx b/src/frontend/components/_organisms/modals/quit-application-modal.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/modals/quit-application-modal.tsx
rename to src/frontend/components/_organisms/modals/quit-application-modal.tsx
index e0b4dfc70..703ef8cf4 100644
--- a/src2/frontend/components/_organisms/modals/quit-application-modal.tsx
+++ b/src/frontend/components/_organisms/modals/quit-application-modal.tsx
@@ -1,8 +1,8 @@
-import { WarningIcon } from '../../../assets/icons/interface/Warning'
-import { useOpenPLCStore } from '../../../store'
-import { useWindow } from '../../../../middleware/shared/providers'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { useWindow } from '../../../../middleware/shared/providers'
+import { WarningIcon } from '../../../assets/icons/interface/Warning'
+import { useOpenPLCStore } from '../../../store'
 import { Modal, ModalContent } from '../../_molecules/modal'
 
 type QuitApplicationModalProps = ComponentPropsWithoutRef<typeof Modal> & {
diff --git a/src2/frontend/components/_organisms/modals/runtime-connection-lost-modal.tsx b/src/frontend/components/_organisms/modals/runtime-connection-lost-modal.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/modals/runtime-connection-lost-modal.tsx
rename to src/frontend/components/_organisms/modals/runtime-connection-lost-modal.tsx
index cd9cf382b..472af5cb5 100644
--- a/src2/frontend/components/_organisms/modals/runtime-connection-lost-modal.tsx
+++ b/src/frontend/components/_organisms/modals/runtime-connection-lost-modal.tsx
@@ -1,6 +1,5 @@
 import { WarningIcon } from '../../../assets/icons/interface/Warning'
 import { useOpenPLCStore } from '../../../store'
-
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
 const RuntimeConnectionLostModal = () => {
diff --git a/src2/frontend/components/_organisms/modals/runtime-create-user-modal.tsx b/src/frontend/components/_organisms/modals/runtime-create-user-modal.tsx
similarity index 98%
rename from src2/frontend/components/_organisms/modals/runtime-create-user-modal.tsx
rename to src/frontend/components/_organisms/modals/runtime-create-user-modal.tsx
index aa7a69d6f..9585bc2c5 100644
--- a/src2/frontend/components/_organisms/modals/runtime-create-user-modal.tsx
+++ b/src/frontend/components/_organisms/modals/runtime-create-user-modal.tsx
@@ -1,7 +1,8 @@
-import { useOpenPLCStore } from '../../../store'
-import { useRuntime } from '../../../../middleware/shared/providers'
 import { useState } from 'react'
 
+import { useRuntime } from '../../../../middleware/shared/providers'
+import { useOpenPLCStore } from '../../../store'
+import { getErrorMessage } from '../../../utils/get-error-message'
 import { Label } from '../../_atoms/label'
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
@@ -53,7 +54,7 @@ const RuntimeCreateUserModal = () => {
         setError('Failed to create user: ' + (result.error || 'Unknown error'))
       }
     } catch (err) {
-      setError('Error: ' + String(err))
+      setError('Error: ' + getErrorMessage(err))
     } finally {
       setIsLoading(false)
     }
diff --git a/src2/frontend/components/_organisms/modals/runtime-login-modal.tsx b/src/frontend/components/_organisms/modals/runtime-login-modal.tsx
similarity index 97%
rename from src2/frontend/components/_organisms/modals/runtime-login-modal.tsx
rename to src/frontend/components/_organisms/modals/runtime-login-modal.tsx
index c559629f1..aa01f0714 100644
--- a/src2/frontend/components/_organisms/modals/runtime-login-modal.tsx
+++ b/src/frontend/components/_organisms/modals/runtime-login-modal.tsx
@@ -1,7 +1,8 @@
-import { useOpenPLCStore } from '../../../store'
-import { useRuntime } from '../../../../middleware/shared/providers'
 import { useState } from 'react'
 
+import { useRuntime } from '../../../../middleware/shared/providers'
+import { useOpenPLCStore } from '../../../store'
+import { getErrorMessage } from '../../../utils/get-error-message'
 import { Label } from '../../_atoms/label'
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
@@ -42,7 +43,7 @@ const RuntimeLoginModal = () => {
         setError('Login failed: ' + (result.error || 'Invalid credentials'))
       }
     } catch (err) {
-      setError('Error: ' + String(err))
+      setError('Error: ' + getErrorMessage(err))
     } finally {
       setIsLoading(false)
     }
diff --git a/src/frontend/components/_organisms/modals/save-changes-file-modal.tsx b/src/frontend/components/_organisms/modals/save-changes-file-modal.tsx
new file mode 100644
index 000000000..4d93f3e37
--- /dev/null
+++ b/src/frontend/components/_organisms/modals/save-changes-file-modal.tsx
@@ -0,0 +1,164 @@
+import { ComponentPropsWithoutRef } from 'react'
+
+import { useProject } from '../../../../middleware/shared/providers'
+import { WarningIcon } from '../../../assets/icons/interface/Warning'
+import { useOpenPLCStore } from '../../../store'
+import type { FBDFlowType } from '../../../store/slices/fbd'
+import type { LadderFlowType } from '../../../store/slices/ladder'
+import { getExtensionFromLanguage, getFolderFromPouType } from '../../../utils/PLC/pou-file-extensions'
+import { parseGraphicalPouFromString, parseTextualPouFromString } from '../../../utils/PLC/pou-text-parser'
+import { prepareSavePayload } from '../../../utils/save-project'
+import { toast } from '../../_features/[app]/toast/use-toast'
+import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
+
+export type SaveChangesFileModalData = {
+  fileName: string
+}
+
+export type SaveChangesFileModalProps = ComponentPropsWithoutRef<typeof Modal> & {
+  isOpen: boolean
+  data: SaveChangesFileModalData
+}
+
+const SaveChangesFileModal = ({ isOpen, data, ...rest }: SaveChangesFileModalProps) => {
+  const {
+    project,
+    editor: activeEditor,
+    editors,
+    deviceDefinitions,
+    modalActions: { closeModal, onOpenChange },
+    projectActions: { updatePou },
+    sharedWorkspaceActions: { forceCloseFile },
+    fileActions: { updateFile, setAllToSaved },
+    workspaceActions: { setEditingState },
+    snapshotActions: { markAllSaved },
+    ladderFlowActions: { addLadderFlow },
+    fbdFlowActions: { addFBDFlow },
+  } = useOpenPLCStore()
+
+  const projectPort = useProject()
+  const { fileName } = data
+
+  const handleSave = async () => {
+    closeModal()
+
+    const params = prepareSavePayload({
+      projectPath: project.meta.path,
+      projectName: project.meta.name,
+      projectData: project.data,
+      deviceConfiguration: deviceDefinitions.configuration,
+      devicePinMapping: deviceDefinitions.pinMapping.pins,
+      editors,
+      activeEditor,
+    })
+    const result = await projectPort.saveProject(params)
+    if (!result.success) {
+      toast({
+        title: 'Error saving file!',
+        description: result.error ?? 'Save failed',
+        variant: 'fail',
+      })
+      return
+    }
+
+    setEditingState('saved')
+    setAllToSaved()
+    markAllSaved()
+    forceCloseFile(fileName)
+  }
+
+  const handleDontSave = async () => {
+    closeModal()
+
+    // Reload the POU from disk to discard in-memory changes
+    const pou = project.data.pous.find((p) => p.name === fileName)
+    if (pou) {
+      try {
+        const language = pou.body.language
+        const ext = getExtensionFromLanguage(language)
+        const folder = getFolderFromPouType(pou.pouType)
+        const fullPath = `${project.meta.path}/pous/${folder}/${fileName}${ext}`
+
+        const result = await projectPort.readFileContent(fullPath)
+        if (result.success && result.content) {
+          const isGraphical = language === 'ld' || language === 'fbd'
+
+          const parsed = isGraphical
+            ? parseGraphicalPouFromString(result.content, language, pou.pouType)
+            : parseTextualPouFromString(result.content, language, pou.pouType)
+
+          // Restore POU body in the project store
+          updatePou({ name: fileName, content: parsed.body })
+
+          // For graphical POUs, also restore the flow state (nodes, edges, positions).
+          // The parsed body.value is the full flow type (same as what addLadderFlow/addFBDFlow
+          // receive during project open).
+          if (language === 'ld' && parsed.body.value) {
+            addLadderFlow(parsed.body.value as LadderFlowType)
+          } else if (language === 'fbd' && parsed.body.value) {
+            addFBDFlow(parsed.body.value as FBDFlowType)
+          }
+        }
+      } catch {
+        // If reload fails, just close without restoring — same as web fallback
+      }
+    }
+
+    updateFile({ name: fileName, saved: true })
+    forceCloseFile(fileName)
+  }
+
+  const handleCancel = () => {
+    closeModal()
+  }
+
+  return (
+    <Modal
+      open={isOpen}
+      onOpenChange={(open) => {
+        if (!open) {
+          handleCancel()
+        }
+        onOpenChange('save-changes-file', open)
+      }}
+      {...rest}
+    >
+      <ModalContent className='flex h-[420px] w-[340px] select-none flex-col items-center justify-evenly rounded-lg'>
+        <ModalTitle className='hidden'>Save file changes</ModalTitle>
+        <div className='flex h-[350px] select-none flex-col items-center gap-6'>
+          <WarningIcon className='mr-2 mt-2 h-[73px] w-[73px]' />
+          <div>
+            <p className='text-m w-full text-center font-bold text-gray-600 dark:text-neutral-100'>
+              <strong>{fileName}</strong> has unsaved changes. Do you want to save before closing?
+            </p>
+          </div>
+
+          <div className='flex w-[300px] flex-col text-sm'>
+            <div className='mb-6 flex flex-col gap-2'>
+              <button
+                onClick={() => void handleSave()}
+                className='w-full rounded-lg bg-brand px-4 py-2 text-center font-medium text-white'
+              >
+                Save
+              </button>
+              <button
+                onClick={() => void handleDontSave()}
+                className='w-full rounded-lg bg-neutral-100 px-4 py-2 text-center font-medium text-neutral-1000 dark:bg-neutral-850 dark:text-neutral-100'
+              >
+                Don't Save
+              </button>
+            </div>
+            <button
+              onClick={handleCancel}
+              className='w-full rounded-lg bg-neutral-100 px-4 py-2 text-center font-medium text-neutral-1000 dark:bg-neutral-850 dark:text-neutral-100'
+            >
+              Cancel
+            </button>
+          </div>
+        </div>
+      </ModalContent>
+    </Modal>
+  )
+}
+
+export { SaveChangesFileModal }
diff --git a/src2/frontend/components/_organisms/modals/save-changes-modal.tsx b/src/frontend/components/_organisms/modals/save-changes-modal.tsx
similarity index 77%
rename from src2/frontend/components/_organisms/modals/save-changes-modal.tsx
rename to src/frontend/components/_organisms/modals/save-changes-modal.tsx
index e70018918..03a7728a4 100644
--- a/src2/frontend/components/_organisms/modals/save-changes-modal.tsx
+++ b/src/frontend/components/_organisms/modals/save-changes-modal.tsx
@@ -1,8 +1,10 @@
-import { WarningIcon } from '../../../assets/icons/interface/Warning'
-import { useOpenPLCStore } from '../../../store'
-import { useProject, useWindow, useCapabilities } from '../../../../middleware/shared/providers'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { useCapabilities, useProject, useWindow } from '../../../../middleware/shared/providers'
+import { WarningIcon } from '../../../assets/icons/interface/Warning'
+import { useOpenPLCStore } from '../../../store'
+import { prepareSavePayload } from '../../../utils/save-project'
+import { toast } from '../../_features/[app]/toast/use-toast'
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
 /**
@@ -26,13 +28,19 @@ export type ValidationContext =
 export type SaveChangeModalProps = ComponentPropsWithoutRef<typeof Modal> & {
   isOpen: boolean
   validationContext: ValidationContext
+  /** Callback to execute after save+close completes (e.g., re-open recent project). */
+  onAfterAction?: () => void
 }
 
-const SaveChangesModal = ({ isOpen, validationContext, ...rest }: SaveChangeModalProps) => {
+const SaveChangesModal = ({ isOpen, validationContext, onAfterAction, ...rest }: SaveChangeModalProps) => {
   const {
     project,
+    editor: activeEditor,
+    editors,
     deviceDefinitions,
     workspaceActions: { setEditingState },
+    fileActions: { setAllToSaved },
+    snapshotActions: { markAllSaved },
     modalActions: { closeModal, onOpenChange, openModal },
   } = useOpenPLCStore()
 
@@ -40,8 +48,12 @@ const SaveChangesModal = ({ isOpen, validationContext, ...rest }: SaveChangeModa
   const windowPort = useWindow()
   const capabilities = useCapabilities()
 
+  const {
+    sharedWorkspaceActions: { clearStatesOnCloseProject },
+  } = useOpenPLCStore()
+
   const clearAndClose = () => {
-    // Web navigates back; editor resets editing state
+    clearStatesOnCloseProject()
     setEditingState('initial-state')
     if (!capabilities.hasLocalFilesystem) {
       window.history.back()
@@ -52,15 +64,32 @@ const SaveChangesModal = ({ isOpen, validationContext, ...rest }: SaveChangeModa
     closeModal()
 
     if (operation === 'save') {
-      const result = await projectPort.saveProject({
+      const params = prepareSavePayload({
         projectPath: project.meta.path,
+        projectName: project.meta.name,
         projectData: project.data,
         deviceConfiguration: deviceDefinitions.configuration,
         devicePinMapping: deviceDefinitions.pinMapping.pins,
+        editors,
+        activeEditor,
       })
+      const result = await projectPort.saveProject(params)
       if (!result.success) {
+        toast({
+          title: 'Error in the save request!',
+          description: result.error ?? 'Save failed',
+          variant: 'fail',
+        })
         return
       }
+      setEditingState('saved')
+      setAllToSaved()
+      markAllSaved()
+      toast({
+        title: 'Changes saved!',
+        description: 'The project was saved successfully!',
+        variant: 'default',
+      })
     }
 
     switch (validationContext) {
@@ -72,10 +101,9 @@ const SaveChangesModal = ({ isOpen, validationContext, ...rest }: SaveChangeModa
         await projectPort.openProject()
         return
       case 'open-recent-project':
-        // Editor-specific: handled via IPC callback outside the modal
-        return
       case 'open-project-by-path':
-        // Editor-specific: handled via IPC callback outside the modal
+        // Execute the deferred action (e.g., re-open the recent project)
+        onAfterAction?.()
         return
       case 'close-project':
         clearAndClose()
diff --git a/src2/frontend/components/_organisms/modals/server-ip-mismatch-modal.tsx b/src/frontend/components/_organisms/modals/server-ip-mismatch-modal.tsx
similarity index 97%
rename from src2/frontend/components/_organisms/modals/server-ip-mismatch-modal.tsx
rename to src/frontend/components/_organisms/modals/server-ip-mismatch-modal.tsx
index eabf312bb..67910dc17 100644
--- a/src2/frontend/components/_organisms/modals/server-ip-mismatch-modal.tsx
+++ b/src/frontend/components/_organisms/modals/server-ip-mismatch-modal.tsx
@@ -1,7 +1,7 @@
-import { WarningIcon } from '../../../assets/icons/interface/Warning'
-import { useOpenPLCStore } from '../../../store'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { WarningIcon } from '../../../assets/icons/interface/Warning'
+import { useOpenPLCStore } from '../../../store'
 import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
 
 export type ServerIpMismatch = {
@@ -101,7 +101,7 @@ const ServerIpMismatchModal = ({ isOpen, ...rest }: ServerIpMismatchModalProps)
           <div className='mt-2 flex w-full flex-col gap-2 text-sm'>
             <button
               onClick={handleSwitchToAllInterfaces}
-              className='w-full rounded-lg bg-brand px-4 py-2 text-center font-medium text-white hover:bg-brand/90'
+              className='hover:bg-brand/90 w-full rounded-lg bg-brand px-4 py-2 text-center font-medium text-white'
             >
               Switch to All Interfaces (0.0.0.0)
             </button>
diff --git a/src/renderer/components/_organisms/navigation/index.tsx b/src/frontend/components/_organisms/navigation/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/navigation/index.tsx
rename to src/frontend/components/_organisms/navigation/index.tsx
diff --git a/src2/frontend/components/_organisms/panel/__tests__/panel.test.tsx b/src/frontend/components/_organisms/panel/__tests__/panel.test.tsx
similarity index 90%
rename from src2/frontend/components/_organisms/panel/__tests__/panel.test.tsx
rename to src/frontend/components/_organisms/panel/__tests__/panel.test.tsx
index ccf9f76b7..4cd0e6b6b 100644
--- a/src2/frontend/components/_organisms/panel/__tests__/panel.test.tsx
+++ b/src/frontend/components/_organisms/panel/__tests__/panel.test.tsx
@@ -2,8 +2,16 @@ import { render } from '@testing-library/react'
 
 // Mock react-resizable-panels
 vi.mock('react-resizable-panels', () => ({
-  Panel: ({ children, ...props }: { children?: React.ReactNode }) => <div data-testid='panel' {...props}>{children}</div>,
-  PanelGroup: ({ children, ...props }: { children?: React.ReactNode }) => <div data-testid='panel-group' {...props}>{children}</div>,
+  Panel: ({ children, ...props }: { children?: React.ReactNode }) => (
+    <div data-testid='panel' {...props}>
+      {children}
+    </div>
+  ),
+  PanelGroup: ({ children, ...props }: { children?: React.ReactNode }) => (
+    <div data-testid='panel-group' {...props}>
+      {children}
+    </div>
+  ),
   PanelResizeHandle: ({ children, ...props }: { children?: React.ReactNode }) => (
     <div data-testid='panel-resize-handle' {...props}>
       {children}
diff --git a/src2/frontend/components/_organisms/panel/index.tsx b/src/frontend/components/_organisms/panel/index.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/panel/index.tsx
rename to src/frontend/components/_organisms/panel/index.tsx
index e58ba585a..2c9d194a0 100644
--- a/src2/frontend/components/_organisms/panel/index.tsx
+++ b/src/frontend/components/_organisms/panel/index.tsx
@@ -1,8 +1,9 @@
 import { DragHandleDots2Icon } from '@radix-ui/react-icons'
-import { cn } from '../../../utils/cn'
 import { ComponentProps } from 'react'
 import { Panel, PanelGroup, PanelResizeHandle } from 'react-resizable-panels'
 
+import { cn } from '../../../utils/cn'
+
 type IResizablePanelGroupProps = ComponentProps<typeof PanelGroup>
 
 const ResizablePanelGroup = ({ className, ...res }: IResizablePanelGroupProps) => (
diff --git a/src2/frontend/components/_organisms/pin-mapping-editor/index.tsx b/src/frontend/components/_organisms/pin-mapping-editor/index.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/pin-mapping-editor/index.tsx
rename to src/frontend/components/_organisms/pin-mapping-editor/index.tsx
diff --git a/src2/frontend/components/_organisms/plc-logs/filters.tsx b/src/frontend/components/_organisms/plc-logs/filters.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/plc-logs/filters.tsx
rename to src/frontend/components/_organisms/plc-logs/filters.tsx
index 0dd1fd880..1f9c7ab84 100644
--- a/src2/frontend/components/_organisms/plc-logs/filters.tsx
+++ b/src/frontend/components/_organisms/plc-logs/filters.tsx
@@ -1,10 +1,11 @@
+import { ChevronDown, Download, Filter, Search, X } from 'lucide-react'
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
+import { isV4Logs, RuntimeLogEntry, RuntimeLogLevel } from '../../../../middleware/shared/ports'
 import { useOpenPLCStore } from '../../../store'
 import { TimestampFormat } from '../../../store/slices/console/types'
-import { isV4Logs, RuntimeLogEntry, RuntimeLogLevel } from '../../../../middleware/shared/ports'
 import { cn } from '../../../utils/cn'
 import formatTimestamp from '../../../utils/format-timestamp'
-import { ChevronDown, Download, Filter, Search, X } from 'lucide-react'
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
 type LogLevel = 'debug' | 'info' | 'warning' | 'error'
 type ExportFormat = 'txt' | 'csv' | 'json'
diff --git a/src2/frontend/components/_organisms/plc-logs/index.tsx b/src/frontend/components/_organisms/plc-logs/index.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/plc-logs/index.tsx
rename to src/frontend/components/_organisms/plc-logs/index.tsx
index bc7fe3881..ac69f67d2 100644
--- a/src2/frontend/components/_organisms/plc-logs/index.tsx
+++ b/src/frontend/components/_organisms/plc-logs/index.tsx
@@ -1,9 +1,9 @@
-import { useOpenPLCStore } from '../../../store'
-import { isV4Logs, RuntimeLogEntry, RuntimeLogLevel } from '../../../../middleware/shared/ports'
-import formatTimestamp from '../../../utils/format-timestamp'
 import { debounce } from 'lodash'
 import { memo, useEffect, useMemo, useRef } from 'react'
 
+import { isV4Logs, RuntimeLogEntry, RuntimeLogLevel } from '../../../../middleware/shared/ports'
+import { useOpenPLCStore } from '../../../store'
+import formatTimestamp from '../../../utils/format-timestamp'
 import { LogComponent, LogLevel } from '../console/log'
 
 const mapV4LevelToLogLevel = (level: RuntimeLogLevel): LogLevel => {
diff --git a/src2/frontend/components/_organisms/project-filter-bar/index.tsx b/src/frontend/components/_organisms/project-filter-bar/index.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/project-filter-bar/index.tsx
rename to src/frontend/components/_organisms/project-filter-bar/index.tsx
index 9bcc4ce6f..62522284a 100644
--- a/src2/frontend/components/_organisms/project-filter-bar/index.tsx
+++ b/src/frontend/components/_organisms/project-filter-bar/index.tsx
@@ -1,9 +1,9 @@
 import * as PrimitiveDropdown from '@radix-ui/react-dropdown-menu'
+import { ReactNode, useEffect, useState } from 'react'
+
 import { ArrowIcon } from '../../../assets/icons/interface/Arrow'
 import { MagnifierIcon } from '../../../assets/icons/interface/Magnifier'
 import { useOpenPLCStore } from '../../../store'
-import { ReactNode, useEffect, useState } from 'react'
-
 import { InputWithRef } from '../../_atoms/input'
 
 interface ProjectFilterBarProps {
diff --git a/src2/frontend/components/_organisms/task-editor/index.tsx b/src/frontend/components/_organisms/task-editor/index.tsx
similarity index 94%
rename from src2/frontend/components/_organisms/task-editor/index.tsx
rename to src/frontend/components/_organisms/task-editor/index.tsx
index 8856ab26b..2ff871db6 100644
--- a/src2/frontend/components/_organisms/task-editor/index.tsx
+++ b/src/frontend/components/_organisms/task-editor/index.tsx
@@ -1,16 +1,16 @@
+import { useCallback, useEffect, useState } from 'react'
+
+import type { PLCTask } from '../../../../middleware/shared/ports/types'
+import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { MinusIcon } from '../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../assets/icons/interface/StickArrow'
-import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { TableIcon } from '../../../assets/icons/interface/TableIcon'
 import { useOpenPLCStore } from '../../../store'
 import type { TaskType } from '../../../store/slices/editor'
-import type { PLCTask } from '../../../../middleware/shared/ports/types'
 import { cn } from '../../../utils/cn'
 import { parseResourceConfigurationToString } from '../../../utils/parse-resource-configuration-to-string'
 import { parseResourceStringToConfiguration } from '../../../utils/parse-resource-string-to-configuration'
-import { useEffect, useState } from 'react'
-
 import TableActions from '../../_atoms/table-actions'
 import { toast } from '../../_features/[app]/toast/use-toast'
 import { TaskTable } from '../../_molecules/task-table'
@@ -26,16 +26,36 @@ const TaskEditor = () => {
     },
     project: {
       data: {
-        configuration: {
+        configurations: {
           resource: { tasks, instances },
         },
       },
     },
     editorActions: { updateModelTasks },
-    projectActions: { createTask, rearrangeTasks, deleteTask, setTasks, setInstances, pushToHistory },
+    projectActions: { createTask, rearrangeTasks, deleteTask, setTasks, setInstances },
     sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
   } = useOpenPLCStore()
 
+  const {
+    project: {
+      data: { pous: snapshotPous, configurations },
+    },
+    snapshotActions: { pushToHistory: rawPushToHistory },
+  } = useOpenPLCStore()
+
+  const pushToHistory = useCallback(
+    (pouName: string) => {
+      const pou = snapshotPous.find((p) => p.name === pouName)
+      if (!pou) return
+      rawPushToHistory(pouName, {
+        variables: pou.interface?.variables ?? [],
+        body: pou.body.value,
+        globalVariables: configurations.resource.globalVariables,
+      })
+    },
+    [snapshotPous, configurations.resource.globalVariables, rawPushToHistory],
+  )
+
   const [taskData, setTaskData] = useState<PLCTask[]>([])
   const [editorCode, setEditorCode] = useState(() => parseResourceConfigurationToString(taskData, instances))
   const [parseError, setParseError] = useState<string | null>(null)
@@ -87,7 +107,6 @@ const TaskEditor = () => {
         selectedRow: editorTasks.display === 'table' ? parseInt(editorTasks.selectedRow) : ROWS_NOT_SELECTED,
       })
     } else {
-      // @ts-expect-error: 'selectedRow' is not required when display is 'code'
       updateModelTasks({
         display: 'code',
       })
diff --git a/src/renderer/components/_organisms/title-bar/index.tsx b/src/frontend/components/_organisms/title-bar/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/title-bar/index.tsx
rename to src/frontend/components/_organisms/title-bar/index.tsx
diff --git a/src2/frontend/components/_organisms/title-bar/slots/center-slot.tsx b/src/frontend/components/_organisms/title-bar/slots/center-slot.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/title-bar/slots/center-slot.tsx
rename to src/frontend/components/_organisms/title-bar/slots/center-slot.tsx
index 254a02abc..dab0e2fee 100644
--- a/src2/frontend/components/_organisms/title-bar/slots/center-slot.tsx
+++ b/src/frontend/components/_organisms/title-bar/slots/center-slot.tsx
@@ -1,6 +1,6 @@
+import { useCapabilities } from '../../../../../middleware/shared/providers'
 import { OpenPLCIcon } from '../../../../assets/icons/oplc'
 import { useOpenPLCStore } from '../../../../store'
-import { useCapabilities } from '../../../../../middleware/shared/providers'
 import { cn } from '../../../../utils/cn'
 
 const TitleBarCenterSlot = () => {
diff --git a/src/renderer/components/_organisms/title-bar/slots/index.ts b/src/frontend/components/_organisms/title-bar/slots/index.ts
similarity index 100%
rename from src/renderer/components/_organisms/title-bar/slots/index.ts
rename to src/frontend/components/_organisms/title-bar/slots/index.ts
diff --git a/src2/frontend/components/_organisms/title-bar/slots/left-slot.tsx b/src/frontend/components/_organisms/title-bar/slots/left-slot.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/title-bar/slots/left-slot.tsx
rename to src/frontend/components/_organisms/title-bar/slots/left-slot.tsx
index e09328d57..e740640b3 100644
--- a/src2/frontend/components/_organisms/title-bar/slots/left-slot.tsx
+++ b/src/frontend/components/_organisms/title-bar/slots/left-slot.tsx
@@ -1,7 +1,7 @@
+import { useCapabilities } from '../../../../../middleware/shared/providers'
 import { OpenPLCIcon } from '../../../../assets/icons/oplc'
-import { MenuBar } from '../../../_molecules/menu-bar'
 import { useOpenPLCStore } from '../../../../store'
-import { useCapabilities } from '../../../../../middleware/shared/providers'
+import { MenuBar } from '../../../_molecules/menu-bar'
 
 export const TitleBarLeftSlot = () => {
   const caps = useCapabilities()
diff --git a/src2/frontend/components/_organisms/title-bar/slots/right-slot.tsx b/src/frontend/components/_organisms/title-bar/slots/right-slot.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/title-bar/slots/right-slot.tsx
rename to src/frontend/components/_organisms/title-bar/slots/right-slot.tsx
diff --git a/src2/frontend/components/_organisms/variables-code-editor/index.tsx b/src/frontend/components/_organisms/variables-code-editor/index.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/variables-code-editor/index.tsx
rename to src/frontend/components/_organisms/variables-code-editor/index.tsx
diff --git a/src2/frontend/components/_organisms/variables-editor/index.tsx b/src/frontend/components/_organisms/variables-editor/index.tsx
similarity index 94%
rename from src2/frontend/components/_organisms/variables-editor/index.tsx
rename to src/frontend/components/_organisms/variables-editor/index.tsx
index 358deb129..d44fed81c 100644
--- a/src2/frontend/components/_organisms/variables-editor/index.tsx
+++ b/src/frontend/components/_organisms/variables-editor/index.tsx
@@ -1,30 +1,37 @@
+import { ColumnFiltersState } from '@tanstack/react-table'
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import { PLCVariable } from '../../../../middleware/shared/ports/types'
+import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { MinusIcon } from '../../../assets/icons/interface/Minus'
 import { PlusIcon } from '../../../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../../../assets/icons/interface/StickArrow'
-import { CodeIcon } from '../../../assets/icons/interface/CodeIcon'
 import { TableIcon } from '../../../assets/icons/interface/TableIcon'
 import { useOpenPLCStore } from '../../../store'
+import type { VariablesTable as VariablesTableType } from '../../../store/slices/editor'
 import type { FBDFlowActions, FBDFlowState } from '../../../store/slices/fbd'
 import type { LadderFlowActions, LadderFlowState } from '../../../store/slices/ladder'
-import type { VariablesTable as VariablesTableType } from '../../../store/slices/editor'
-import { TypeChangeValidationResult, validateTypeChange, } from '../../../store/slices/project/validation/type-change'
-import { syncNodesWithVariables as syncNodesWithVariablesUtil, syncNodesWithVariablesFBD as syncNodesWithVariablesFBDUtil, } from '../../../utils/graphical/sync-nodes-with-variables'
-import { findAllReferencesToVariable, propagateVariableRename, type ReferenceImpactAnalysis, } from '../../../utils/variable-references'
-import { baseTypes } from '../../../utils/plc-constants'
-import { PLCVariable } from '../../../../middleware/shared/ports/types'
+import { TypeChangeValidationResult, validateTypeChange } from '../../../store/slices/project/validation/type-change'
 import { cn } from '../../../utils/cn'
 import { parseIecStringToVariables } from '../../../utils/generate-iec-string-to-variables'
 import { generateIecVariablesToString } from '../../../utils/generate-iec-variables-to-string'
-import { ColumnFiltersState } from '@tanstack/react-table'
-import { useEffect, useRef, useState } from 'react'
-
+import {
+  syncNodesWithVariables as syncNodesWithVariablesUtil,
+  syncNodesWithVariablesFBD as syncNodesWithVariablesFBDUtil,
+} from '../../../utils/graphical/sync-nodes-with-variables'
+import { baseTypes } from '../../../utils/plc-constants'
+import {
+  findAllReferencesToVariable,
+  propagateVariableRename,
+  type ReferenceImpactAnalysis,
+} from '../../../utils/variable-references'
 import { InputWithRef } from '../../_atoms/input'
 import { Select, SelectContent, SelectItem, SelectTrigger } from '../../_atoms/select'
 import TableActions from '../../_atoms/table-actions'
 import { toast } from '../../_features/[app]/toast/use-toast'
-import { VariablesTable } from '../../_molecules/variables-table'
 import { RenameImpactModal } from '../../_molecules/rename-impact-modal'
 import { TypeChangeModal } from '../../_molecules/type-change-modal'
+import { VariablesTable } from '../../_molecules/variables-table'
 import { VariablesCodeEditor } from '../variables-code-editor'
 
 const VariablesEditor = () => {
@@ -55,11 +62,30 @@ const VariablesEditor = () => {
       setPouVariables,
       updatePou,
       updateVariable,
-      pushToHistory,
     },
     sharedWorkspaceActions: { handleFileAndWorkspaceSavedState },
   } = useOpenPLCStore()
 
+  const {
+    project: {
+      data: { pous: snapshotPous, configurations },
+    },
+    snapshotActions: { pushToHistory: rawPushToHistory },
+  } = useOpenPLCStore()
+
+  const pushToHistory = useCallback(
+    (pouName: string) => {
+      const pou = snapshotPous.find((p) => p.name === pouName)
+      if (!pou) return
+      rawPushToHistory(pouName, {
+        variables: pou.interface?.variables ?? [],
+        body: pou.body.value,
+        globalVariables: configurations.resource.globalVariables,
+      })
+    },
+    [snapshotPous, configurations.resource.globalVariables, rawPushToHistory],
+  )
+
   /**
    * Table data and column filters states to keep track of the table data and column filters
    */
@@ -75,7 +101,7 @@ const VariablesEditor = () => {
     ) {
       return editor.variable.code
     }
-    return generateIecVariablesToString(tableData as PLCVariable[])
+    return generateIecVariablesToString(tableData)
   })
   const [parseError, setParseError] = useState<string | null>(null)
   const [pouDescription, setPouDescription] = useState<string>('')
@@ -115,23 +141,23 @@ const VariablesEditor = () => {
     }
   })
 
-  const pou = pous.find((p) => p.data.name === editor.meta.name)
+  const pou = pous.find((p) => p.name === editor.meta.name)
   useEffect(() => {
-    const data = pou?.data.documentation
+    const data = pou?.documentation
     if (data) setPouDescription(data)
     return () => {
       setPouDescription('')
     }
-  }, [editor, pou?.data.documentation])
+  }, [editor, pou?.documentation])
 
   /**
    * Update the table data and the editor's variables when the editor or the pous change
    */
   useEffect(() => {
     if (pou) {
-      setTableData(pou.data.variables)
-      if (pou.type === 'function') {
-        setReturnType(pou.data.returnType)
+      setTableData(pou.interface?.variables ?? [])
+      if (pou.pouType === 'function') {
+        setReturnType(pou.interface?.returnType ?? 'BOOL')
       }
     } else {
       setTableData([])
@@ -148,7 +174,7 @@ const VariablesEditor = () => {
 
   useEffect(() => {
     if (editorVariables.display !== 'code') {
-      setEditorCode(generateIecVariablesToString(tableData as PLCVariable[]))
+      setEditorCode(generateIecVariablesToString(tableData))
     }
   }, [tableData, editorVariables.display])
 
@@ -291,7 +317,8 @@ const VariablesEditor = () => {
 
     pushToHistory(editor.meta.name)
 
-    const variables = pous.filter((pou) => pou.data.name === editor.meta.name)[0].data.variables
+    const matchedPou = pous.find((p) => p.name === editor.meta.name)
+    const variables = matchedPou?.interface?.variables ?? []
     const selectedRow = parseInt(editorVariables.selectedRow)
 
     const language = 'language' in editor.meta ? editor.meta.language : null
@@ -304,7 +331,7 @@ const VariablesEditor = () => {
         data: {
           name: 'LocalVar',
           class: defaultClass,
-          type: { definition: 'base-type', value: 'dint' },
+          type: { definition: 'base-type', value: 'DINT' },
           location: '',
           documentation: '',
           debug: false,
@@ -328,7 +355,7 @@ const VariablesEditor = () => {
         data: {
           ...variable,
           class: defaultClass,
-          type: variable.type.definition === 'derived' ? { definition: 'base-type', value: 'dint' } : variable.type,
+          type: variable.type.definition === 'derived' ? { definition: 'base-type', value: 'DINT' } : variable.type,
         },
       })
       updateModelVariables({
@@ -344,7 +371,7 @@ const VariablesEditor = () => {
       data: {
         ...variable,
         class: defaultClass,
-        type: variable.type.definition === 'derived' ? { definition: 'base-type', value: 'dint' } : variable.type,
+        type: variable.type.definition === 'derived' ? { definition: 'base-type', value: 'DINT' } : variable.type,
       },
       rowToInsert: selectedRow + 1,
     })
@@ -361,7 +388,8 @@ const VariablesEditor = () => {
     pushToHistory(editor.meta.name)
 
     const selectedRow = parseInt(editorVariables.selectedRow)
-    const variables = pous.filter((pou) => pou.data.name === editor.meta.name)[0].data.variables
+    const deletePou = pous.find((p) => p.name === editor.meta.name)
+    const variables = deletePou?.interface?.variables ?? []
     const variableToDelete = variables[selectedRow]
 
     if (variableToDelete) {
@@ -792,7 +820,7 @@ const VariablesEditor = () => {
       })
 
       const response = setPouVariables({
-        pouName: pou?.data?.name ?? '',
+        pouName: pou?.name ?? '',
         variables: finalVariables,
       })
 
@@ -808,8 +836,8 @@ const VariablesEditor = () => {
         fbdFlows: freshFBDFlows,
       } = useOpenPLCStore.getState()
 
-      const freshPou = freshPous.find((p) => p.data.name === editor.meta.name)
-      const freshVariables = freshPou?.data.variables ?? []
+      const freshPou = freshPous.find((p) => p.name === editor.meta.name)
+      const freshVariables = freshPou?.interface?.variables ?? []
 
       if (language === 'ld') {
         syncNodesWithVariablesUtil(freshVariables, freshLadderFlows, updateNode)
@@ -850,7 +878,7 @@ const VariablesEditor = () => {
       setParseError(null)
       handleFileAndWorkspaceSavedState(editor.meta.name)
 
-      if (freshPou && 'variablesText' in freshPou.data) {
+      if (freshPou && freshPou.interface && 'variablesText' in freshPou.interface) {
         clearPouVariablesText(editor.meta.name)
       }
 
diff --git a/src/frontend/components/_organisms/workspace-activity-bar/default.tsx b/src/frontend/components/_organisms/workspace-activity-bar/default.tsx
new file mode 100644
index 000000000..d7728c051
--- /dev/null
+++ b/src/frontend/components/_organisms/workspace-activity-bar/default.tsx
@@ -0,0 +1,667 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import type { DebugConnectionConfig } from '../../../../middleware/shared/ports/types'
+import { useCompiler, useDebugger, useProject, useRuntime, useSimulator } from '../../../../middleware/shared/providers'
+import { StopIcon } from '../../../assets/icons/interface/Stop'
+import { useDebugPolling } from '../../../hooks/useDebugPolling'
+import { useDebugSession } from '../../../hooks/useDebugSession'
+import { useOpenPLCStore } from '../../../store'
+import type { RuntimeConnection } from '../../../store/slices/device/types'
+import { cn } from '../../../utils/cn'
+import { logCompilerEvent } from '../../../utils/debugger-session'
+import { isOpenPLCRuntimeTarget, isOpenPLCRuntimeV4Target } from '../../../utils/device'
+import { getErrorMessage } from '../../../utils/get-error-message'
+import { prepareSavePayload } from '../../../utils/save-project'
+import { ChatButton } from '../../_molecules/workspace-activity-bar/default/chat'
+import { DebuggerButton } from '../../_molecules/workspace-activity-bar/default/debugger'
+import { DownloadButton } from '../../_molecules/workspace-activity-bar/default/download'
+import { PlayButton } from '../../_molecules/workspace-activity-bar/default/play'
+import { SearchButton } from '../../_molecules/workspace-activity-bar/default/search'
+import { ZoomButton } from '../../_molecules/workspace-activity-bar/default/zoom'
+import { TooltipSidebarWrapperButton } from '../../_molecules/workspace-activity-bar/tooltip-button'
+
+const showDebuggerMessage = (
+  type: 'info' | 'warning' | 'error' | 'question',
+  title: string,
+  message: string,
+  buttons: string[],
+): Promise<number> => {
+  return new Promise((resolve) => {
+    useOpenPLCStore.getState().modalActions.openModal('debugger-message', {
+      type,
+      title,
+      message,
+      buttons,
+      onResponse: (buttonIndex: number) => resolve(buttonIndex),
+    })
+  })
+}
+
+const showDebuggerIpInput = (title: string, message: string, defaultValue: string): Promise<string | null> => {
+  return new Promise((resolve) => {
+    useOpenPLCStore.getState().modalActions.openModal('debugger-ip-input', {
+      title,
+      message,
+      defaultValue,
+      onSubmit: (value: string) => resolve(value),
+      onCancel: () => resolve(null),
+    })
+  })
+}
+
+const disabledButtonClass = 'cursor-not-allowed opacity-50 [&>*:first-child]:hover:bg-transparent'
+
+type DefaultWorkspaceActivityBarProps = {
+  zoom?: {
+    onClick: () => void
+  }
+}
+
+export const DefaultWorkspaceActivityBar = ({ zoom }: DefaultWorkspaceActivityBarProps) => {
+  const {
+    project: { data: projectData, meta: projectMeta },
+    deviceDefinitions,
+    deviceAvailableOptions: { availableBoards },
+    consoleActions: { addLog },
+  } = useOpenPLCStore()
+
+  const compiler = useCompiler()
+  const runtime = useRuntime()
+  const simulator = useSimulator()
+  const debuggerPort = useDebugger()
+  const projectPort = useProject()
+  const debugSession = useDebugSession()
+  useDebugPolling({ debugTreesRef: debugSession.debugTreesRef })
+
+  const [isCompiling, setIsCompiling] = useState(false)
+  const [isDebuggerProcessing, setIsDebuggerProcessing] = useState(false)
+  const [simulatorRunning, setSimulatorRunning] = useState(false)
+  const pendingSimulatorDebugRef = useRef(false)
+
+  const connectionStatus = useOpenPLCStore((state) => state.runtimeConnection.connectionStatus)
+  const plcStatus = useOpenPLCStore((state): RuntimeConnection['plcStatus'] => state.runtimeConnection.plcStatus)
+  const jwtToken = useOpenPLCStore((state) => state.runtimeConnection.jwtToken)
+  const editingState = useOpenPLCStore((state) => state.workspace.editingState)
+  const isDebuggerVisible = useOpenPLCStore((state) => state.workspace.isDebuggerVisible)
+
+  const currentBoardInfo = availableBoards.get(deviceDefinitions.configuration.deviceBoard)
+  const isSimulatorBoard = currentBoardInfo?.compiler === 'simulator'
+
+  // Sync simulatorRunning when the simulator stops externally
+  useEffect(() => {
+    const unsub = simulator.onStopped(() => {
+      pendingSimulatorDebugRef.current = false
+      setSimulatorRunning(false)
+      const { workspace } = useOpenPLCStore.getState()
+      if (workspace.isDebuggerVisible) {
+        void debugSession.stopSession()
+      }
+    })
+    return unsub
+  }, [simulator, debugSession])
+
+  // Stop simulator if the board is switched away while it's running
+  const prevIsSimulatorBoardRef = useRef(isSimulatorBoard)
+  useEffect(() => {
+    const wasSimulator = prevIsSimulatorBoardRef.current
+    prevIsSimulatorBoardRef.current = isSimulatorBoard
+
+    if (wasSimulator && !isSimulatorBoard && simulator.isRunning()) {
+      addLog({
+        id: crypto.randomUUID(),
+        level: 'info',
+        message: 'Board changed from simulator. Stopping simulator.',
+      })
+      void simulator.stop()
+      if (isDebuggerVisible) {
+        const { workspaceActions } = useOpenPLCStore.getState()
+        workspaceActions.clearDebugState()
+      }
+    }
+  }, [isSimulatorBoard, isDebuggerVisible, simulator, addLog])
+
+  const executeSave = useCallback(async (): Promise<boolean> => {
+    const state = useOpenPLCStore.getState()
+    const { workspaceActions, fileActions, snapshotActions, editors } = state
+    const activeEditor = editors[0] ?? { type: 'available', meta: { name: '' } }
+    try {
+      workspaceActions.setEditingState('save-request')
+      const payload = prepareSavePayload({
+        projectPath: projectMeta.path,
+        projectName: projectMeta.name,
+        projectData,
+        deviceConfiguration: deviceDefinitions.configuration,
+        devicePinMapping: deviceDefinitions.pinMapping.pins,
+        editors,
+        activeEditor,
+      })
+      const res = await projectPort.saveProject(payload)
+      if (res.success) {
+        workspaceActions.setEditingState('saved')
+        fileActions.setAllToSaved()
+        snapshotActions.markAllSaved()
+        return true
+      }
+      workspaceActions.setEditingState('unsaved')
+      addLog({ id: crypto.randomUUID(), level: 'error', message: `Save failed: ${res.error ?? 'Unknown error'}` })
+      return false
+    } catch {
+      workspaceActions.setEditingState('unsaved')
+      return false
+    }
+  }, [projectPort, projectMeta, projectData, deviceDefinitions, addLog])
+
+  // ---------------------------------------------------------------------------
+  // Build (Compile)
+  // ---------------------------------------------------------------------------
+
+  const handleBuild = useCallback(async () => {
+    if (isCompiling) return
+
+    if (editingState === 'unsaved') {
+      const saved = await executeSave()
+      if (!saved) return
+    }
+
+    setIsCompiling(true)
+    addLog({ id: crypto.randomUUID(), level: 'info', message: 'Build process started' })
+
+    try {
+      const result = await compiler.compileProgram(
+        {
+          projectData,
+          boardTarget: deviceDefinitions.configuration.deviceBoard,
+          projectPath: projectMeta.path,
+          compileOnly: deviceDefinitions.configuration.compileOnly,
+          isSimulator: isSimulatorBoard,
+          runtimeIpAddress: deviceDefinitions.configuration.runtimeIpAddress || null,
+          runtimeJwtToken: jwtToken || null,
+        },
+        (event) => {
+          if (event.plcStatus) {
+            useOpenPLCStore
+              .getState()
+              .deviceActions.setPlcRuntimeStatus(event.plcStatus as NonNullable<RuntimeConnection['plcStatus']>)
+          }
+          logCompilerEvent(event, addLog)
+          if (event.firmwarePath && isSimulatorBoard) {
+            void simulator.loadFirmware(event.firmwarePath).then((loadResult) => {
+              if (loadResult.success) {
+                setSimulatorRunning(true)
+                addLog({ id: crypto.randomUUID(), level: 'info', message: 'Simulator is running.' })
+                if (pendingSimulatorDebugRef.current) {
+                  pendingSimulatorDebugRef.current = false
+                  void debugSession.connectAndStart()
+                }
+              } else {
+                pendingSimulatorDebugRef.current = false
+                addLog({
+                  id: crypto.randomUUID(),
+                  level: 'error',
+                  message: `Failed to start simulator: ${loadResult.error ?? 'Unknown error'}`,
+                })
+              }
+            })
+          }
+        },
+      )
+
+      if (!result.success) {
+        addLog({ id: crypto.randomUUID(), level: 'error', message: result.error ?? 'Compilation failed' })
+      }
+    } catch (err: unknown) {
+      addLog({ id: crypto.randomUUID(), level: 'error', message: `Build error: ${getErrorMessage(err)}` })
+    } finally {
+      setIsCompiling(false)
+    }
+  }, [
+    compiler,
+    projectData,
+    projectMeta,
+    deviceDefinitions,
+    isSimulatorBoard,
+    simulator,
+    debugSession,
+    addLog,
+    isCompiling,
+    editingState,
+    executeSave,
+    jwtToken,
+  ])
+
+  const handleBuildRef = useRef(handleBuild)
+  handleBuildRef.current = handleBuild
+
+  // ---------------------------------------------------------------------------
+  // PLC control (Start/Stop for runtime targets)
+  // ---------------------------------------------------------------------------
+
+  const handlePlcControl = useCallback(async (): Promise<void> => {
+    if (!jwtToken || connectionStatus !== 'connected') return
+
+    try {
+      if (plcStatus === 'RUNNING') {
+        const result = await runtime.stopPlc()
+        if (!result.success) {
+          addLog({
+            id: crypto.randomUUID(),
+            level: 'error',
+            message: `Failed to stop PLC: ${result.error ?? 'Unknown error'}`,
+          })
+          return
+        }
+      } else {
+        const result = await runtime.startPlc()
+        if (!result.success) {
+          addLog({
+            id: crypto.randomUUID(),
+            level: 'error',
+            message: `Failed to start PLC: ${result.error ?? 'Unknown error'}`,
+          })
+          return
+        }
+      }
+
+      const statusResult = await runtime.getStatus()
+      if (statusResult.success && statusResult.status) {
+        useOpenPLCStore
+          .getState()
+          .deviceActions.setPlcRuntimeStatus(statusResult.status as NonNullable<RuntimeConnection['plcStatus']>)
+      }
+    } catch (error: unknown) {
+      addLog({ id: crypto.randomUUID(), level: 'error', message: `PLC control error: ${getErrorMessage(error)}` })
+    }
+  }, [runtime, jwtToken, connectionStatus, plcStatus, addLog])
+
+  // ---------------------------------------------------------------------------
+  // Simulator control (Start/Stop simulator + auto-debug)
+  // ---------------------------------------------------------------------------
+
+  const handleSimulatorControl = useCallback(async (): Promise<void> => {
+    try {
+      if (simulatorRunning) {
+        await debugSession.stopSession()
+        setSimulatorRunning(false)
+        addLog({ id: crypto.randomUUID(), level: 'info', message: 'Simulator stopped.' })
+      } else {
+        pendingSimulatorDebugRef.current = true
+        handleBuildRef.current().catch(() => {
+          pendingSimulatorDebugRef.current = false
+        })
+      }
+    } catch (error: unknown) {
+      pendingSimulatorDebugRef.current = false
+      addLog({ id: crypto.randomUUID(), level: 'error', message: `Simulator control error: ${getErrorMessage(error)}` })
+    }
+  }, [debugSession, simulatorRunning, addLog])
+
+  // ---------------------------------------------------------------------------
+  // MD5 verification — runs after debug compilation for non-simulator
+  // ---------------------------------------------------------------------------
+
+  const handleMd5Verification = async (
+    projectPath: string,
+    boardTarget: string,
+    debugConfig: DebugConnectionConfig,
+    isRuntimeTarget: boolean,
+  ) => {
+    const { consoleActions, runtimeConnection, deviceActions } = useOpenPLCStore.getState()
+
+    try {
+      // If runtime target + PLC stopped, offer to start
+      if (isRuntimeTarget && runtimeConnection.plcStatus === 'STOPPED' && runtimeConnection.jwtToken) {
+        const response = await showDebuggerMessage(
+          'question',
+          'PLC Stopped',
+          'The PLC is currently stopped. The debugger requires the PLC to be running. Would you like to start the PLC now?',
+          ['Yes', 'No'],
+        )
+        if (response === 1) {
+          consoleActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Debugger session cancelled.' })
+          setIsDebuggerProcessing(false)
+          return
+        }
+
+        consoleActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Starting PLC...' })
+        const startResult = await runtime.startPlc()
+        if (!startResult.success) {
+          await showDebuggerMessage(
+            'error',
+            'Start PLC Failed',
+            `Could not start the PLC: ${startResult.error || 'Unknown error'}`,
+            ['OK'],
+          )
+          setIsDebuggerProcessing(false)
+          return
+        }
+        deviceActions.setPlcRuntimeStatus('RUNNING')
+        await new Promise((resolve) => setTimeout(resolve, 2000))
+      }
+
+      // Read local MD5
+      consoleActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Verifying program MD5...' })
+      const md5Result = await debuggerPort.readProgramMd5(projectPath, boardTarget)
+      if (!md5Result.success || !md5Result.md5) {
+        await showDebuggerMessage('error', 'MD5 Extraction Failed', md5Result.error ?? 'Could not extract MD5', ['OK'])
+        setIsDebuggerProcessing(false)
+        return
+      }
+
+      // Connect debug transport before MD5 verification — the web platform
+      // needs an active transport (WebRTC or HTTP fallback) to query the device.
+      // connect() is idempotent: connectAndStart will reuse this connection.
+      const preConnectResult = await debuggerPort.connect(debugConfig)
+      if (!preConnectResult.success) {
+        await showDebuggerMessage(
+          'error',
+          'Connection Error',
+          `Could not connect to debug target: ${preConnectResult.error ?? 'Unknown error'}`,
+          ['OK'],
+        )
+        setIsDebuggerProcessing(false)
+        return
+      }
+
+      const verifyResult = await debuggerPort.verifyMd5(md5Result.md5, debugConfig)
+      if (!verifyResult.success) {
+        await debuggerPort.disconnect()
+        await showDebuggerMessage(
+          'error',
+          'Connection Error',
+          `Could not verify MD5: ${verifyResult.error ?? 'Unknown error'}`,
+          ['OK'],
+        )
+        setIsDebuggerProcessing(false)
+        return
+      }
+
+      if (verifyResult.match) {
+        consoleActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'MD5 verified. Starting debugger...' })
+        await debugSession.connectAndStart(debugConfig)
+        setIsDebuggerProcessing(false)
+      } else {
+        // Disconnect before re-upload; the recursive call will reconnect
+        await debuggerPort.disconnect()
+
+        consoleActions.addLog({
+          id: crypto.randomUUID(),
+          level: 'warning',
+          message: `MD5 mismatch. Target: ${verifyResult.targetMd5}, Expected: ${md5Result.md5}`,
+        })
+        const response = await showDebuggerMessage(
+          'warning',
+          'Program Mismatch',
+          'The program on the target does not match. Upload the current project?',
+          ['Yes', 'No'],
+        )
+        if (response === 0) {
+          const runtimeIpAddress = deviceDefinitions.configuration.runtimeIpAddress || null
+          const runtimeJwtToken = useOpenPLCStore.getState().runtimeConnection.jwtToken || null
+          const compileResult = await compiler.compileProgram(
+            {
+              projectData,
+              boardTarget,
+              projectPath,
+              compileOnly: false,
+              isSimulator: false,
+              runtimeIpAddress,
+              runtimeJwtToken,
+            },
+            (event) => logCompilerEvent(event, consoleActions.addLog),
+          )
+          if (compileResult.success) {
+            consoleActions.addLog({
+              id: crypto.randomUUID(),
+              level: 'info',
+              message: 'Upload completed. Re-verifying...',
+            })
+            await new Promise((resolve) => setTimeout(resolve, 2000))
+            void handleMd5Verification(projectPath, boardTarget, debugConfig, isRuntimeTarget)
+          } else {
+            consoleActions.addLog({
+              id: crypto.randomUUID(),
+              level: 'error',
+              message: `Upload failed: ${compileResult.error ?? 'Unknown error'}`,
+            })
+            setIsDebuggerProcessing(false)
+          }
+        } else {
+          setIsDebuggerProcessing(false)
+        }
+      }
+    } catch (error: unknown) {
+      await debuggerPort.disconnect()
+      consoleActions.addLog({
+        id: crypto.randomUUID(),
+        level: 'error',
+        message: `MD5 verification error: ${getErrorMessage(error)}`,
+      })
+      setIsDebuggerProcessing(false)
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Debugger click — full orchestration for non-simulator targets
+  // ---------------------------------------------------------------------------
+
+  const handleDebuggerClick = useCallback(async () => {
+    if (isSimulatorBoard) return
+
+    const { workspace, project, deviceDefinitions: devDefs, consoleActions, deviceActions } = useOpenPLCStore.getState()
+
+    // Toggle off
+    if (workspace.isDebuggerVisible) {
+      await debugSession.stopSession()
+      return
+    }
+
+    if (isDebuggerProcessing) return
+    setIsDebuggerProcessing(true)
+
+    try {
+      if (editingState === 'unsaved') {
+        const saved = await executeSave()
+        if (!saved) {
+          setIsDebuggerProcessing(false)
+          return
+        }
+      }
+
+      const boardTarget = devDefs.configuration.deviceBoard
+      const projectPath = project.meta.path
+      const boardInfo = availableBoards.get(boardTarget)
+      const isRuntimeTarget = isOpenPLCRuntimeTarget(boardInfo)
+
+      // Resolve connection config
+      let debugConfig: DebugConnectionConfig = { connectionType: 'tcp', connectionParams: {} }
+
+      if (isRuntimeTarget) {
+        const rtConn = useOpenPLCStore.getState().runtimeConnection
+        const runtimeIpAddress = devDefs.configuration.runtimeIpAddress
+        if (!runtime.isReadyForDebug?.() || rtConn.connectionStatus !== 'connected') {
+          await showDebuggerMessage('warning', 'Connection Required', 'Connect to the target first.', ['OK'])
+          setIsDebuggerProcessing(false)
+          return
+        }
+        if (isOpenPLCRuntimeV4Target(boardTarget)) {
+          const token = rtConn.jwtToken || undefined
+          if (!token) {
+            await showDebuggerMessage(
+              'error',
+              'Authentication Required',
+              'JWT token missing. Reconnect to the runtime.',
+              ['OK'],
+            )
+            setIsDebuggerProcessing(false)
+            return
+          }
+          debugConfig = {
+            connectionType: 'websocket',
+            connectionParams: { ipAddress: runtimeIpAddress, jwtToken: token },
+          }
+        } else {
+          debugConfig = { connectionType: 'tcp', connectionParams: { ipAddress: runtimeIpAddress } }
+        }
+      } else {
+        // Embedded hardware — determine TCP or RTU
+        const { modbusTCP, modbusRTU, communicationPreferences } = devDefs.configuration.communicationConfiguration
+        if (!communicationPreferences.enabledRTU && !communicationPreferences.enabledTCP) {
+          await showDebuggerMessage('warning', 'Modbus Required', 'Modbus must be enabled for debugging.', ['OK'])
+          setIsDebuggerProcessing(false)
+          return
+        }
+
+        let useModbusTcp = communicationPreferences.enabledTCP
+        if (communicationPreferences.enabledRTU && communicationPreferences.enabledTCP) {
+          const resp = await showDebuggerMessage('question', 'Select Protocol', 'Which Modbus protocol?', [
+            'RTU (Serial)',
+            'TCP',
+          ])
+          useModbusTcp = resp === 1
+        }
+
+        if (useModbusTcp) {
+          let targetIp: string | undefined
+          if (communicationPreferences.enabledDHCP) {
+            const previousIp = useOpenPLCStore.getState().deviceDefinitions.temporaryDhcpIp || ''
+            const result = await showDebuggerIpInput('Target IP Address', 'Enter the target device IP:', previousIp)
+            if (!result) {
+              setIsDebuggerProcessing(false)
+              return
+            }
+            targetIp = result
+            deviceActions.setTemporaryDhcpIp(targetIp)
+          } else {
+            targetIp = modbusTCP.tcpStaticHostConfiguration.ipAddress || undefined
+            if (!targetIp) {
+              await showDebuggerMessage('error', 'Configuration Error', 'No IP configured for Modbus TCP.', ['OK'])
+              setIsDebuggerProcessing(false)
+              return
+            }
+          }
+          debugConfig = { connectionType: 'tcp', connectionParams: { ipAddress: targetIp } }
+        } else {
+          const rtuPort = devDefs.configuration.communicationPort
+          const rtuSlaveId = modbusRTU.rtuSlaveId ?? undefined
+          if (!rtuPort) {
+            await showDebuggerMessage('error', 'Configuration Error', 'No port selected for Modbus RTU.', ['OK'])
+            setIsDebuggerProcessing(false)
+            return
+          }
+          if (rtuSlaveId === undefined) {
+            await showDebuggerMessage('error', 'Configuration Error', 'No slave ID configured for Modbus RTU.', ['OK'])
+            setIsDebuggerProcessing(false)
+            return
+          }
+          consoleActions.addLog({
+            id: crypto.randomUUID(),
+            level: 'info',
+            message: `Using RTU: Port=${rtuPort}, Baud=${modbusRTU.rtuBaudRate}, SlaveID=${rtuSlaveId}`,
+          })
+          debugConfig = {
+            connectionType: 'rtu',
+            connectionParams: { port: rtuPort, baudRate: parseInt(modbusRTU.rtuBaudRate, 10), slaveId: rtuSlaveId },
+          }
+        }
+      }
+
+      // Debug compilation
+      consoleActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Starting debug compilation...' })
+      const debugCompileResult = await compiler.compileForDebug({ projectData, boardTarget, projectPath }, (event) =>
+        logCompilerEvent(event, consoleActions.addLog),
+      )
+      if (!debugCompileResult.success) {
+        consoleActions.addLog({
+          id: crypto.randomUUID(),
+          level: 'error',
+          message: `Debug compilation failed: ${debugCompileResult.error ?? 'Unknown error'}`,
+        })
+        setIsDebuggerProcessing(false)
+        return
+      }
+
+      void handleMd5Verification(projectPath, boardTarget, debugConfig, isRuntimeTarget)
+    } catch (error: unknown) {
+      consoleActions.addLog({
+        id: crypto.randomUUID(),
+        level: 'error',
+        message: `Debugger init error: ${getErrorMessage(error)}`,
+      })
+      setIsDebuggerProcessing(false)
+    }
+  }, [
+    debuggerPort,
+    runtime,
+    compiler,
+    debugSession,
+    projectData,
+    deviceDefinitions,
+    projectMeta,
+    availableBoards,
+    isSimulatorBoard,
+    isDebuggerProcessing,
+    editingState,
+    executeSave,
+    addLog,
+  ])
+
+  // ---------------------------------------------------------------------------
+  // JSX
+  // ---------------------------------------------------------------------------
+
+  return (
+    <>
+      <TooltipSidebarWrapperButton tooltipContent='Search'>
+        <SearchButton />
+      </TooltipSidebarWrapperButton>
+      <TooltipSidebarWrapperButton tooltipContent='Open/Close Toolbox'>
+        <ZoomButton {...zoom} />
+      </TooltipSidebarWrapperButton>
+      <TooltipSidebarWrapperButton tooltipContent={isSimulatorBoard ? 'Use Start to build and run' : 'Compile'}>
+        <DownloadButton
+          disabled={isCompiling || isSimulatorBoard}
+          className={cn((isCompiling || isSimulatorBoard) && disabledButtonClass)}
+          onClick={() => void handleBuild()}
+        />
+      </TooltipSidebarWrapperButton>
+      <TooltipSidebarWrapperButton
+        tooltipContent={
+          isSimulatorBoard
+            ? simulatorRunning
+              ? 'Stop Simulator'
+              : 'Start Simulator'
+            : connectionStatus !== 'connected'
+              ? 'Connect to runtime first'
+              : plcStatus === 'RUNNING'
+                ? 'Stop PLC'
+                : 'Start PLC'
+        }
+      >
+        <PlayButton
+          onClick={isSimulatorBoard ? () => void handleSimulatorControl() : () => void handlePlcControl()}
+          disabled={isSimulatorBoard ? isCompiling || isDebuggerProcessing : connectionStatus !== 'connected'}
+          className={cn(
+            isSimulatorBoard
+              ? isCompiling || isDebuggerProcessing
+                ? disabledButtonClass
+                : ''
+              : connectionStatus !== 'connected'
+                ? disabledButtonClass
+                : '',
+          )}
+        >
+          {(isSimulatorBoard ? simulatorRunning : plcStatus === 'RUNNING') ? <StopIcon /> : null}
+        </PlayButton>
+      </TooltipSidebarWrapperButton>
+      <TooltipSidebarWrapperButton tooltipContent={isSimulatorBoard ? 'Use Start to debug' : 'Debugger'}>
+        <DebuggerButton
+          onClick={() => void handleDebuggerClick()}
+          disabled={isDebuggerProcessing || isSimulatorBoard}
+          isActive={isDebuggerVisible}
+          className={cn((isDebuggerProcessing || isSimulatorBoard) && disabledButtonClass)}
+        />
+      </TooltipSidebarWrapperButton>
+      <ChatButton />
+    </>
+  )
+}
diff --git a/src2/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx b/src/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
rename to src/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
diff --git a/src2/frontend/components/_organisms/workspace-activity-bar/index.tsx b/src/frontend/components/_organisms/workspace-activity-bar/index.tsx
similarity index 99%
rename from src2/frontend/components/_organisms/workspace-activity-bar/index.tsx
rename to src/frontend/components/_organisms/workspace-activity-bar/index.tsx
index f55130f0a..edd83abbc 100644
--- a/src2/frontend/components/_organisms/workspace-activity-bar/index.tsx
+++ b/src/frontend/components/_organisms/workspace-activity-bar/index.tsx
@@ -1,5 +1,4 @@
 import { useOpenPLCStore } from '../../../store'
-
 import { DividerActivityBar } from '../../_atoms/workspace-activity-bar/divider'
 import { ExitButton } from '../../_molecules/workspace-activity-bar/default/exit'
 import { TooltipSidebarWrapperButton } from '../../_molecules/workspace-activity-bar/tooltip-button'
diff --git a/src2/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx b/src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
similarity index 90%
rename from src2/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
rename to src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
index 54ba4ff0c..a6733487a 100644
--- a/src2/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
+++ b/src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
@@ -1,8 +1,8 @@
 import { useOpenPLCStore } from '../../../store'
-import { getFunctionBlockVariablesToCleanup } from '../../../utils/graphical/get-function-block-variables-to-cleanup'
 import { cn } from '../../../utils/cn'
-
+import { getFunctionBlockVariablesToCleanup } from '../../../utils/graphical/get-function-block-variables-to-cleanup'
 import { DividerActivityBar } from '../../_atoms/workspace-activity-bar/divider'
+import { removeElements } from '../../_molecules/graphical-editor/ladder/rung/ladder-utils/elements'
 import { DeleteElementButton } from '../../_molecules/workspace-activity-bar/default/exit'
 import { BlockButton } from '../../_molecules/workspace-activity-bar/ladder/block'
 import { CoilButton } from '../../_molecules/workspace-activity-bar/ladder/coil'
@@ -66,11 +66,12 @@ export const LadderToolbox = () => {
     const allNodesToRemove = flow?.rungs.flatMap((rung) => rung.selectedNodes || []) || []
 
     flow?.rungs.forEach((rung) => {
-      ladderFlowActions.removeNodes({
-        nodes: rung.selectedNodes || [],
-        editorName: editor.meta.name,
-        rungId: rung.id,
-      })
+      const selectedNodes = rung.selectedNodes || []
+      if (selectedNodes.length === 0) return
+
+      const { nodes: newNodes, edges: newEdges } = removeElements({ ...rung }, selectedNodes)
+      ladderFlowActions.setNodes({ editorName: editor.meta.name, rungId: rung.id, nodes: newNodes })
+      ladderFlowActions.setEdges({ editorName: editor.meta.name, rungId: rung.id, edges: newEdges })
       ladderFlowActions.setSelectedNodes({
         editorName: editor.meta.name,
         rungId: rung.id,
diff --git a/src2/frontend/components/_templates/.gitkeep b/src/frontend/components/_templates/.gitkeep
similarity index 100%
rename from src2/frontend/components/_templates/.gitkeep
rename to src/frontend/components/_templates/.gitkeep
diff --git a/src/renderer/components/_templates/[editors]/device-editor-slot.tsx b/src/frontend/components/_templates/[editors]/device-editor-slot.tsx
similarity index 100%
rename from src/renderer/components/_templates/[editors]/device-editor-slot.tsx
rename to src/frontend/components/_templates/[editors]/device-editor-slot.tsx
diff --git a/src/renderer/components/_templates/[editors]/device-editor-template.tsx b/src/frontend/components/_templates/[editors]/device-editor-template.tsx
similarity index 100%
rename from src/renderer/components/_templates/[editors]/device-editor-template.tsx
rename to src/frontend/components/_templates/[editors]/device-editor-template.tsx
diff --git a/src/renderer/components/_templates/[start]/main-content.tsx b/src/frontend/components/_templates/[start]/main-content.tsx
similarity index 100%
rename from src/renderer/components/_templates/[start]/main-content.tsx
rename to src/frontend/components/_templates/[start]/main-content.tsx
diff --git a/src/renderer/components/_templates/[start]/side-content.tsx b/src/frontend/components/_templates/[start]/side-content.tsx
similarity index 100%
rename from src/renderer/components/_templates/[start]/side-content.tsx
rename to src/frontend/components/_templates/[start]/side-content.tsx
diff --git a/src2/frontend/components/_templates/[workspace]/main-content.tsx b/src/frontend/components/_templates/[workspace]/main-content.tsx
similarity index 99%
rename from src2/frontend/components/_templates/[workspace]/main-content.tsx
rename to src/frontend/components/_templates/[workspace]/main-content.tsx
index 420fcfe02..293aa90d3 100644
--- a/src2/frontend/components/_templates/[workspace]/main-content.tsx
+++ b/src/frontend/components/_templates/[workspace]/main-content.tsx
@@ -1,7 +1,8 @@
-import { cn } from '../../../utils/cn'
-import { useOpenPLCStore } from '../../../store'
 import { ComponentPropsWithoutRef } from 'react'
 
+import { useOpenPLCStore } from '../../../store'
+import { cn } from '../../../utils/cn'
+
 type IWorkspaceMainContentProps = ComponentPropsWithoutRef<'div'>
 const WorkspaceMainContent = (props: IWorkspaceMainContentProps) => {
   const {
diff --git a/src/renderer/components/_templates/[workspace]/side-content.tsx b/src/frontend/components/_templates/[workspace]/side-content.tsx
similarity index 100%
rename from src/renderer/components/_templates/[workspace]/side-content.tsx
rename to src/frontend/components/_templates/[workspace]/side-content.tsx
diff --git a/src2/frontend/components/_templates/accelerator-handler.tsx b/src/frontend/components/_templates/accelerator-handler.tsx
similarity index 62%
rename from src2/frontend/components/_templates/accelerator-handler.tsx
rename to src/frontend/components/_templates/accelerator-handler.tsx
index 6dbaac415..a4c94ce64 100644
--- a/src2/frontend/components/_templates/accelerator-handler.tsx
+++ b/src/frontend/components/_templates/accelerator-handler.tsx
@@ -1,8 +1,16 @@
-import { useAccelerator, useCompiler, useProject, useWindow, useCapabilities } from '../../../middleware/shared/providers'
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import {
+  useAccelerator,
+  useCapabilities,
+  useCompiler,
+  useProject,
+  useTheme,
+  useWindow,
+} from '../../../middleware/shared/providers'
 import { useOpenPLCStore } from '../../store'
 import type { ModalTypes } from '../../store/slices/modal'
-import { useEffect, useState } from 'react'
-
+import { prepareSavePayload } from '../../utils/save-project'
 import { toast } from '../_features/[app]/toast/use-toast'
 
 const quitAppRequest = (isUnsaved: boolean, openModal: (modal: ModalTypes, data?: unknown) => void) => {
@@ -20,6 +28,7 @@ const AcceleratorHandler = () => {
   const compilerPort = useCompiler()
   const projectPort = useProject()
   const windowPort = useWindow()
+  const themePort = useTheme()
   const capabilities = useCapabilities()
 
   const [requestFlag, setRequestFlag] = useState(false)
@@ -28,18 +37,82 @@ const AcceleratorHandler = () => {
   const {
     project,
     editor: { meta },
+    editor: activeEditor,
+    editors,
     deviceDefinitions,
     workspace: { editingState, systemConfigs, close },
     modalActions: { openModal },
-    sharedWorkspaceActions: { closeProject },
-    workspaceActions: { switchAppTheme, toggleMaximizedWindow, setCloseWindow, setCloseApp, setCloseAppDarwin },
+    sharedWorkspaceActions: { closeProject, handleOpenProjectResponse },
+    workspaceActions: {
+      switchAppTheme,
+      toggleMaximizedWindow,
+      setCloseWindow,
+      setCloseAppDarwin,
+      setEditingState,
+      setModalOpen,
+      toggleCollapse,
+    },
     tabsActions: { removeTab },
+    fileActions: { setAllToSaved },
     pouActions: { deleteRequest: deletePouRequest },
     datatypeActions: { deleteRequest: deleteDatatypeRequest },
-    snapshotActions: { undo, redo },
+    snapshotActions: { undo, redo, markAllSaved },
   } = useOpenPLCStore()
   const isMonacoFocused: boolean = useOpenPLCStore((state) => state.isMonacoFocused)
   const selectedProjectTreeLeaf = useOpenPLCStore((state) => state.workspace.selectedProjectTreeLeaf)
+  const pendingRecentProjectRef = useRef<unknown>(null)
+
+  /**
+   * Shared save logic: sanitizes POUs, collects debug variables, saves, and updates state.
+   */
+  const executeSave = useCallback(async (): Promise<{ success: boolean }> => {
+    setEditingState('save-request')
+    toast({
+      title: 'Save changes',
+      description: 'Trying to save the changes in the project file.',
+      variant: 'warn',
+    })
+
+    try {
+      const params = prepareSavePayload({
+        projectPath: project.meta.path,
+        projectName: project.meta.name,
+        projectData: project.data,
+        deviceConfiguration: deviceDefinitions.configuration,
+        devicePinMapping: deviceDefinitions.pinMapping.pins,
+        editors,
+        activeEditor,
+      })
+
+      const res = await projectPort.saveProject(params)
+      if (res.success) {
+        setEditingState('saved')
+        setAllToSaved()
+        markAllSaved()
+        toast({
+          title: 'Changes saved!',
+          description: 'The project was saved successfully!',
+          variant: 'default',
+        })
+      } else {
+        setEditingState('unsaved')
+        toast({
+          title: 'Error in the save request!',
+          description: res.error ?? 'Save failed',
+          variant: 'fail',
+        })
+      }
+      return { success: res.success }
+    } catch {
+      setEditingState('unsaved')
+      toast({
+        title: 'Error in the save request!',
+        description: 'An unexpected error occurred while saving.',
+        variant: 'fail',
+      })
+      return { success: false }
+    }
+  }, [project, deviceDefinitions, editors, activeEditor, projectPort, setEditingState, setAllToSaved])
 
   /**
    * Export project accelerator
@@ -121,15 +194,27 @@ const AcceleratorHandler = () => {
    * Open recent project (editor-specific — data passed via IPC accelerator)
    */
   useEffect(() => {
-    const unsub = accelerator.onOpenRecent(() => {
+    const unsub = accelerator.onOpenRecent((projectData?: unknown) => {
       switch (editingState) {
         case 'saved':
         case 'initial-state':
-          // Recent project data is passed by the adapter via IPC callback
+          // Process immediately — data comes from the main process IPC event
+          if (projectData) {
+            handleOpenProjectResponse(projectData as Parameters<typeof handleOpenProjectResponse>[0])
+          }
           break
         case 'unsaved':
+          // Store pending data and show save modal with callback
+          pendingRecentProjectRef.current = projectData ?? null
           openModal('save-changes-project', {
             validationContext: 'open-recent-project',
+            onAfterAction: () => {
+              const data = pendingRecentProjectRef.current
+              pendingRecentProjectRef.current = null
+              if (data) {
+                handleOpenProjectResponse(data as Parameters<typeof handleOpenProjectResponse>[0])
+              }
+            },
           })
           break
         case 'save-request':
@@ -144,7 +229,7 @@ const AcceleratorHandler = () => {
       }
     })
     return unsub
-  }, [editingState, accelerator, openModal])
+  }, [editingState, accelerator, openModal, handleOpenProjectResponse])
 
   /**
    * Close project
@@ -157,19 +242,14 @@ const AcceleratorHandler = () => {
   }, [editingState, accelerator, closeProject])
 
   /**
-   * Save project
+   * Save project (Cmd+Shift+S)
    */
   useEffect(() => {
     const unsub = accelerator.onSaveProject(() => {
-      void projectPort.saveProject({
-        projectPath: project.meta.path,
-        projectData: project.data,
-        deviceConfiguration: deviceDefinitions.configuration,
-        devicePinMapping: deviceDefinitions.pinMapping.pins,
-      })
+      void executeSave()
     })
     return unsub
-  }, [project, deviceDefinitions, accelerator, projectPort])
+  }, [accelerator, executeSave])
 
   /**
    * Delete file
@@ -218,19 +298,34 @@ const AcceleratorHandler = () => {
   }, [selectedProjectTreeLeaf, accelerator, removeTab])
 
   /**
-   * Save file (saves entire project since files are part of project XML)
+   * Save file (Cmd+S) — saves entire project since files are part of project XML
    */
   useEffect(() => {
     const unsub = accelerator.onSaveFile(() => {
-      void projectPort.saveProject({
-        projectPath: project.meta.path,
-        projectData: project.data,
-        deviceConfiguration: deviceDefinitions.configuration,
-        devicePinMapping: deviceDefinitions.pinMapping.pins,
-      })
+      void executeSave()
     })
     return unsub
-  }, [selectedProjectTreeLeaf, accelerator, projectPort, project, deviceDefinitions])
+  }, [accelerator, executeSave])
+
+  /**
+   * Find in project (Cmd+Shift+F)
+   */
+  useEffect(() => {
+    const unsub = accelerator.onFindInProject(() => {
+      setModalOpen('findInProject', true)
+    })
+    return unsub
+  }, [accelerator, setModalOpen])
+
+  /**
+   * Switch perspective (F12)
+   */
+  useEffect(() => {
+    const unsub = accelerator.onSwitchPerspective(() => {
+      toggleCollapse()
+    })
+    return unsub
+  }, [accelerator, toggleCollapse])
 
   /**
    * Undo / Redo
@@ -251,9 +346,36 @@ const AcceleratorHandler = () => {
     return unsub
   }, [meta.name, isMonacoFocused, accelerator, redo])
 
+  /**
+   * Quit app (Ctrl+Q on Windows/Linux)
+   */
+  useEffect(() => {
+    const unsub = accelerator.onQuitApp(() => {
+      quitAppRequest(editingState === 'unsaved', openModal)
+    })
+    return unsub
+  }, [editingState, accelerator, openModal])
+
+  /**
+   * Theme update from main process
+   */
+  useEffect(() => {
+    const unsub = themePort.onThemeChanged(() => {
+      switchAppTheme()
+    })
+    return unsub
+  }, [themePort, switchAppTheme])
+
   /**
    * Window lifecycle events (editor-only, gated by capabilities)
    */
+  useEffect(() => {
+    if (!capabilities.hasNativeWindowControls) return
+
+    const unsub = windowPort.enableAutoCloseHandshake?.()
+    return unsub
+  }, [capabilities.hasNativeWindowControls, windowPort])
+
   useEffect(() => {
     if (!capabilities.hasNativeWindowControls) return
 
@@ -263,6 +385,15 @@ const AcceleratorHandler = () => {
     return unsub
   }, [capabilities.hasNativeWindowControls, windowPort, setCloseWindow])
 
+  useEffect(() => {
+    if (!capabilities.hasNativeWindowControls) return
+
+    const unsub = windowPort.onDarwinAppQuitting?.(() => {
+      setCloseAppDarwin(true)
+    })
+    return unsub
+  }, [capabilities.hasNativeWindowControls, windowPort, setCloseAppDarwin])
+
   useEffect(() => {
     if (!capabilities.hasNativeWindowControls) return
 
diff --git a/src2/frontend/components/_templates/app-layout.tsx b/src/frontend/components/_templates/app-layout.tsx
similarity index 89%
rename from src2/frontend/components/_templates/app-layout.tsx
rename to src/frontend/components/_templates/app-layout.tsx
index 0903b1c8b..b7cfba765 100644
--- a/src2/frontend/components/_templates/app-layout.tsx
+++ b/src/frontend/components/_templates/app-layout.tsx
@@ -1,27 +1,27 @@
-import { useOpenPLCStore } from '../../store'
-import { useSystem, useProject, useCapabilities } from '../../../middleware/shared/providers'
-import { cn } from '../../utils/cn'
 import { ComponentPropsWithoutRef, ReactNode, useEffect, useState } from 'react'
 
+import { useProject, useSystem } from '../../../middleware/shared/providers'
+import { useOpenPLCStore } from '../../store'
+import type { RungLadderState } from '../../store/slices/ladder'
+import { cn } from '../../utils/cn'
+import { ResolutionWarning } from '../_atoms/resolution-warning-message'
 import Toaster from '../_features/[app]/toast/toaster'
 import { ProjectModal } from '../_features/[start]/new-project/project-modal'
-import { ConfirmDeleteElementModal } from '../_organisms/modals/delete-confirmation-modal'
+import { RuntimeCreateUserModal, RuntimeLoginModal } from '../_organisms/modals'
 import { DebuggerMessageModal } from '../_organisms/modals/debugger-message-modal'
+import { ConfirmDeleteElementModal } from '../_organisms/modals/delete-confirmation-modal'
 import { QuitApplicationModal } from '../_organisms/modals/quit-application-modal'
 import { RuntimeConnectionLostModal } from '../_organisms/modals/runtime-connection-lost-modal'
+import type { SaveChangesFileModalData } from '../_organisms/modals/save-changes-file-modal'
 import { SaveChangesFileModal } from '../_organisms/modals/save-changes-file-modal'
+import type { SaveChangeModalProps } from '../_organisms/modals/save-changes-modal'
 import { SaveChangesModal } from '../_organisms/modals/save-changes-modal'
 import { ServerIpMismatchModal } from '../_organisms/modals/server-ip-mismatch-modal'
-import type { SaveChangeModalProps } from '../_organisms/modals/save-changes-modal'
-import type { SaveChangesFileModalData } from '../_organisms/modals/save-changes-file-modal'
-import type { RungLadderState } from '../../store/slices/ladder'
 import { TitleBar } from '../_organisms/title-bar'
-import { ResolutionWarning } from '../_atoms/resolution-warning-message'
 import { AcceleratorHandler } from './accelerator-handler'
 
 type AppLayoutProps = ComponentPropsWithoutRef<'main'>
 const AppLayout = ({ children, ...rest }: AppLayoutProps): ReactNode => {
-  const capabilities = useCapabilities()
   const system = useSystem()
   const projectPort = useProject()
   const [showComponent, setShowComponent] = useState(true)
@@ -84,6 +84,10 @@ const AppLayout = ({ children, ...rest }: AppLayoutProps): ReactNode => {
               validationContext={
                 (modals['save-changes-project'].data as SaveChangeModalProps)?.validationContext ?? 'close-project'
               }
+              onAfterAction={
+                (modals['save-changes-project'].data as SaveChangeModalProps & { onAfterAction?: () => void })
+                  ?.onAfterAction
+              }
             />
           )}
           {modals?.['save-changes-file']?.open === true && (
@@ -106,7 +110,9 @@ const AppLayout = ({ children, ...rest }: AppLayoutProps): ReactNode => {
           )}
           {modals?.['runtime-connection-lost']?.open === true && <RuntimeConnectionLostModal />}
           {modals?.['debugger-message']?.open === true && <DebuggerMessageModal />}
-          {capabilities.hasNativeMenu && <AcceleratorHandler />}
+          {modals?.['runtime-login']?.open === true && <RuntimeLoginModal />}
+          {modals?.['runtime-create-user']?.open === true && <RuntimeCreateUserModal />}
+          <AcceleratorHandler />
         </main>
       </div>
       <ResolutionWarning />
diff --git a/src2/frontend/components/ui/scroll-area/display.tsx b/src/frontend/components/ui/scroll-area/display.tsx
similarity index 99%
rename from src2/frontend/components/ui/scroll-area/display.tsx
rename to src/frontend/components/ui/scroll-area/display.tsx
index 067f977f1..99c3b4934 100644
--- a/src2/frontend/components/ui/scroll-area/display.tsx
+++ b/src/frontend/components/ui/scroll-area/display.tsx
@@ -1,6 +1,7 @@
-import { cn } from '../../../utils/cn'
 import { ForwardedRef, forwardRef, HTMLAttributes } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 type CustomDisplayProps = HTMLAttributes<HTMLDivElement>
 
 const CustomDisplay = forwardRef(
diff --git a/src/renderer/components/ui/scroll-area/index.ts b/src/frontend/components/ui/scroll-area/index.ts
similarity index 100%
rename from src/renderer/components/ui/scroll-area/index.ts
rename to src/frontend/components/ui/scroll-area/index.ts
diff --git a/src2/frontend/components/ui/scroll-area/root.tsx b/src/frontend/components/ui/scroll-area/root.tsx
similarity index 99%
rename from src2/frontend/components/ui/scroll-area/root.tsx
rename to src/frontend/components/ui/scroll-area/root.tsx
index a9b5106b8..b75a8064d 100644
--- a/src2/frontend/components/ui/scroll-area/root.tsx
+++ b/src/frontend/components/ui/scroll-area/root.tsx
@@ -1,7 +1,8 @@
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area'
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef, ElementRef, forwardRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const Root = forwardRef<
   ElementRef<typeof ScrollAreaPrimitive.Root>,
   ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>
diff --git a/src2/frontend/components/ui/scroll-area/scrollbar.tsx b/src/frontend/components/ui/scroll-area/scrollbar.tsx
similarity index 99%
rename from src2/frontend/components/ui/scroll-area/scrollbar.tsx
rename to src/frontend/components/ui/scroll-area/scrollbar.tsx
index 09ac8bd7e..33c4b0c2f 100644
--- a/src2/frontend/components/ui/scroll-area/scrollbar.tsx
+++ b/src/frontend/components/ui/scroll-area/scrollbar.tsx
@@ -1,7 +1,8 @@
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area'
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef, ElementRef, forwardRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const ScrollBar = forwardRef<
   ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,
   ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>
diff --git a/src2/frontend/components/ui/scroll-area/viewport.tsx b/src/frontend/components/ui/scroll-area/viewport.tsx
similarity index 99%
rename from src2/frontend/components/ui/scroll-area/viewport.tsx
rename to src/frontend/components/ui/scroll-area/viewport.tsx
index e172f42fb..4510408a9 100644
--- a/src2/frontend/components/ui/scroll-area/viewport.tsx
+++ b/src/frontend/components/ui/scroll-area/viewport.tsx
@@ -1,7 +1,8 @@
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area'
-import { cn } from '../../../utils/cn'
 import { ComponentPropsWithoutRef, ElementRef, forwardRef } from 'react'
 
+import { cn } from '../../../utils/cn'
+
 const Viewport = forwardRef<
   ElementRef<typeof ScrollAreaPrimitive.ScrollAreaViewport>,
   ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaViewport>
diff --git a/src/renderer/data/constants/icon-styles.ts b/src/frontend/data/constants/icon-styles.ts
similarity index 100%
rename from src/renderer/data/constants/icon-styles.ts
rename to src/frontend/data/constants/icon-styles.ts
diff --git a/src2/frontend/data/constants/language-icons.ts b/src/frontend/data/constants/language-icons.ts
similarity index 100%
rename from src2/frontend/data/constants/language-icons.ts
rename to src/frontend/data/constants/language-icons.ts
diff --git a/src2/frontend/data/constants/pou-icons.ts b/src/frontend/data/constants/pou-icons.ts
similarity index 100%
rename from src2/frontend/data/constants/pou-icons.ts
rename to src/frontend/data/constants/pou-icons.ts
index ac2a0e9b7..213cf2878 100644
--- a/src2/frontend/data/constants/pou-icons.ts
+++ b/src/frontend/data/constants/pou-icons.ts
@@ -1,7 +1,7 @@
 import { DataTypeIcon } from '../../assets/icons/project/DataType'
 import { DeviceIcon } from '../../assets/icons/project/Device'
-import { FunctionBlockIcon } from '../../assets/icons/project/FunctionBlock'
 import { FunctionIcon } from '../../assets/icons/project/Function'
+import { FunctionBlockIcon } from '../../assets/icons/project/FunctionBlock'
 import { ProgramIcon } from '../../assets/icons/project/Program'
 import { ResourceIcon } from '../../assets/icons/project/Resource'
 
diff --git a/src/frontend/data/library/MQTT.ts b/src/frontend/data/library/MQTT.ts
new file mode 100644
index 000000000..27331fe63
--- /dev/null
+++ b/src/frontend/data/library/MQTT.ts
@@ -0,0 +1,197 @@
+import { z } from 'zod'
+
+import { BaseLibraryPouSchema, BaseLibraryVariableSchema } from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const MQTTVariablesSchema = BaseLibraryVariableSchema
+
+const MQTTPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(MQTTVariablesSchema),
+})
+
+export const MQTTLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(MQTTPouSchema),
+})
+
+type MQTTLibrary = z.infer<typeof MQTTLibrarySchema>
+
+const MQTT: MQTTLibrary = {
+  name: 'MQTT',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'src/renderer/data/library/mqtt/st',
+  cPath: 'src/renderer/data/library/mqtt/c',
+  pous: [
+    {
+      name: 'MQTT_RECEIVE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'RECEIVE', class: 'input', type: { definition: 'base-type', value: 'BOOL' }, documentation: 'RECEIVE' },
+        { name: 'TOPIC', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'TOPIC' },
+        {
+          name: 'RECEIVED',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'RECEIVED',
+        },
+        {
+          name: 'MESSAGE',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+          documentation: 'MESSAGE',
+        },
+      ],
+      body: 'RECEIVED := 0;',
+      documentation:
+        'Receive MQTT messages for a particular TOPIC when RECEIVE is active. You must subscribe to a topic first before you can start receiving messages for that particular topic. Once a message is received, RECEIVED output is triggered, and MESSAGE will contain the received message as a STRING.',
+    },
+    {
+      name: 'MQTT_SEND',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SEND', class: 'input', type: { definition: 'base-type', value: 'BOOL' }, documentation: 'SEND' },
+        { name: 'TOPIC', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'TOPIC' },
+        {
+          name: 'MESSAGE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+          documentation: 'MESSAGE',
+        },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Sends a MESSAGE to a particular TOPIC when SEND input is triggered. Keep in mind that SEND is not configured as a rising edge input, which means that MQTT_SEND will continuously send messages every scan cycle while SEND is TRUE. If the message was sent without errors, SUCCESS will be TRUE.',
+    },
+    {
+      name: 'MQTT_CONNECT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'CONNECT', class: 'input', type: { definition: 'base-type', value: 'BOOL' }, documentation: 'CONNECT' },
+        { name: 'BROKER', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'BROKER' },
+        { name: 'PORT', class: 'input', type: { definition: 'base-type', value: 'UINT' }, documentation: 'PORT' },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Connect to a BROKER at a given PORT when CONNECT is triggered. If a successful connection is made, SUCCESS is set to TRUE',
+    },
+    {
+      name: 'MQTT_CONNECT_AUTH',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'CONNECT', class: 'input', type: { definition: 'base-type', value: 'BOOL' }, documentation: 'CONNECT' },
+        { name: 'BROKER', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'BROKER' },
+        { name: 'PORT', class: 'input', type: { definition: 'base-type', value: 'UINT' }, documentation: 'PORT' },
+        { name: 'USER', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'USER' },
+        {
+          name: 'PASSWORD',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+          documentation: 'PASSWORD',
+        },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Connect to an authenticated BROKER at a given PORT using the credentials from USER and PASSWORD when CONNECT is triggered. If a successful connection is made, SUCCESS is set to TRUE',
+    },
+    {
+      name: 'MQTT_SUBSCRIBE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'SUBSCRIBE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUBSCRIBE',
+        },
+        { name: 'TOPIC', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'TOPIC' },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Subscribe to a given TOPIC when SUBSCRIBE input is triggered. Upon a successful subscription, SUCCESS is set to TRUE. Keep in mind that once you subscribe to a topic, OpenPLC will start receiving messages sent to that topic and storing them in a message pool. You must use the MQTT_RECEIVE block to retrieve messages from the pool and free up space to receive more messages. The maximum pool size is currently limited to 10 messages. If you let messages accumulate in the pool you will start loosing messages once the pool is full.',
+    },
+    {
+      name: 'MQTT_UNSUBSCRIBE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'UNSUBSCRIBE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'UNSUBSCRIBE',
+        },
+        { name: 'TOPIC', class: 'input', type: { definition: 'base-type', value: 'STRING' }, documentation: 'TOPIC' },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Unsubscribe to a given TOPIC when UNSUBSCRIBE input is triggered. Upon a successful unsubscription, SUCCESS is set to TRUE. Keep in mind that once you unsubscribe to a topic, OpenPLC will stop storing messages sent to that topic in the message pool. However, messages received previously and not captured with a MQTT_RECEIVE block will remain in the pool using up pool space.',
+    },
+    {
+      name: 'MQTT_DISCONNECT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'DISCONNECT',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'DISCONNECT',
+        },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Disconnects from the current broker when DISCONNECT is set to TRUE. Upon a successful disconnection, SUCCESS is set to TRUE.',
+    },
+  ],
+}
+
+export { MQTT }
diff --git a/src/frontend/data/library/P1AM.ts b/src/frontend/data/library/P1AM.ts
new file mode 100644
index 000000000..8a0a2d7d8
--- /dev/null
+++ b/src/frontend/data/library/P1AM.ts
@@ -0,0 +1,180 @@
+import { z } from 'zod'
+
+import { BaseLibraryPouSchema, BaseLibraryVariableSchema } from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const P1AMVariablesSchema = BaseLibraryVariableSchema
+
+const P1AMPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(P1AMVariablesSchema),
+})
+
+export const P1AMLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(P1AMPouSchema),
+})
+
+type P1AMLibrary = z.infer<typeof P1AMLibrarySchema>
+
+const P1AM: P1AMLibrary = {
+  name: 'P1AM',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'src/renderer/data/library/p1am/st',
+  cPath: 'src/renderer/data/library/p1am/c',
+  pous: [
+    {
+      name: 'P1AM_INIT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'INIT', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'SUCCESS', class: 'output', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        "Initialize P1AM Modules and return the number of initialized modules on SUCCESS. If SUCCESS is zero, an error has occurred, or there aren't any modules on the bus",
+    },
+    {
+      name: 'P1_16CDR',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SLOT', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'O1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O5', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O6', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O7', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O8', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'I1 := 0;',
+      documentation:
+        'Get all inputs and update all outputs from P1-16CDR module. Also works with P1-15CDD1 and P1-15CDD2',
+    },
+    {
+      name: 'P1_08N',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SLOT', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'I1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'I1 := 0;',
+      documentation: 'Get all inputs from P1-08Nxx modules. Compatible with P1-08NA, P1-08ND3, P1-08NE3 and P1-08SIM',
+    },
+    {
+      name: 'P1_16N',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SLOT', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'I1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I9', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I10', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I11', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I12', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I13', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I14', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I15', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I16', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'I1 := 0;',
+      documentation: 'Get all inputs from P1-16Nxx modules. Compatible with P1-16ND3 and P1-16NE3',
+    },
+    {
+      name: 'P1_08T',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SLOT', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'O1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O5', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O6', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O7', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O8', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DUMMY', class: 'local', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'DUMMY := SLOT;',
+      documentation: 'Set all outputs on P1-08Txx modules. Compatible with P1-08TA, P1-08TD1, P1-08TD2 and P1-08TRS',
+    },
+    {
+      name: 'P1_16TR',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SLOT', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'O1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O5', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O6', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O7', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O8', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O9', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O10', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O11', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O12', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O13', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O14', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O15', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'O16', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DUMMY', class: 'local', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'DUMMY := SLOT;',
+      documentation: 'Set all outputs on P1-16TR modules. Also compatible with P1-15TD1 and P1-15TD2',
+    },
+    {
+      name: 'P1_04AD',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SLOT', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'I1', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'I2', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'I3', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'I4', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'DUMMY', class: 'local', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'DUMMY := SLOT;',
+      documentation: 'Get all analog inputs from P1-04ADxx modules. Compatible with P1-04AD, P1-04ADL-1 and P1-04ADL-2',
+    },
+  ],
+}
+
+export { P1AM }
diff --git a/src/frontend/data/library/additional-function-blocks.ts b/src/frontend/data/library/additional-function-blocks.ts
new file mode 100644
index 000000000..fdd3e9b74
--- /dev/null
+++ b/src/frontend/data/library/additional-function-blocks.ts
@@ -0,0 +1,341 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+} from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const AdditionalFunctionBlocksVariablesSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('derived-type'),
+      value: z.string(),
+    }),
+  ]),
+  initialValue: z
+    .lazy((): z.Schema<unknown> => AdditionalFunctionBlocksVariablesSchema.pick({ type: true }))
+    .optional(),
+})
+
+const AdditionalFunctionBlocksPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(AdditionalFunctionBlocksVariablesSchema),
+})
+
+export const AdditionalFunctionBlocksLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(AdditionalFunctionBlocksPouSchema),
+})
+
+type AdditionalFunctionBlocksLibrary = z.infer<typeof AdditionalFunctionBlocksLibrarySchema>
+
+const AdditionalFunctionBlocks: AdditionalFunctionBlocksLibrary = {
+  name: 'Additional Function Blocks',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'dummypath/wichwillbereplacedlater',
+  cPath: 'dummypath/wichwillbereplacedlater',
+  pous: [
+    {
+      name: 'RTC',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: '0 - current time, 1 - load time from PDT',
+        },
+        {
+          name: 'PDT',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+          documentation: 'Preset datetime',
+        },
+        {
+          name: 'Q',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          initialValue: { value: 'FALSE' },
+          documentation: 'Copy of IN',
+        },
+        {
+          name: 'CDT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+          documentation: 'Datetime, current or relative to PDT',
+        },
+        {
+          name: 'PREV_IN',
+          class: 'local',
+          type: { definition: 'base-type', value: 'BOOL' },
+          initialValue: { value: 'FALSE' },
+        },
+        { name: 'OFFSET', class: 'local', type: { definition: 'base-type', value: 'TIME' } },
+        { name: 'CURRENT_TIME', class: 'local', type: { definition: 'base-type', value: 'DT' } },
+      ],
+      body: '{__SET_VAR(data__->,CURRENT_TIME,,__CURRENT_TIME)}\n\n IF IN\n THEN\n   IF NOT PREV_IN\n   THEN\n       OFFSET := PDT - CURRENT_TIME;\n   END_IF;\n\n   (* PDT + time since PDT was loaded *)\n   CDT := CURRENT_TIME + OFFSET;\n ELSE\n   CDT := CURRENT_TIME;\n END_IF;\n\n Q := IN;\n PREV_IN := IN;',
+      documentation:
+        'The real time clock has many uses including time stamping, setting dates and times of day in batch reports, in alarm messages and so on.',
+    },
+    {
+      name: 'INTEGRAL',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'RUN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: '1 = integrate, 0 = hold',
+        },
+        {
+          name: 'R1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'Overriding reset',
+        },
+        {
+          name: 'XIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Input variable',
+        },
+        {
+          name: 'X0',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Initial value',
+        },
+        {
+          name: 'CYCLE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+          documentation: 'Sampling period',
+        },
+        { name: 'Q', class: 'output', type: { definition: 'base-type', value: 'BOOL' }, documentation: 'NOT R1' },
+        {
+          name: 'XOUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Integrated output',
+        },
+      ],
+      body: 'Q := NOT R1 ;\nIF R1 THEN XOUT := X0;\nELSIF RUN THEN XOUT := XOUT + XIN * TIME_TO_REAL(CYCLE);\nEND_IF;',
+      documentation: 'The integral function block integrates the value of input XIN over time.',
+    },
+    {
+      name: 'DERIVATIVE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'RUN', class: 'input', type: { definition: 'base-type', value: 'BOOL' }, documentation: '0 = reset' },
+        {
+          name: 'XIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Input to be differentiated',
+        },
+        {
+          name: 'CYCLE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+          documentation: 'Sampling period',
+        },
+        {
+          name: 'XOUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Differentiated output',
+        },
+        { name: 'X1', class: 'local', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'X2', class: 'local', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'X3', class: 'local', type: { definition: 'base-type', value: 'REAL' } },
+      ],
+      body: 'IF RUN THEN\n  XOUT := (3.0 * (XIN - X3) + X1 - X2)\n          / (10.0 * TIME_TO_REAL(CYCLE));\n  X3 := X2;\n  X2 := X1;\n  X1 := XIN;\nELSE \n  XOUT := 0.0;\n  X1 := XIN;\n  X2 := XIN;\n  X3 := XIN;\nEND_IF;',
+      documentation:
+        'The derivative function block produces an output XOUT proportional to the rate of change of the input XIN.',
+    },
+    {
+      name: 'PID',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'AUTO',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: '0 - manual, 1 - automatic',
+        },
+        {
+          name: 'PV',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Process variable',
+        },
+        { name: 'SP', class: 'input', type: { definition: 'base-type', value: 'REAL' }, documentation: 'Set point' },
+        {
+          name: 'X0',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Manual output adjustment - Typically from transfer station',
+        },
+        {
+          name: 'KP',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Proportional gain',
+        },
+        { name: 'TR', class: 'input', type: { definition: 'base-type', value: 'REAL' }, documentation: 'Reset time' },
+        {
+          name: 'TD',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Derivative time constant',
+        },
+        {
+          name: 'CYCLE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+          documentation: 'Sampling period',
+        },
+        { name: 'XOUT', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ERROR', class: 'local', type: { definition: 'base-type', value: 'REAL' }, documentation: 'PV - SP' },
+        {
+          name: 'ITERM',
+          class: 'local',
+          type: { definition: 'derived-type', value: 'INTEGRAL' },
+          documentation: 'FB for integral term',
+        },
+        {
+          name: 'DTERM',
+          class: 'local',
+          type: { definition: 'derived-type', value: 'DERIVATIVE' },
+          documentation: 'FB for derivative term',
+        },
+      ],
+      body: 'ERROR := PV - SP ;\n(*** Adjust ITERM so that XOUT := X0 when AUTO = 0 ***)\nITERM(RUN := AUTO, R1 := NOT AUTO, XIN := ERROR,\n      X0 := TR * (X0 - ERROR), CYCLE := CYCLE);\nDTERM(RUN := AUTO, XIN := ERROR, CYCLE := CYCLE);\nXOUT := KP * (ERROR + ITERM.XOUT/TR + DTERM.XOUT*TD);',
+      documentation:
+        'The PID (proportional, Integral, Derivative) function block provides the classical three term controller for closed loop control.',
+    },
+    {
+      name: 'RAMP',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'RUN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: '0 - track X0, 1 - ramp to/track X1',
+        },
+        { name: 'X0', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'X1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        {
+          name: 'TR',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+          documentation: 'Ramp duration',
+        },
+        {
+          name: 'CYCLE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+          documentation: 'Sampling period',
+        },
+        {
+          name: 'BUSY',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'BUSY = 1 during ramping period',
+        },
+        {
+          name: 'XOUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          initialValue: { value: '0.0' },
+        },
+        {
+          name: 'XI',
+          class: 'local',
+          type: { definition: 'base-type', value: 'REAL' },
+          initialValue: { value: '0.0' },
+          documentation: 'Initial value',
+        },
+        {
+          name: 'T',
+          class: 'local',
+          type: { definition: 'base-type', value: 'TIME' },
+          initialValue: { value: 'T#0s' },
+          documentation: 'Elapsed time of ramp',
+        },
+      ],
+      body: `BUSY := RUN ;
+IF RUN THEN
+  IF T >= TR THEN
+    BUSY := 0;
+    XOUT := X1;
+  ELSE XOUT := XI + (X1-XI) * TIME_TO_REAL(T)
+                            / TIME_TO_REAL(TR);
+    T := T + CYCLE;
+  END_IF;
+ELSE
+  XOUT := X0;
+  XI := X0;
+  T := T#0s;
+END_IF;`,
+      documentation: 'The RAMP function block is modelled on example given in the standard.',
+    },
+    {
+      name: 'HYSTERESIS',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'XIN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'XIN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'EPS',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'Q',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: `IF Q THEN
+  IF XIN1 < (XIN2 - EPS) THEN
+    Q := 0;
+  END_IF;
+ELSIF XIN1 > (XIN2 + EPS) THEN
+  Q := 1;
+END_IF;`,
+      documentation:
+        'The hysteresis function block provides a hysteresis boolean output driven by the difference of two floating point (REAL) inputs XIN1 and XIN2.',
+    },
+  ],
+}
+
+export { AdditionalFunctionBlocks }
diff --git a/src/frontend/data/library/arduino-function-blocks.ts b/src/frontend/data/library/arduino-function-blocks.ts
new file mode 100644
index 000000000..591bef82a
--- /dev/null
+++ b/src/frontend/data/library/arduino-function-blocks.ts
@@ -0,0 +1,439 @@
+import { z } from 'zod'
+
+import { BaseLibraryPouSchema, BaseLibraryVariableSchema } from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const ArduinoFunctionBlocksVariableSchema = BaseLibraryVariableSchema
+
+const ArduinoFunctionBlocksPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(ArduinoFunctionBlocksVariableSchema),
+})
+
+export const ArduinoFunctionBlocksLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(ArduinoFunctionBlocksPouSchema),
+})
+
+type ArduinoFunctionBlocksLibrary = z.infer<typeof ArduinoFunctionBlocksLibrarySchema>
+
+const ArduinoFunctionBlocks: ArduinoFunctionBlocksLibrary = {
+  name: 'Arduino Function Blocks',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'src/renderer/data/library/arduino-function-blocks/st',
+  cPath: 'src/renderer/data/library/arduino-function-blocks/c',
+  pous: [
+    {
+      name: 'DS18B20',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'PIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'Arduino pin where sensor is connected to',
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+      ],
+      body: 'OUT := 0.0;',
+      documentation: 'Reads temperature from one DS18B20 one-wire sensor connected to the pin specified in PIN',
+    },
+    {
+      name: 'DS18B20_2_OUT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'PIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'Arduino pin where sensor is connected to',
+        },
+        {
+          name: 'OUT_0',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_1',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+      ],
+      body: 'OUT := 0.0;',
+      documentation:
+        'Reads temperature from two DS18B20 one-wire sensors. Both sensors must be on the same bus connected to the pin specified in PIN',
+    },
+    {
+      name: 'DS18B20_3_OUT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'PIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'Arduino pin where sensor is connected to',
+        },
+        {
+          name: 'OUT_0',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_1',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_2',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+      ],
+      body: 'OUT := 0.0;',
+      documentation:
+        'Reads temperature from three DS18B20 one-wire sensors. All sensors must be on the same bus connected to the pin specified in PIN',
+    },
+    {
+      name: 'DS18B20_4_OUT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'PIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'Arduino pin where sensor is connected to',
+        },
+        {
+          name: 'OUT_0',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_1',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_2',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_3',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+      ],
+      body: 'OUT := 0.0;',
+      documentation:
+        'Reads temperature from four DS18B20 one-wire sensors. All sensors must be on the same bus connected to the pin specified in PIN',
+    },
+    {
+      name: 'DS18B20_5_OUT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'PIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'Arduino pin where sensor is connected to',
+        },
+        {
+          name: 'OUT_0',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_1',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_2',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_3',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+        {
+          name: 'OUT_4',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'Temperature output in Celsius',
+        },
+      ],
+      body: 'OUT := 0.0;',
+      documentation:
+        'Reads temperature from five DS18B20 one-wire sensors. All sensors must be on the same bus connected to the pin specified in PIN',
+    },
+    {
+      name: 'CLOUD_ADD_BOOL',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'VAR_NAME', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'BOOL_VAR', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'SSID := SSID;',
+      documentation:
+        'Add a BOOL variable to sync with the Arduino Cloud. VAR_NAME must have the same name as the variable set up in the Arduino IoT Cloud',
+    },
+    {
+      name: 'CLOUD_ADD_DINT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'VAR_NAME', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'DINT_VAR', class: 'input', type: { definition: 'base-type', value: 'DINT' } },
+      ],
+      body: 'SSID := SSID;',
+      documentation:
+        'Add an DINT variable (Arduino int) to sync with the Arduino Cloud. VAR_NAME must have the same name as the variable set up in the Arduino IoT Cloud',
+    },
+    {
+      name: 'CLOUD_ADD_REAL',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'VAR_NAME', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'REAL_VAR', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+      ],
+      body: 'SSID := SSID;',
+      documentation:
+        'Add a REAL variable (Arduino float) to sync with the Arduino Cloud. VAR_NAME must have the same name as the variable set up in the Arduino IoT Cloud',
+    },
+    {
+      name: 'CLOUD_BEGIN',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'THING_ID', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'SSID', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'PASS', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+      ],
+      body: 'SSID := SSID;',
+      documentation:
+        'Setup and initialize Arduino Cloud communication. Must be called before adding any variables (properties).',
+    },
+    {
+      name: 'PWM_CONTROLLER',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'CHANNEL', class: 'input', type: { definition: 'base-type', value: 'SINT' }, documentation: 'CHANNEL' },
+        { name: 'FREQ', class: 'input', type: { definition: 'base-type', value: 'REAL' }, documentation: 'FREQ' },
+        { name: 'DUTY', class: 'input', type: { definition: 'base-type', value: 'REAL' }, documentation: 'DUTY' },
+        {
+          name: 'internal_ch',
+          class: 'local',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'internal_ch',
+        },
+        {
+          name: 'internal_freq',
+          class: 'local',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'internal_freq',
+        },
+        {
+          name: 'internal_duty',
+          class: 'local',
+          type: { definition: 'base-type', value: 'REAL' },
+          documentation: 'internal_duty',
+        },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: `
+          IF CHANNEL < 1 THEN
+            SUCCESS := FALSE;
+            RETURN;
+          END_IF;
+
+
+          IF (CHANNEL <> internal_ch) OR (FREQ <> internal_freq) OR (DUTY <> internal_duty) THEN
+            SUCCESS := TRUE;
+          END_IF;
+        `,
+      documentation:
+        'Configures the CPU internal PWM peripheral to generate a PWM signal through hardware. If the CPU does not have a PWM peripheral, compiling this block will result in a compilation error. CHANNEL is the PWM channel number. For most Arduino boards that number is the pin number for the PWM capable pin. FREQ is the desired PWM frequency in Hz. DUTY is the PWM duty cycle (between 0 and 100).',
+    },
+    {
+      name: 'ARDUINOCAN_CONF',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'EN_PIN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+          documentation: 'Arduino CAN Enable pin',
+        },
+        {
+          name: 'BR',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+          documentation: 'Arduino CAN Baudrate',
+        },
+        {
+          name: 'DONE',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'Arduino CAN configuration Done flag',
+        },
+      ],
+      body: 'DONE := FALSE;',
+      documentation: 'Configure Arduino CAN communication',
+    },
+    {
+      name: 'ARDUINOCAN_WRITE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'ID',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+          documentation: 'Arduino CAN message ID',
+        },
+        {
+          name: 'D0',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN first payload byte',
+        },
+        {
+          name: 'D1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN second payload byte',
+        },
+        {
+          name: 'D2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN third payload byte',
+        },
+        {
+          name: 'D3',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN fourth payload byte',
+        },
+        {
+          name: 'D4',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN fifth payload byte',
+        },
+        {
+          name: 'D5',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN sixth payload byte',
+        },
+        {
+          name: 'D6',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN seventh payload byte',
+        },
+        {
+          name: 'D7',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+          documentation: 'Arduino CAN eighth payload byte',
+        },
+        {
+          name: 'DONE',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'Arduino CAN write done flag',
+        },
+      ],
+      body: 'DONE := FALSE;',
+      documentation: 'Write data to Arduino CAN bus',
+    },
+    {
+      name: 'ARDUINOCAN_WRITE_WORD',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'ID',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+          documentation: 'Arduino CAN message ID',
+        },
+        {
+          name: 'DATA',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+          documentation: 'Arduino CAN payload',
+        },
+        {
+          name: 'DONE',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'Arduino CAN write done flag',
+        },
+      ],
+      body: 'DONE := FALSE;',
+      documentation: 'Write word data to Arduino CAN bus',
+    },
+    {
+      name: 'ARDUINOCAN_READ',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        {
+          name: 'DATA',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+          documentation: 'Arduino CAN readed data from arduino can message',
+        },
+      ],
+      body: 'DATA := 0;',
+      documentation: 'CAN READ',
+    },
+  ],
+}
+
+export { ArduinoFunctionBlocks }
diff --git a/src/frontend/data/library/communication-blocks.ts b/src/frontend/data/library/communication-blocks.ts
new file mode 100644
index 000000000..c2b0b938b
--- /dev/null
+++ b/src/frontend/data/library/communication-blocks.ts
@@ -0,0 +1,92 @@
+import { z } from 'zod'
+
+import { BaseLibraryPouSchema, BaseLibraryVariableSchema } from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const CommunicationBlocksVariableSchema = BaseLibraryVariableSchema
+
+const CommunicationBlocksPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(CommunicationBlocksVariableSchema),
+})
+
+export const CommunicationBlocksLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(CommunicationBlocksPouSchema),
+})
+
+type CommunicationBlocksLibrary = z.infer<typeof CommunicationBlocksLibrarySchema>
+
+const CommunicationBlocks: CommunicationBlocksLibrary = {
+  name: 'Communication Blocks',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'src/renderer/data/library/communication-blocks/st',
+  cPath: 'src/renderer/data/library/communication-blocks/c',
+  pous: [
+    {
+      name: 'TCP_CONNECT',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'CONNECT', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'IP_ADDRESS', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'PORT', class: 'input', type: { definition: 'base-type', value: 'INT' } },
+        { name: 'UDP', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'SOCKET_ID', class: 'output', type: { definition: 'base-type', value: 'INT' } },
+      ],
+      body: 'SOCKET_ID := 0;',
+      documentation:
+        'Connect to a remote TCP server when CONNECT is TRUE. Upon success, this block returns the connection ID on SOCKET_ID. If SOCKET_ID is less than zero, then the connection was not successfull',
+    },
+    {
+      name: 'TCP_SEND',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'SEND', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'SOCKET_ID', class: 'input', type: { definition: 'base-type', value: 'INT' } },
+        { name: 'MSG', class: 'input', type: { definition: 'base-type', value: 'STRING' } },
+        { name: 'BYTES_SENT', class: 'output', type: { definition: 'base-type', value: 'INT' } },
+      ],
+      body: 'BYTES_SENT := 0;',
+      documentation:
+        'Send a message to a remote device using TCP/IP when SEND is TRUE. SOCKET_ID must receive a connection ID from a successfull connection using the TCP_Connect block. BYTES_SENT returns the number of bytes sent to the remote device. If BYTES_SENT is less than zero then an error occurred while trying to send the message',
+    },
+    {
+      name: 'TCP_RECEIVE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'RECEIVE', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'SOCKET_ID', class: 'input', type: { definition: 'base-type', value: 'INT' } },
+        { name: 'BYTES_RECEIVED', class: 'output', type: { definition: 'base-type', value: 'INT' } },
+        { name: 'MSG', class: 'output', type: { definition: 'base-type', value: 'STRING' } },
+      ],
+      body: 'BYTES_RECEIVED := 0;',
+      documentation:
+        'Send a message to a remote device using TCP/IP when SEND is TRUE. SOCKET_ID must receive a connection ID from a successfull connection using the TCP_Connect block. BYTES_RECEIVED returns the number of bytes received from the remote device. MSG is a String containing the message received',
+    },
+    {
+      name: 'TCP_CLOSE',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'CLOSE', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'SOCKET_ID', class: 'input', type: { definition: 'base-type', value: 'INT' } },
+        { name: 'SUCCESS', class: 'output', type: { definition: 'base-type', value: 'INT' } },
+      ],
+      body: 'SUCCESS := 0;',
+      documentation:
+        'Close the TCP connection with the remote server. If SUCCESS is less than zero, then the connection was not successfully closed, or the connection does not exist anymore.',
+    },
+  ],
+}
+
+export { CommunicationBlocks }
diff --git a/src/frontend/data/library/function/arithmetic.ts b/src/frontend/data/library/function/arithmetic.ts
new file mode 100644
index 000000000..f52a5d660
--- /dev/null
+++ b/src/frontend/data/library/function/arithmetic.ts
@@ -0,0 +1,222 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const ArithmeticVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const ArithmeticPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(ArithmeticVariableSchema),
+})
+
+const ArithmeticLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(ArithmeticPouSchema),
+})
+
+type ArithmeticLibrary = z.infer<typeof ArithmeticLibrarySchema>
+
+const Arithmetic: ArithmeticLibrary = {
+  name: 'Arithmetic',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'ADD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+      ],
+      body: 'Addition',
+      documentation: '(IN1: ANY_NUM, IN2:ANY_NUM) => OUT:ANY_NUM',
+      extensible: true,
+    },
+    {
+      name: 'MUL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+      ],
+      body: 'Multiplication',
+      documentation: '(IN1: ANY_NUM, IN2:ANY_NUM) => OUT:ANY_NUM',
+      extensible: true,
+    },
+    {
+      name: 'SUB',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+      ],
+      body: 'Subtraction',
+      documentation: '(IN1: ANY_NUM, IN2:ANY_NUM) => OUT:ANY_NUM',
+      extensible: false,
+    },
+    {
+      name: 'DIV',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+      ],
+      body: 'Division',
+      documentation: '(IN1: ANY_NUM, IN2:ANY_NUM) => OUT:ANY_NUM',
+      extensible: false,
+    },
+    {
+      name: 'MOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+      ],
+      body: 'Remainder (modulo)',
+      documentation: '(IN1: ANY_INT, IN2:ANY_INT) => OUT:ANY_INT',
+      extensible: false,
+    },
+    {
+      name: 'EXPT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Exponent',
+      documentation: '(IN1: ANY_REAL, IN2:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'MOVE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+      ],
+      body: 'Assignment',
+      documentation: '(IN: ANY, OUT:ANY) => OUT:ANY',
+      extensible: false,
+    },
+  ],
+}
+
+export { Arithmetic, ArithmeticLibrarySchema }
diff --git a/src/frontend/data/library/function/bit-shift.ts b/src/frontend/data/library/function/bit-shift.ts
new file mode 100644
index 000000000..dca87bc5a
--- /dev/null
+++ b/src/frontend/data/library/function/bit-shift.ts
@@ -0,0 +1,152 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const BitShiftVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const BitShiftPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(BitShiftVariableSchema),
+})
+
+const BitShiftLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(BitShiftPouSchema),
+})
+
+type BitShiftLibrary = z.infer<typeof BitShiftLibrarySchema>
+
+const BitShift: BitShiftLibrary = {
+  name: 'BitShift',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'SHL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'N',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+      ],
+      body: 'Shift Left',
+      documentation: '(IN: ANY_BIT, N:INT) => OUT:ANY_BIT',
+      extensible: false,
+    },
+    {
+      name: 'SHR',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'N',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+      ],
+      body: 'Shift Right',
+      documentation: '(IN: ANY_BIT, N:INT) => OUT:ANY_BIT',
+      extensible: false,
+    },
+    {
+      name: 'ROR',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' }, // need review
+        },
+        {
+          name: 'N',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' }, // need review
+        },
+      ],
+      body: 'Rotate Right',
+      documentation: '(IN: ANY_NBIT, N:INT) => OUT:ANY_NBIT',
+      extensible: false,
+    },
+    {
+      name: 'ROL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' }, // need review
+        },
+        {
+          name: 'N',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' }, // need review
+        },
+      ],
+      body: 'Rotate Left',
+      documentation: '(IN: ANY_NBIT, N:INT) => OUT:ANY_NBIT',
+      extensible: false,
+    },
+  ],
+}
+
+export { BitShift, BitShiftLibrarySchema }
diff --git a/src/frontend/data/library/function/bitwise.ts b/src/frontend/data/library/function/bitwise.ts
new file mode 100644
index 000000000..4215cbb3d
--- /dev/null
+++ b/src/frontend/data/library/function/bitwise.ts
@@ -0,0 +1,147 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const BitwiseVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const BitwisePouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(BitwiseVariableSchema),
+})
+
+const BitwiseLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(BitwisePouSchema),
+})
+
+type BitwiseLibrary = z.infer<typeof BitwiseLibrarySchema>
+
+const Bitwise: BitwiseLibrary = {
+  name: 'Bitwise',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'AND',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+      ],
+      body: 'Bitwise AND',
+      documentation: '(IN1: ANY_BIT, IN2:ANY_BIT) => OUT:ANY_BIT',
+      extensible: true,
+    },
+    {
+      name: 'OR',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+      ],
+      body: 'Bitwise OR',
+      documentation: '(IN1: ANY_BIT, IN2:ANY_BIT) => OUT:ANY_BIT',
+      extensible: true,
+    },
+    {
+      name: 'XOR',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+      ],
+      body: 'Bitwise XOR',
+      documentation: '(IN1: ANY_BIT, IN2:ANY_BIT) => OUT:ANY_BIT',
+      extensible: true,
+    },
+    {
+      name: 'NOT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_BIT' },
+        },
+      ],
+      body: 'Bitwise NOT',
+      documentation: '(IN: ANY_BIT) => OUT:ANY_BIT',
+      extensible: false,
+    },
+  ],
+}
+
+export { Bitwise, BitwiseLibrarySchema }
diff --git a/src/frontend/data/library/function/character-string.ts b/src/frontend/data/library/function/character-string.ts
new file mode 100644
index 000000000..1fc004242
--- /dev/null
+++ b/src/frontend/data/library/function/character-string.ts
@@ -0,0 +1,322 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const CharacterStringVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const CharacterStringPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(CharacterStringVariableSchema),
+})
+
+const CharacterStringLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(CharacterStringPouSchema),
+})
+
+type CharacterStringLibrary = z.infer<typeof CharacterStringLibrarySchema>
+
+const CharacterString: CharacterStringLibrary = {
+  name: 'CharacterString',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'LEN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Length of string',
+      documentation: '(IN:STRING) => OUT:INT',
+      extensible: false,
+    },
+    {
+      name: 'LEFT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'L',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'String left of',
+      documentation: '(IN:STRING, L:ANY_INT) => OUT:STRING',
+      extensible: false,
+    },
+    {
+      name: 'RIGHT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'L',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'String right of',
+      documentation: '(IN:STRING, L:ANY_INT) => OUT:STRING',
+      extensible: false,
+    },
+    {
+      name: 'MID',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'L',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'S',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'String from middle of',
+      documentation: '(IN:STRING, L:ANY_INT, S:ANY_INT) => OUT:STRING',
+      extensible: false,
+    },
+    {
+      name: 'CONCAT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Concatenation',
+      documentation: '(IN1:STRING, IN2:STRING) => OUT:STRING',
+      extensible: true,
+    },
+    {
+      name: 'CONCAT_DATE_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Time concatenation',
+      documentation: '(IN1:DATE, IN2:TOD) => OUT:DT',
+      extensible: false,
+    },
+    {
+      name: 'INSERT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'P',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Insertion (into)',
+      documentation: '(IN1:STRING, IN2:STRING, P:ANY_INT) => OUT:STRING',
+      extensible: false,
+    },
+    {
+      name: 'DELETE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'L',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'P',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Deletion (within)',
+      documentation: '(IN:STRING, L:ANY_INT, P:ANY_INT) => OUT:STRING',
+      extensible: false,
+    },
+    {
+      name: 'REPLACE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'L',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'P',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Replacement (within)',
+      documentation: '(IN1:STRING, IN2:STRING, L:ANY_INT, P:ANY_INT) => OUT:STRING',
+      extensible: false,
+    },
+    {
+      name: 'FIND',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Find position',
+      documentation: '(IN1:STRING, IN2:STRING) => OUT:INT',
+      extensible: false,
+    },
+  ],
+}
+
+export { CharacterString, CharacterStringLibrarySchema }
diff --git a/src/frontend/data/library/function/comparison.ts b/src/frontend/data/library/function/comparison.ts
new file mode 100644
index 000000000..2e3de2dd7
--- /dev/null
+++ b/src/frontend/data/library/function/comparison.ts
@@ -0,0 +1,202 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const ComparisonVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const ComparisonPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(ComparisonVariableSchema),
+})
+
+const ComparisonLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(ComparisonPouSchema),
+})
+
+type ComparisonLibrary = z.infer<typeof ComparisonLibrarySchema>
+
+const Comparison: ComparisonLibrary = {
+  name: 'Comparison',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'GT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Greater Than',
+      documentation: '(IN1: ANY, IN2: ANY) => OUT:BOOL',
+      extensible: true,
+    },
+    {
+      name: 'GE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Greater Than or equal to',
+      documentation: '(IN1: ANY, IN2: ANY) => OUT:BOOL',
+      extensible: true,
+    },
+    {
+      name: 'EQ',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Equal to',
+      documentation: '(IN1: ANY, IN2: ANY) => OUT:BOOL',
+      extensible: true,
+    },
+    {
+      name: 'LT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Less Than',
+      documentation: '(IN1: ANY, IN2: ANY) => OUT:BOOL',
+      extensible: true,
+    },
+    {
+      name: 'LE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Less Than or equal to',
+      documentation: '(IN1: ANY, IN2: ANY) => OUT:BOOL',
+      extensible: true,
+    },
+    {
+      name: 'NE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Not Equal to',
+      documentation: '(IN1: ANY, IN2: ANY) => OUT:BOOL',
+      extensible: false,
+    },
+  ],
+}
+
+export { Comparison, ComparisonLibrarySchema }
diff --git a/src/renderer/data/library/function/index.ts b/src/frontend/data/library/function/index.ts
similarity index 100%
rename from src/renderer/data/library/function/index.ts
rename to src/frontend/data/library/function/index.ts
diff --git a/src/frontend/data/library/function/numerical.ts b/src/frontend/data/library/function/numerical.ts
new file mode 100644
index 000000000..e98d19794
--- /dev/null
+++ b/src/frontend/data/library/function/numerical.ts
@@ -0,0 +1,272 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const NumericalVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const NumericalPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(NumericalVariableSchema),
+})
+
+const NumericalLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(NumericalPouSchema),
+})
+
+type NumericalLibrary = z.infer<typeof NumericalLibrarySchema>
+
+const Numerical: NumericalLibrary = {
+  name: 'Numerical',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'ABS',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+      ],
+      body: 'Absolute value',
+      documentation: '(IN:ANY_NUM) => OUT:ANY_NUM',
+      extensible: false,
+    },
+    {
+      name: 'SQRT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Square root (base 2)',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'LN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Arc tangent',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'LOG',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Logarithm to base 10',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'EXP',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Exponentiation',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'SIN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Sine',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'COS',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Cosine',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'TAN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Tangent',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'ASIN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Arc sine',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'ACOS',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Arc cosine',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+    {
+      name: 'ATAN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+      ],
+      body: 'Arc tangent',
+      documentation: '(IN:ANY_REAL) => OUT:ANY_REAL',
+      extensible: false,
+    },
+  ],
+}
+
+export { Numerical, NumericalLibrarySchema }
diff --git a/src/frontend/data/library/function/selection.ts b/src/frontend/data/library/function/selection.ts
new file mode 100644
index 000000000..20e1a2466
--- /dev/null
+++ b/src/frontend/data/library/function/selection.ts
@@ -0,0 +1,192 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const SelectionVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const SelectionPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(SelectionVariableSchema),
+})
+
+const SelectionLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(SelectionPouSchema),
+})
+
+type SelectionLibrary = z.infer<typeof SelectionLibrarySchema>
+
+const Selection: SelectionLibrary = {
+  name: 'Selection',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'SEL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'G',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'IN0',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+      ],
+      body: 'Binary selection (1 of 2)',
+      documentation: '(G:BOOL, IN0:ANY, IN1:ANY) => OUT:ANY',
+      extensible: false,
+    },
+    {
+      name: 'MAX',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+      ],
+      body: 'Maximum',
+      documentation: '(IN1:ANY, IN2:ANY) => OUT:ANY',
+      extensible: true,
+    },
+    {
+      name: 'MIN',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+      ],
+      body: 'Minimum',
+      documentation: '(IN1:ANY, IN2:ANY) => OUT:ANY',
+      extensible: true,
+    },
+    {
+      name: 'LIMIT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'MN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'MX',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+      ],
+      body: 'Limitation',
+      documentation: '(MN:ANY, IN:ANY, MX:ANY) => OUT:ANY',
+      extensible: false,
+    },
+    {
+      name: 'MUX',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'K',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'IN0',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY' },
+        },
+      ],
+      body: 'Multiplexer (select 1 of N)',
+      documentation: '(K:INT, IN0:ANY, IN1:ANY) => OUT:ANY',
+      extensible: true,
+    },
+  ],
+}
+
+export { Selection, SelectionLibrarySchema }
diff --git a/src/frontend/data/library/function/time.ts b/src/frontend/data/library/function/time.ts
new file mode 100644
index 000000000..47b0fd8cd
--- /dev/null
+++ b/src/frontend/data/library/function/time.ts
@@ -0,0 +1,327 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const TimeVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const TimePouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(TimeVariableSchema),
+})
+
+const TimeLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(TimePouSchema),
+})
+
+type TimeLibrary = z.infer<typeof TimeLibrarySchema>
+
+const Time: TimeLibrary = {
+  name: 'Time',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'ADD_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Time addition',
+      documentation: '(IN1:TIME, IN2:TIME) => OUT:TIME',
+      extensible: false,
+    },
+    {
+      name: 'ADD_TOD_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Time-of-day addition',
+      documentation: '(IN1:TOD, IN2:TIME) => OUT:TOD',
+      extensible: false,
+    },
+    {
+      name: 'ADD_DT_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Date addition',
+      documentation: '(IN1:DT, IN2:TIME) => OUT:DT',
+      extensible: false,
+    },
+    {
+      name: 'MUL_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Time multiplication',
+      documentation: '(IN1:TIME, IN2:ANY_NUM) => OUT:TIME',
+      extensible: false,
+    },
+    {
+      name: 'SUB_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Time subtraction',
+      documentation: '(IN1:TIME, IN2:TIME) => OUT:TIME',
+      extensible: false,
+    },
+    {
+      name: 'SUB_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Date subtraction',
+      documentation: '(IN1:DATE, IN2:DATE) => OUT:TIME',
+      extensible: false,
+    },
+    {
+      name: 'SUB_TOD_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Time-of-day subtraction',
+      documentation: '(IN1:TOD, IN2:TIME) => OUT:TOD',
+      extensible: false,
+    },
+    {
+      name: 'SUB_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Time-of-day subtraction',
+      documentation: '(IN1:TOD, IN2:TOD) => OUT:TIME',
+      extensible: false,
+    },
+    {
+      name: 'SUB_DT_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Date and time subtraction',
+      documentation: '(IN1:DT, IN2:TIME) => OUT:DT',
+      extensible: false,
+    },
+    {
+      name: 'SUB_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Date and time subtraction',
+      documentation: '(IN1:DT, IN2:DT) => OUT:TIME',
+      extensible: false,
+    },
+    {
+      name: 'DIV_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN1',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'IN2',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_NUM' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Time division',
+      documentation: '(IN1:TIME, IN2:ANY_NUM) => OUT:TIME',
+      extensible: false,
+    },
+  ],
+}
+
+export { Time, TimeLibrarySchema }
diff --git a/src/frontend/data/library/function/type-conversion.ts b/src/frontend/data/library/function/type-conversion.ts
new file mode 100644
index 000000000..69a9af3fa
--- /dev/null
+++ b/src/frontend/data/library/function/type-conversion.ts
@@ -0,0 +1,7812 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+  genericTypeSchema,
+} from '../../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const TypeConversionVariableSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('generic-type'),
+      value: genericTypeSchema.keyof(),
+    }),
+  ]),
+})
+
+const TypeConversionPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(TypeConversionVariableSchema),
+})
+
+const TypeConversionLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(TypeConversionPouSchema),
+})
+
+type TypeConversionLibrary = z.infer<typeof TypeConversionLibrarySchema>
+
+const TypeConversion: TypeConversionLibrary = {
+  name: 'TypeConversion',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'path/to/st/file',
+  cPath: 'path/to/c/file',
+  pous: [
+    {
+      name: 'BOOL_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'BOOL_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BOOL) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'SINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: SINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'INT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: INT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'DINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'LINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: USINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: UDINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: ULINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'REAL_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: REAL) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'LREAL_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LREAL) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'TIME_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TIME) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'DATE_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DATE) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'TOD_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: TOD) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'DT_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'STRING_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: STRING) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'BYTE_TO_LWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: BYTE) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'WORD_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: WORD) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'DWORD_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: DWORD) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_BOOL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: BOOL',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_SINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'SINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: SINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_INT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'INT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: INT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_DINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: DINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_LINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: LINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_REAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'REAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: REAL',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_LREAL',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LREAL' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: LREAL',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_TIME',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TIME' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: TIME',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: DATE',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_TOD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_DT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: DT',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_BYTE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_WORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_DWORD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'LWORD_TO_STRING',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'STRING' },
+        },
+      ],
+      body: 'Data type conversion',
+      documentation: '(IN: LWORD) => OUT: STRING',
+      extensible: false,
+    },
+    {
+      name: 'TRUNC',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'generic-type', value: 'ANY_REAL' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'generic-type', value: 'ANY_INT' },
+        },
+      ],
+      body: 'Rounding up/down',
+      documentation: '(IN: ANY_REAL) => OUT: ANY_INT',
+      extensible: false,
+    },
+    {
+      name: 'BCD_TO_USINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+      ],
+      body: 'Conversion from BCD',
+      documentation: '(IN: BYTE) => OUT: USINT',
+      extensible: false,
+    },
+    {
+      name: 'BCD_TO_UINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+      ],
+      body: 'Conversion from BCD',
+      documentation: '(IN: WORD) => OUT: UINT',
+      extensible: false,
+    },
+    {
+      name: 'BCD_TO_UDINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+      ],
+      body: 'Conversion from BCD',
+      documentation: '(IN: DWORD) => OUT: UDINT',
+      extensible: false,
+    },
+    {
+      name: 'BCD_TO_ULINT',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+      ],
+      body: 'Conversion from BCD',
+      documentation: '(IN: LWORD) => OUT: ULINT',
+      extensible: false,
+    },
+    {
+      name: 'USINT_TO_BCD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'USINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BYTE' },
+        },
+      ],
+      body: 'Conversion to BCD',
+      documentation: '(IN: USINT) => OUT: BYTE',
+      extensible: false,
+    },
+    {
+      name: 'UINT_TO_BCD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'WORD' },
+        },
+      ],
+      body: 'Conversion to BCD',
+      documentation: '(IN: UINT) => OUT: WORD',
+      extensible: false,
+    },
+    {
+      name: 'UDINT_TO_BCD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'UDINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DWORD' },
+        },
+      ],
+      body: 'Conversion to BCD',
+      documentation: '(IN: UDINT) => OUT: DWORD',
+      extensible: false,
+    },
+    {
+      name: 'ULINT_TO_BCD',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'ULINT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'LWORD' },
+        },
+      ],
+      body: 'Conversion to BCD',
+      documentation: '(IN: ULINT) => OUT: LWORD',
+      extensible: false,
+    },
+    {
+      name: 'DATE_AND_TIME_TO_TIME_OF_DAY',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'TOD' },
+        },
+      ],
+      body: 'Conversion to time-of-day',
+      documentation: '(IN: DT) => OUT: TOD',
+      extensible: false,
+    },
+    {
+      name: 'DATE_AND_TIME_TO_DATE',
+      type: 'function',
+      language: 'st',
+      variables: [
+        {
+          name: 'IN',
+          class: 'input',
+          type: { definition: 'base-type', value: 'DT' },
+        },
+        {
+          name: 'OUT',
+          class: 'output',
+          type: { definition: 'base-type', value: 'DATE' },
+        },
+      ],
+      body: 'Conversion to date',
+      documentation: '(IN: DT) => OUT: DATE',
+      extensible: false,
+    },
+  ],
+}
+
+export { TypeConversion, TypeConversionLibrarySchema }
diff --git a/src/renderer/data/library/index.ts b/src/frontend/data/library/index.ts
similarity index 100%
rename from src/renderer/data/library/index.ts
rename to src/frontend/data/library/index.ts
diff --git a/src/frontend/data/library/jaguar.ts b/src/frontend/data/library/jaguar.ts
new file mode 100644
index 000000000..af0b77bd5
--- /dev/null
+++ b/src/frontend/data/library/jaguar.ts
@@ -0,0 +1,77 @@
+import { z } from 'zod'
+
+import { BaseLibraryPouSchema, BaseLibraryVariableSchema } from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const JaguarVariablesSchema = BaseLibraryVariableSchema
+
+const JaguarPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(JaguarVariablesSchema),
+})
+
+export const JaguarLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(JaguarPouSchema),
+})
+
+type JaguarLibrary = z.infer<typeof JaguarLibrarySchema>
+
+const Jaguar: JaguarLibrary = {
+  name: 'Jaguar',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'src/renderer/data/library/jaguar/st',
+  cPath: 'src/renderer/data/library/jaguar/c',
+  pous: [
+    {
+      name: 'ADC_CONFIG',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'ADC_CH', class: 'input', type: { definition: 'base-type', value: 'INT' }, documentation: 'ADC_CH' },
+        {
+          name: 'ADC_TYPE',
+          class: 'input',
+          type: { definition: 'base-type', value: 'INT' },
+          documentation: 'ADC_TYPE',
+        },
+        {
+          name: 'ADC_CH_LOCAL',
+          class: 'local',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'ADC_CH_LOCAL',
+        },
+        {
+          name: 'ADC_TYPE_LOCAL',
+          class: 'local',
+          type: { definition: 'base-type', value: 'SINT' },
+          documentation: 'ADC_TYPE_LOCAL',
+        },
+        {
+          name: 'SUCCESS',
+          class: 'output',
+          type: { definition: 'base-type', value: 'BOOL' },
+          documentation: 'SUCCESS',
+        },
+      ],
+      body: `IF ADC_CH <> ADC_CH_LOCAL OR ADC_TYPE <> ADC_TYPE_LOCAL THEN
+    ADC_CH_LOCAL := ADC_CH;
+    ADC_TYPE_LOCAL := ADC_TYPE;
+    SUCCESS := TRUE;
+  ELSE
+    SUCCESS := FALSE;
+  END_IF;`,
+      documentation:
+        'Configures the analog channel inputs on the Jaguar board. ADC_CH must be between 0 - 3. ADC_TYPE must be between 0 - 3, where 0 = unipolar 10V, 1 = bipolar 10V, 2 = unipolar 5V, and 3 = bipolar 5V. Upon successful configuration of the ADC, SUCCESS is set to TRUE.',
+    },
+  ],
+}
+
+export { Jaguar }
diff --git a/src/frontend/data/library/sequent-microsystems-modules.ts b/src/frontend/data/library/sequent-microsystems-modules.ts
new file mode 100644
index 000000000..56e2e3b3c
--- /dev/null
+++ b/src/frontend/data/library/sequent-microsystems-modules.ts
@@ -0,0 +1,350 @@
+import { z } from 'zod'
+
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+} from '../../../middleware/shared/ports/plc-schemas'
+
+/** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  author: z.string(),
+  stPath: z.string(),
+  cPath: z.string(),
+})
+
+const SequentMicrosystemsModulesVariablesSchema = BaseLibraryVariableSchema.extend({
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('derived-type'),
+      value: z.string(),
+    }),
+  ]),
+  initialValue: z
+    .lazy((): z.Schema<unknown> => SequentMicrosystemsModulesVariablesSchema.pick({ type: true }))
+    .optional(),
+})
+
+const SequentMicrosystemsModulesPouSchema = BaseLibraryPouSchema.extend({
+  variables: z.array(SequentMicrosystemsModulesVariablesSchema),
+})
+
+export const SequentMicrosystemsModulesLibrarySchema = BaseLibrarySchema.extend({
+  pous: z.array(SequentMicrosystemsModulesPouSchema),
+})
+
+type SequentMicrosystemsModulesLibrary = z.infer<typeof SequentMicrosystemsModulesLibrarySchema>
+
+const SequentMicrosystemsModules: SequentMicrosystemsModulesLibrary = {
+  name: 'Sequent Microsystems Modules',
+  version: '1.0.0',
+  author: 'Autonomy Logic',
+  stPath: 'dummypath/wichwillbereplacedlater',
+  cPath: 'dummypath/wichwillbereplacedlater',
+  pous: [
+    {
+      name: 'SM_8RELAY',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: '01', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '02', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '03', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '04', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '05', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '06', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '07', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '08', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DUMMY', class: 'output', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'DUMMY := STACK;',
+      documentation: 'Update all outputs from 8-relays card',
+    },
+    {
+      name: 'SM_16RELAY',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: '01', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '02', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '03', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '04', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '05', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '06', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '07', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '08', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '09', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '010', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '011', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '012', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '013', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '014', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '015', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: '016', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DUMMY', class: 'output', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'DUMMY := STACK;',
+      documentation: 'Update all outputs from 16-relays card',
+    },
+    {
+      name: 'SM_8DIN',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'I1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'I1 := 0;',
+      documentation: 'Get all inputs from Sequent microsystems 8 HV Inputs modules',
+    },
+    {
+      name: 'SM_16DIN',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'I1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I9', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I10', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I11', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I12', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I13', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I14', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I15', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I16', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'I1 := 0;',
+      documentation: 'Get all inputs from Sequent microsystems 16 digital inputs modules.',
+    },
+    {
+      name: 'SM_4REL4IN',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'RELAY1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'AC_OPTO1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'AC_OPTO2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'AC_OPTO3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'AC_OPTO4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'PWM1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'PWM2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'PWM3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'PWM4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'FREQ1', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'FREQ2', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'FREQ3', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'FREQ4', class: 'output', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'BUTTON', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+      ],
+      body: 'OPTO1 := 0;',
+      documentation: 'Get all inputs from and set all outputs to SM_4REL4IN modules',
+    },
+    {
+      name: 'SM_INDUSTRIAL',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'LED1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'Q0_10V1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V2', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V3', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V4', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q4_20MA1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q4_20MA2', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q4_20MA3', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q4_20MA4', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD2', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD3', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD4', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OPTO1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'I0_10V1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I0_10V2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I0_10V3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I0_10V4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I4_20MA1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I4_20MA2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I4_20MA3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'I4_20MA4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+      ],
+      body: 'OPTO1 := 0;',
+      documentation: 'Get all input and set all outputs of a Sequent Microsystems Industrial Automation card.',
+    },
+    {
+      name: 'SM_RTD',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'TEMP1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP5', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP6', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP7', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'TEMP8', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+      ],
+      body: 'TEMP1 := 0.0;',
+      documentation: 'Get all temperature inputs from SM_RTD modules as REAL values in deg Celsius',
+    },
+    {
+      name: 'SM_BAS',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'TRIAC1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'TRIAC2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'TRIAC3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'TRIAC4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'LED4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'IN1_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN2_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN3_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN4_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN5_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN6_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN7_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'IN8_T', class: 'input', type: { definition: 'base-type', value: 'UINT' } },
+        { name: 'Q0_10V1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V2', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V3', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V4', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV5', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV6', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV7', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'UNIV8', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'DRY_C1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DRY_C8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OWB_T1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+      ],
+      body: 'DRY_C1 := 0;',
+      documentation: 'Get all input and set all outputs of a Sequent Microsystems Building Automation card.',
+    },
+    {
+      name: 'SM_HOME',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'RELAY1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY5', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY6', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY7', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'RELAY8', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'Q0_10V1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V2', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V3', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'Q0_10V4', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD1', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD2', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD3', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'QOD4', class: 'input', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OPTO1', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO2', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO3', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO4', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO5', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO6', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO7', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'OPTO8', class: 'output', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'ADC1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC5', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC6', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC7', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'ADC8', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T1', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T2', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T3', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+        { name: 'OWB_T4', class: 'output', type: { definition: 'base-type', value: 'REAL' } },
+      ],
+      body: 'OPTO1 := 0;',
+      documentation: 'Get all inputs and set all outputs of a Sequent Microsystems Home Automation card.',
+    },
+    {
+      name: 'SM_8MOSFET',
+      type: 'function-block',
+      language: 'st',
+      variables: [
+        { name: 'STACK', class: 'input', type: { definition: 'base-type', value: 'SINT' } },
+        { name: 'MOS1', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS2', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS3', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS4', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS5', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS6', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS7', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'MOS8', class: 'input', type: { definition: 'base-type', value: 'BOOL' } },
+        { name: 'DUMMY', class: 'local', type: { definition: 'base-type', value: 'SINT' } },
+      ],
+      body: 'DUMMY := STACK;',
+      documentation: 'Update all outputs from 8-mosfets card',
+    },
+  ],
+}
+
+export { SequentMicrosystemsModules }
diff --git a/src2/frontend/data/library/standard-function-blocks.ts b/src/frontend/data/library/standard-function-blocks.ts
similarity index 99%
rename from src2/frontend/data/library/standard-function-blocks.ts
rename to src/frontend/data/library/standard-function-blocks.ts
index 4318cc2c1..272ec9c7a 100644
--- a/src2/frontend/data/library/standard-function-blocks.ts
+++ b/src/frontend/data/library/standard-function-blocks.ts
@@ -1,6 +1,11 @@
-import { BaseLibraryPouSchema, BaseLibraryVariableSchema, baseTypeSchema } from '../../../middleware/shared/ports/plc-schemas'
 import { z } from 'zod'
 
+import {
+  BaseLibraryPouSchema,
+  BaseLibraryVariableSchema,
+  baseTypeSchema,
+} from '../../../middleware/shared/ports/plc-schemas'
+
 /** Library-level schema (name + version + paths). Not in plc-schemas so defined locally. */
 const BaseLibrarySchema = z.object({
   name: z.string(),
diff --git a/src2/frontend/data/sources/POU.tsx b/src/frontend/data/sources/POU.tsx
similarity index 100%
rename from src2/frontend/data/sources/POU.tsx
rename to src/frontend/data/sources/POU.tsx
index 557b59bb8..bb9618929 100644
--- a/src2/frontend/data/sources/POU.tsx
+++ b/src/frontend/data/sources/POU.tsx
@@ -1,8 +1,8 @@
 import { CppIcon } from '../../assets/icons/project/Cpp'
 import { DataTypeIcon } from '../../assets/icons/project/DataType'
 import { FBDIcon } from '../../assets/icons/project/FBD'
-import { FunctionBlockIcon } from '../../assets/icons/project/FunctionBlock'
 import { FunctionIcon } from '../../assets/icons/project/Function'
+import { FunctionBlockIcon } from '../../assets/icons/project/FunctionBlock'
 import { ILIcon } from '../../assets/icons/project/IL'
 import { LDIcon } from '../../assets/icons/project/LD'
 import { ProgramIcon } from '../../assets/icons/project/Program'
diff --git a/src2/frontend/data/sources/data-type.tsx b/src/frontend/data/sources/data-type.tsx
similarity index 100%
rename from src2/frontend/data/sources/data-type.tsx
rename to src/frontend/data/sources/data-type.tsx
diff --git a/src/frontend/env.d.ts b/src/frontend/env.d.ts
new file mode 100644
index 000000000..fbad0dd0c
--- /dev/null
+++ b/src/frontend/env.d.ts
@@ -0,0 +1,7 @@
+interface ImportMetaEnv {
+  readonly [key: string]: string | undefined
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
diff --git a/src2/frontend/hooks/.gitkeep b/src/frontend/hooks/.gitkeep
similarity index 100%
rename from src2/frontend/hooks/.gitkeep
rename to src/frontend/hooks/.gitkeep
diff --git a/src2/frontend/hooks/use-debug-composite-key.ts b/src/frontend/hooks/use-debug-composite-key.ts
similarity index 99%
rename from src2/frontend/hooks/use-debug-composite-key.ts
rename to src/frontend/hooks/use-debug-composite-key.ts
index a4146b237..1fb937861 100644
--- a/src2/frontend/hooks/use-debug-composite-key.ts
+++ b/src/frontend/hooks/use-debug-composite-key.ts
@@ -1,6 +1,7 @@
-import { useOpenPLCStore } from '../store'
 import { useCallback, useMemo } from 'react'
 
+import { useOpenPLCStore } from '../store'
+
 /**
  * Hook that returns a memoized function to build composite keys for debug variable lookups.
  * Handles both program POUs (simple `pouName:variableName` format) and function block POUs
diff --git a/src/frontend/hooks/use-pou-snapshot.ts b/src/frontend/hooks/use-pou-snapshot.ts
new file mode 100644
index 000000000..acbcc670d
--- /dev/null
+++ b/src/frontend/hooks/use-pou-snapshot.ts
@@ -0,0 +1,38 @@
+import { useCallback } from 'react'
+
+import { useOpenPLCStore } from '../store'
+
+/**
+ * Convenience hook wrapping snapshotActions.pushToHistory().
+ * Captures the current POU state (variables, body, globalVariables, and
+ * graphical flow state for LD/FBD) and pushes it to the undo history.
+ */
+export function usePouSnapshot() {
+  const {
+    project,
+    ladderFlows,
+    fbdFlows,
+    snapshotActions: { pushToHistory, undo, redo },
+  } = useOpenPLCStore()
+
+  const captureAndPush = useCallback(
+    (pouName: string) => {
+      const pou = project.data.pous.find((p) => p.name === pouName)
+      if (!pou) return
+
+      const ladderFlow = ladderFlows.find((f) => f.name === pouName)
+      const fbdFlow = fbdFlows.find((f) => f.name === pouName)
+
+      pushToHistory(pouName, {
+        variables: JSON.parse(JSON.stringify(pou.interface?.variables ?? [])),
+        body: JSON.parse(JSON.stringify(pou.body.value)),
+        ladderFlow: ladderFlow ? JSON.parse(JSON.stringify(ladderFlow)) : undefined,
+        fbdFlow: fbdFlow ? JSON.parse(JSON.stringify(fbdFlow)) : undefined,
+        globalVariables: JSON.parse(JSON.stringify(project.data.configurations.resource.globalVariables)),
+      })
+    },
+    [project.data.pous, project.data.configurations.resource.globalVariables, ladderFlows, fbdFlows, pushToHistory],
+  )
+
+  return { captureAndPush, undo, redo }
+}
diff --git a/src2/frontend/hooks/use-remove-tab.tsx b/src/frontend/hooks/use-remove-tab.tsx
similarity index 99%
rename from src2/frontend/hooks/use-remove-tab.tsx
rename to src/frontend/hooks/use-remove-tab.tsx
index 1805067ac..22b4aad3d 100644
--- a/src2/frontend/hooks/use-remove-tab.tsx
+++ b/src/frontend/hooks/use-remove-tab.tsx
@@ -1,6 +1,7 @@
-import { useOpenPLCStore } from '../store'
 import { useState } from 'react'
 
+import { useOpenPLCStore } from '../store'
+
 const useHandleRemoveTab = () => {
   const {
     sharedWorkspaceActions: { closeFile },
diff --git a/src2/frontend/hooks/use-runtime-polling.ts b/src/frontend/hooks/use-runtime-polling.ts
similarity index 100%
rename from src2/frontend/hooks/use-runtime-polling.ts
rename to src/frontend/hooks/use-runtime-polling.ts
index 2aba485cc..dcad0d03b 100644
--- a/src2/frontend/hooks/use-runtime-polling.ts
+++ b/src/frontend/hooks/use-runtime-polling.ts
@@ -1,8 +1,8 @@
 import { useCallback, useEffect, useRef } from 'react'
 
+import type { PlcStatus } from '../../middleware/shared/ports/types'
 import { useRuntime } from '../../middleware/shared/providers'
 import { useOpenPLCStore } from '../store'
-import type { PlcStatus } from '../../middleware/shared/ports/types'
 
 // Unified polling interval for both status and logs (in milliseconds).
 const POLL_INTERVAL_MS = 2000
diff --git a/src2/frontend/hooks/use-store-selectors.ts b/src/frontend/hooks/use-store-selectors.ts
similarity index 98%
rename from src2/frontend/hooks/use-store-selectors.ts
rename to src/frontend/hooks/use-store-selectors.ts
index 677d87673..03b7c5e65 100644
--- a/src2/frontend/hooks/use-store-selectors.ts
+++ b/src/frontend/hooks/use-store-selectors.ts
@@ -99,7 +99,7 @@ const remoteDeviceSelectors = {
       for (const device of remoteDevices) {
         if (!device.modbusTcpConfig?.ioGroups) continue
         for (const ioGroup of device.modbusTcpConfig.ioGroups) {
-          for (const point of ioGroup.ioPoints) {
+          for (const point of ioGroup.ioPoints ?? []) {
             ioPoints.push({
               deviceName: device.name,
               ioGroupName: ioGroup.name,
@@ -107,7 +107,7 @@ const remoteDeviceSelectors = {
               ioPointName: point.name,
               ioPointType: point.type,
               iecLocation: point.iecLocation,
-              alias: point.alias,
+              alias: point.alias ?? '',
             })
           }
         }
diff --git a/src2/frontend/hooks/useDebugPolling.ts b/src/frontend/hooks/useDebugPolling.ts
similarity index 64%
rename from src2/frontend/hooks/useDebugPolling.ts
rename to src/frontend/hooks/useDebugPolling.ts
index 40190c15c..bdb277bad 100644
--- a/src2/frontend/hooks/useDebugPolling.ts
+++ b/src/frontend/hooks/useDebugPolling.ts
@@ -2,47 +2,50 @@
  * Debug Polling Hook
  *
  * When the debugger is visible, polls variable values from the runtime
- * via debugBridge.getVariablesList() at a transport-aware interval.
+ * via DebuggerPort.getVariablesList() at a board-aware interval.
  *
- * Mirrors the desktop editor's polling loop (workspace-screen.tsx lines 1533-1676):
+ * Platform-agnostic — the DebuggerPort adapter handles the actual transport
+ * (IPC to main process, HTTP, WebRTC, simulator virtual serial port, etc.).
+ *
+ * Polling behavior:
+ * - Polls ONLY variables that are actively needed (watched, forced, graphed,
+ *   visible on the active diagram, or referenced in ST/IL source text)
  * - Single-batch-per-cycle with round-robin offset
  * - Dynamic batch sizing (halves on ERROR_OUT_OF_MEMORY)
  * - lastIndex-aware advancement (runtime may return partial data)
  * - isPolling guard to skip tick if previous poll is in progress
+ * - Diagram/source scan results are cached per {pouName, language, fbContext}
+ *   since the editor is read-only during debug
  *
- * Polling intervals per transport:
- * - Simulator (Modbus RTU): 50ms  (matches desktop DEBUGGER_POLL_INTERVAL_MS)
- * - WebRTC DataChannel:    200ms
- * - HTTP fallback:        2000ms
- *
- * The hook subscribes to the store's debugTransport field so the interval
- * automatically adjusts when the transport changes (e.g. HTTP → WebRTC upgrade).
+ * Polling intervals:
+ * - Simulator board: 50ms  (Modbus RTU frame timing)
+ * - Other boards:   200ms  (general purpose)
  */
 
 import { useCallback, useEffect, useRef } from 'react'
 
-import { useOpenPLCStore } from '../store'
-import { debugBridge } from '../services/debug/debug-bridge'
-import { getTypeSizeByName, parseValueByTypeName } from '../utils/variable-sizes'
 import type { DebugTreeNode } from '../../middleware/shared/ports/types'
+import { useDebugger } from '../../middleware/shared/providers'
+import { openPLCStoreBase, useOpenPLCStore } from '../store'
+import { buildActiveIndexSet } from '../utils/debug-polling-filter'
+import { getTypeSizeByName, parseValueByTypeName } from '../utils/variable-sizes'
 
-/** Polling interval for Modbus RTU / simulator (matches desktop editor). */
+/** Polling interval for simulator boards (Modbus RTU). */
 const SIMULATOR_POLL_INTERVAL_MS = 50
-/** Polling interval for WebRTC DataChannel. */
-const WEBRTC_POLL_INTERVAL_MS = 200
-/** Polling interval for HTTP fallback. */
-const HTTP_POLL_INTERVAL_MS = 2000
+/** Polling interval for non-simulator boards. */
+const DEFAULT_POLL_INTERVAL_MS = 200
 
-/** Default batch size for WebRTC/HTTP transports. */
+/** Default batch size for variable polling. */
 const DEFAULT_BATCH_SIZE = 60
-/** Batch size for Modbus RTU / simulator (matches desktop editor). */
+/** Batch size for simulator (smaller due to RTU frame limits). */
 const RTU_BATCH_SIZE = 20
 const MIN_BATCH_SIZE = 2
 
 /**
  * Collect ALL leaf indexes from a tree (ignoring expansion state).
+ * Used to build the full index→metadata lookup for parsing responses.
  */
-function collectAllLeafIndexes(nodes: DebugTreeNode[]): Map<number, { compositeKey: string; type: string }> {
+function collectAllLeafMeta(nodes: DebugTreeNode[]): Map<number, { compositeKey: string; type: string }> {
   const result = new Map<number, { compositeKey: string; type: string }>()
 
   function walk(node: DebugTreeNode) {
@@ -62,22 +65,13 @@ function collectAllLeafIndexes(nodes: DebugTreeNode[]): Map<number, { compositeK
   return result
 }
 
-/**
- * Determine the polling interval based on the active transport.
- */
-function getPollInterval(isSimulator: boolean, debugTransport: 'http' | 'webrtc'): number {
-  if (isSimulator) return SIMULATOR_POLL_INTERVAL_MS
-  if (debugTransport === 'webrtc') return WEBRTC_POLL_INTERVAL_MS
-  return HTTP_POLL_INTERVAL_MS
-}
-
 export interface UseDebugPollingOptions {
   debugTreesRef: React.MutableRefObject<Record<string, DebugTreeNode[]>>
 }
 
 export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void {
+  const debuggerPort = useDebugger()
   const isDebuggerVisible = useOpenPLCStore((state) => state.workspace.isDebuggerVisible)
-  const debugTransport = useOpenPLCStore((state) => state.session.debugTransport)
   const { workspaceActions, consoleActions } = useOpenPLCStore()
 
   const pollingIntervalRef = useRef<number | null>(null)
@@ -86,62 +80,74 @@ export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void
   const batchOffsetRef = useRef(0)
   const isPollingRef = useRef(false)
 
-  // Dynamic batch size — starts at max for the transport, halves on memory errors
+  // Dynamic batch size — starts at max, halves on memory errors
   const batchSizeRef = useRef(DEFAULT_BATCH_SIZE)
 
-  // Cached leaf index data — computed once when debugger starts, cleared when it stops.
-  const cachedLeavesRef = useRef<Map<number, { compositeKey: string; type: string }> | null>(null)
-  const cachedSortedIndexesRef = useRef<number[]>([])
+  // Full leaf index→metadata map — computed once when debugger starts.
+  const allLeavesRef = useRef<Map<number, { compositeKey: string; type: string }> | null>(null)
 
-  const getLeafData = useCallback(() => {
-    if (cachedLeavesRef.current) {
-      return { allLeaves: cachedLeavesRef.current, sortedIndexes: cachedSortedIndexesRef.current }
-    }
+  // Cache for diagram/source-visible variable scan results.
+  // Keyed by {pouName, language, fbContextKey}. Invalidated on POU/FB switch.
+  const visibleVarsCacheRef = useRef<{
+    pouName: string
+    language: string
+    fbContextKey: string
+    keys: Set<string>
+  } | null>(null)
+
+  /** Build the full leaf metadata map from all debug trees (once per session). */
+  const getAllLeaves = useCallback(() => {
+    if (allLeavesRef.current) return allLeavesRef.current
 
     const allTrees = debugTreesRef.current
     const allLeaves = new Map<number, { compositeKey: string; type: string }>()
     for (const pouTrees of Object.values(allTrees)) {
-      const leaves = collectAllLeafIndexes(pouTrees)
+      const leaves = collectAllLeafMeta(pouTrees)
       for (const [index, meta] of leaves) {
         allLeaves.set(index, meta)
       }
     }
 
     if (allLeaves.size > 0) {
-      cachedLeavesRef.current = allLeaves
-      cachedSortedIndexesRef.current = Array.from(allLeaves.keys()).sort((a, b) => a - b)
+      allLeavesRef.current = allLeaves
     }
 
-    return { allLeaves, sortedIndexes: cachedSortedIndexesRef.current }
+    return allLeaves
   }, [debugTreesRef])
 
   /**
    * Poll one batch of variables from the runtime.
-   * Mirrors the desktop editor's pollVariables() function.
    */
   const pollVariables = useCallback(async () => {
-    const { allLeaves, sortedIndexes } = getLeafData()
+    const allLeaves = getAllLeaves()
     if (allLeaves.size === 0) return
 
-    // Determine batch size based on transport type
-    const connectionType = debugBridge.getConnectionType()
-    const maxBatchSize = connectionType === 'simulator' ? RTU_BATCH_SIZE : DEFAULT_BATCH_SIZE
-    let currentBatchSize = Math.min(batchSizeRef.current, maxBatchSize)
+    // Build the filtered set of indexes to poll this tick
+    const state = openPLCStoreBase.getState()
+    const { activeIndexes, cacheResult } = buildActiveIndexSet(state, allLeaves, visibleVarsCacheRef.current)
+
+    // Update the diagram/source cache if it changed
+    if (cacheResult !== visibleVarsCacheRef.current) {
+      visibleVarsCacheRef.current = cacheResult
+    }
+
+    if (activeIndexes.length === 0) return
+
+    let currentBatchSize = batchSizeRef.current
 
     // Clamp offset to valid range
     let batchOffset = batchOffsetRef.current
-    if (batchOffset >= sortedIndexes.length) {
+    if (batchOffset >= activeIndexes.length) {
       batchOffset = 0
     }
 
     // Slice one batch from the current offset
-    let batch = sortedIndexes.slice(batchOffset, batchOffset + currentBatchSize)
+    let batch = activeIndexes.slice(batchOffset, batchOffset + currentBatchSize)
 
-    // Request variables from runtime via debugBridge
-    let result = await debugBridge.getVariablesList(batch)
+    // Request variables from runtime via debugger port
+    let result = await debuggerPort.getVariablesList(batch)
 
     // Handle ERROR_OUT_OF_MEMORY with retry (halve batch size, same offset)
-    // Matches desktop editor pattern (workspace-screen.tsx lines 1556-1560)
     while (!result.success && result.error === 'ERROR_OUT_OF_MEMORY' && currentBatchSize > MIN_BATCH_SIZE) {
       currentBatchSize = Math.max(MIN_BATCH_SIZE, Math.floor(currentBatchSize / 2))
       batchSizeRef.current = currentBatchSize
@@ -150,8 +156,8 @@ export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void
         level: 'warning',
         message: `Reduced debug batch size to ${currentBatchSize} due to runtime memory error.`,
       })
-      batch = sortedIndexes.slice(batchOffset, batchOffset + currentBatchSize)
-      result = await debugBridge.getVariablesList(batch)
+      batch = activeIndexes.slice(batchOffset, batchOffset + currentBatchSize)
+      result = await debuggerPort.getVariablesList(batch)
     }
 
     if (!result.success) {
@@ -163,11 +169,10 @@ export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void
     workspaceActions.setDebugDataStale(false)
 
     // Parse response buffer → variable values
-    // Matches desktop editor pattern (workspace-screen.tsx lines 1587-1627)
     let itemsProcessed = 0
 
     if (result.data && result.data.length > 0) {
-      const responseBuffer = result.data
+      const responseBuffer = new Uint8Array(result.data)
       const newValues = new Map<string, string>()
       let bufferOffset = 0
 
@@ -198,11 +203,10 @@ export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void
     }
 
     // Advance offset for next poll cycle (wraps around)
-    // Matches desktop editor (workspace-screen.tsx lines 1630-1632)
     if (itemsProcessed > 0) {
-      batchOffsetRef.current = (batchOffset + itemsProcessed) % sortedIndexes.length
+      batchOffsetRef.current = (batchOffset + itemsProcessed) % activeIndexes.length
     }
-  }, [getLeafData, workspaceActions, consoleActions])
+  }, [debuggerPort, getAllLeaves, workspaceActions, consoleActions])
 
   // Ref-based poll so the interval never resets due to callback identity changes
   const pollRef = useRef(pollVariables)
@@ -216,16 +220,15 @@ export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void
   })
 
   // Set up polling interval when debugger becomes visible.
-  // Re-creates the interval when debugTransport changes (HTTP ↔ WebRTC upgrade/downgrade).
   useEffect(() => {
     if (isDebuggerVisible) {
       // Reset state on session start
-      const connectionType = debugBridge.getConnectionType()
-      batchSizeRef.current = connectionType === 'simulator' ? RTU_BATCH_SIZE : DEFAULT_BATCH_SIZE
+      batchSizeRef.current = isSimulatorBoard ? RTU_BATCH_SIZE : DEFAULT_BATCH_SIZE
       batchOffsetRef.current = 0
       lastResponseTimestampRef.current = 0
+      visibleVarsCacheRef.current = null
 
-      const pollIntervalMs = getPollInterval(isSimulatorBoard, debugTransport)
+      const pollIntervalMs = isSimulatorBoard ? SIMULATOR_POLL_INTERVAL_MS : DEFAULT_POLL_INTERVAL_MS
 
       // Fire first poll immediately, then schedule at fixed rate
       // Skip tick if previous poll is still in progress (isPolling guard)
@@ -269,11 +272,11 @@ export function useDebugPolling({ debugTreesRef }: UseDebugPollingOptions): void
         clearInterval(staleCheckRef.current)
         staleCheckRef.current = null
       }
-      cachedLeavesRef.current = null
-      cachedSortedIndexesRef.current = []
+      allLeavesRef.current = null
+      visibleVarsCacheRef.current = null
       batchOffsetRef.current = 0
     }
-  }, [isDebuggerVisible, isSimulatorBoard, debugTransport, workspaceActions])
+  }, [isDebuggerVisible, isSimulatorBoard, workspaceActions])
 
   // Clean up on unmount
   useEffect(() => {
diff --git a/src/frontend/hooks/useDebugSession.ts b/src/frontend/hooks/useDebugSession.ts
new file mode 100644
index 000000000..f788ef42c
--- /dev/null
+++ b/src/frontend/hooks/useDebugSession.ts
@@ -0,0 +1,214 @@
+/**
+ * Debug Session Hook
+ *
+ * Manages the debug session lifecycle: read debug.c, build index/tree maps,
+ * commit debug artifacts to the store, connect/disconnect via DebuggerPort.
+ *
+ * Platform-agnostic — all protocol operations are delegated to the
+ * DebuggerPort and SimulatorPort provided by the PlatformProvider.
+ * The backend adapter decides the actual transport (IPC, HTTP, WebRTC, etc.).
+ */
+
+import { useCallback, useRef } from 'react'
+
+import type { DebugConnectionConfig, DebugTreeNode, FbInstanceInfo } from '../../middleware/shared/ports/types'
+import { useDebugger, useSimulator } from '../../middleware/shared/providers'
+import { useOpenPLCStore } from '../store'
+import { parseDebugFile } from '../utils/debug-parser'
+import { buildDebugVariableTreeMap, buildFbInstanceMap, buildVariableIndexMap } from '../utils/debugger-session'
+import { hexToBytes } from '../utils/hex'
+
+export interface UseDebugSessionReturn {
+  /**
+   * Connect to the debug target and start a debug session.
+   *
+   * Reads the debug file, parses it, builds variable index/tree/FB maps,
+   * connects via the debugger port, stores all artifacts in workspace,
+   * and activates the debugger UI.
+   *
+   * @param config — Connection target (simulator, TCP, RTU, WebSocket).
+   *                 If omitted, defaults to simulator.
+   */
+  connectAndStart: (config?: DebugConnectionConfig) => Promise<{ success: boolean; error?: string }>
+
+  /** Disconnect from the debug target and clear all debug state. */
+  stopSession: () => Promise<void>
+
+  /** Force or release a variable via the debugger port. */
+  forceVariable: (index: number, force: boolean, valueHex?: string) => Promise<boolean>
+
+  /** Debug tree nodes built for each POU, keyed by pouName. */
+  debugTreesRef: React.MutableRefObject<Record<string, DebugTreeNode[]>>
+}
+
+export function useDebugSession(): UseDebugSessionReturn {
+  const debuggerPort = useDebugger()
+  const simulator = useSimulator()
+
+  const {
+    project: { data: projectData, meta: projectMeta },
+    deviceDefinitions,
+    workspaceActions,
+    consoleActions,
+  } = useOpenPLCStore()
+
+  const debugTreesRef = useRef<Record<string, DebugTreeNode[]>>({})
+
+  const connectAndStart = useCallback(
+    async (config?: DebugConnectionConfig): Promise<{ success: boolean; error?: string }> => {
+      const debugConfig = config ?? ({ connectionType: 'simulator', connectionParams: {} } as DebugConnectionConfig)
+      const { project, workspaceActions: wsActions, consoleActions: logActions } = useOpenPLCStore.getState()
+      const boardTarget = deviceDefinitions.configuration.deviceBoard
+      const projectPath = project.meta.path
+
+      logActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Connecting debugger...' })
+
+      try {
+        // Read debug file
+        const debugFileResult = await debuggerPort.readDebugFile(projectPath, boardTarget)
+        if (!debugFileResult.success || !debugFileResult.content) {
+          const error = `Failed to read debug file: ${debugFileResult.error ?? 'No content'}`
+          logActions.addLog({ id: crypto.randomUUID(), level: 'error', message: error })
+          return { success: false, error }
+        }
+
+        wsActions.setDebugCContent(debugFileResult.content)
+
+        // Parse debug file and build variable maps
+        const parsed = parseDebugFile(debugFileResult.content)
+        const instances = project.data.configurations.resource.instances
+
+        // Build variable index map
+        const { indexMap, warnings } = buildVariableIndexMap(project.data.pous, instances, parsed)
+        for (const w of warnings) {
+          logActions.addLog({ id: crypto.randomUUID(), level: 'warning', message: w })
+        }
+
+        // Build debug variable tree
+        let treeMap = new Map<string, DebugTreeNode>()
+        const pouTrees: Record<string, DebugTreeNode[]> = {}
+        try {
+          const treeResult = buildDebugVariableTreeMap(project.data.pous, instances, parsed.variables, project.data)
+          treeMap = treeResult.treeMap
+
+          // Group trees by POU name for polling hook
+          for (const node of treeResult.trees) {
+            const pouName = node.compositeKey.split(':')[0]
+            if (!pouTrees[pouName]) pouTrees[pouName] = []
+            pouTrees[pouName].push(node)
+          }
+
+          logActions.addLog({
+            id: crypto.randomUUID(),
+            level: 'info',
+            message: `Debug tree builder: Built ${treeResult.trees.length} trees (${treeResult.complexCount} complex).`,
+          })
+        } catch {
+          logActions.addLog({
+            id: crypto.randomUUID(),
+            level: 'warning',
+            message: 'Debug tree builder encountered errors.',
+          })
+        }
+
+        debugTreesRef.current = pouTrees
+
+        // Build FB instance map
+        const fbDebugInstancesMap = buildFbInstanceMap(project.data.pous, instances)
+
+        const fbTypesCount = fbDebugInstancesMap.size
+        const totalFbInstances = Array.from(fbDebugInstancesMap.values()).reduce((sum, list) => sum + list.length, 0)
+        if (fbTypesCount > 0) {
+          logActions.addLog({
+            id: crypto.randomUUID(),
+            level: 'info',
+            message: `FB instance map: Found ${totalFbInstances} instances across ${fbTypesCount} FB types.`,
+          })
+        }
+
+        // Connect debugger via port
+        const connectResult = await debuggerPort.connect(debugConfig)
+        if (!connectResult.success) {
+          const error = `Debugger connection failed: ${connectResult.error ?? 'Unknown error'}`
+          logActions.addLog({ id: crypto.randomUUID(), level: 'error', message: error })
+          return { success: false, error }
+        }
+
+        // Store debug artifacts in workspace
+        wsActions.setDebugVariableIndexes(indexMap)
+        wsActions.setDebugVariableTree(treeMap)
+        wsActions.setFbDebugInstances(fbDebugInstancesMap)
+
+        // Set default selected instance for each FB type
+        fbDebugInstancesMap.forEach((instanceList: FbInstanceInfo[], fbTypeName: string) => {
+          if (instanceList.length > 0) {
+            wsActions.setFbSelectedInstance(fbTypeName, instanceList[0].key)
+          }
+        })
+
+        // Set target IP for non-simulator connections
+        if (debugConfig.connectionType !== 'simulator' && debugConfig.connectionParams.ipAddress) {
+          wsActions.setDebuggerTargetIp(debugConfig.connectionParams.ipAddress)
+        }
+
+        wsActions.setDebuggerVisible(true)
+        logActions.addLog({
+          id: crypto.randomUUID(),
+          level: 'info',
+          message: `Debugger connected. Found ${indexMap.size} debug variables.`,
+        })
+
+        return { success: true }
+      } catch (err: unknown) {
+        const error = `Debugger error: ${err instanceof Error ? err.message : String(err)}`
+        logActions.addLog({ id: crypto.randomUUID(), level: 'error', message: error })
+        return { success: false, error }
+      }
+    },
+    [debuggerPort, deviceDefinitions, projectData, projectMeta],
+  )
+
+  const stopSession = useCallback(async () => {
+    // If simulator is running, stop it
+    if (simulator.isRunning()) {
+      await simulator.stop()
+    }
+
+    // Disconnect debugger
+    await debuggerPort.disconnect()
+
+    // Clear all debug state
+    workspaceActions.clearDebugState()
+    debugTreesRef.current = {}
+  }, [simulator, debuggerPort, workspaceActions])
+
+  const forceVariable = useCallback(
+    async (index: number, force: boolean, valueHex = '00'): Promise<boolean> => {
+      const valueBuffer = hexToBytes(valueHex)
+      const result = await debuggerPort.setVariable(index, force, force ? valueBuffer : undefined)
+      if (result.success) {
+        consoleActions.addLog({
+          id: crypto.randomUUID(),
+          level: 'info',
+          message: 'Variable force applied successfully',
+        })
+        return true
+      } else {
+        consoleActions.addLog({
+          id: crypto.randomUUID(),
+          level: 'error',
+          message: `Failed to set variable: ${result.error}`,
+        })
+        return false
+      }
+    },
+    [debuggerPort, consoleActions],
+  )
+
+  return {
+    connectAndStart,
+    stopSession,
+    forceVariable,
+    debugTreesRef,
+  }
+}
diff --git a/src/locales/en/controls.json b/src/frontend/locales/en/controls.json
similarity index 100%
rename from src/locales/en/controls.json
rename to src/frontend/locales/en/controls.json
diff --git a/src/locales/en/createPOU.json b/src/frontend/locales/en/createPOU.json
similarity index 100%
rename from src/locales/en/createPOU.json
rename to src/frontend/locales/en/createPOU.json
diff --git a/src/locales/en/createProject.json b/src/frontend/locales/en/createProject.json
similarity index 100%
rename from src/locales/en/createProject.json
rename to src/frontend/locales/en/createProject.json
diff --git a/src/locales/en/editorTools.json b/src/frontend/locales/en/editorTools.json
similarity index 100%
rename from src/locales/en/editorTools.json
rename to src/frontend/locales/en/editorTools.json
diff --git a/src/locales/en/getProject.json b/src/frontend/locales/en/getProject.json
similarity index 100%
rename from src/locales/en/getProject.json
rename to src/frontend/locales/en/getProject.json
diff --git a/src/locales/en/index.ts b/src/frontend/locales/en/index.ts
similarity index 100%
rename from src/locales/en/index.ts
rename to src/frontend/locales/en/index.ts
diff --git a/src/locales/en/menu.json b/src/frontend/locales/en/menu.json
similarity index 100%
rename from src/locales/en/menu.json
rename to src/frontend/locales/en/menu.json
diff --git a/src/locales/en/navigation.json b/src/frontend/locales/en/navigation.json
similarity index 100%
rename from src/locales/en/navigation.json
rename to src/frontend/locales/en/navigation.json
diff --git a/src/locales/en/openProject.json b/src/frontend/locales/en/openProject.json
similarity index 100%
rename from src/locales/en/openProject.json
rename to src/frontend/locales/en/openProject.json
diff --git a/src/locales/en/powerRail.json b/src/frontend/locales/en/powerRail.json
similarity index 100%
rename from src/locales/en/powerRail.json
rename to src/frontend/locales/en/powerRail.json
diff --git a/src/locales/en/powerRailProperties.json b/src/frontend/locales/en/powerRailProperties.json
similarity index 100%
rename from src/locales/en/powerRailProperties.json
rename to src/frontend/locales/en/powerRailProperties.json
diff --git a/src/locales/en/projectServiceResponses.json b/src/frontend/locales/en/projectServiceResponses.json
similarity index 100%
rename from src/locales/en/projectServiceResponses.json
rename to src/frontend/locales/en/projectServiceResponses.json
diff --git a/src/locales/en/saveProject.json b/src/frontend/locales/en/saveProject.json
similarity index 100%
rename from src/locales/en/saveProject.json
rename to src/frontend/locales/en/saveProject.json
diff --git a/src/locales/en/settings.json b/src/frontend/locales/en/settings.json
similarity index 100%
rename from src/locales/en/settings.json
rename to src/frontend/locales/en/settings.json
diff --git a/src/locales/en/tools.json b/src/frontend/locales/en/tools.json
similarity index 100%
rename from src/locales/en/tools.json
rename to src/frontend/locales/en/tools.json
diff --git a/src/locales/en/translation.json b/src/frontend/locales/en/translation.json
similarity index 100%
rename from src/locales/en/translation.json
rename to src/frontend/locales/en/translation.json
diff --git a/src/locales/en/variables.json b/src/frontend/locales/en/variables.json
similarity index 100%
rename from src/locales/en/variables.json
rename to src/frontend/locales/en/variables.json
diff --git a/src2/frontend/locales/i18n.ts b/src/frontend/locales/i18n.ts
similarity index 100%
rename from src2/frontend/locales/i18n.ts
rename to src/frontend/locales/i18n.ts
diff --git a/src2/frontend/screens/start-screen.tsx b/src/frontend/screens/start-screen.tsx
similarity index 93%
rename from src2/frontend/screens/start-screen.tsx
rename to src/frontend/screens/start-screen.tsx
index fbecdf2ab..cc76f55f0 100644
--- a/src2/frontend/screens/start-screen.tsx
+++ b/src/frontend/screens/start-screen.tsx
@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 
+import { useCapabilities, useDevice, useProject, useSystem, useWindow } from '../../middleware/shared/providers'
 import { FolderIcon } from '../assets/icons/interface/Folder'
 import { PlusIcon } from '../assets/icons/interface/Plus'
 import { StickArrowIcon } from '../assets/icons/interface/StickArrow'
@@ -10,12 +11,11 @@ import { ProjectFilterBar } from '../components/_organisms/project-filter-bar'
 import { StartMainContent } from '../components/_templates/[start]/main-content'
 import { StartSideContent } from '../components/_templates/[start]/side-content'
 import { useOpenPLCStore } from '../store'
-import { useCapabilities, useDevice, useProject, useSystem, useWindow } from '../../middleware/shared/providers'
 
 const StartScreen = () => {
   const [searchFilterValue, setSearchFilterProps] = useState<string>('')
   const capabilities = useCapabilities()
-  const system = useSystem()
+  const _system = useSystem()
   const projectPort = useProject()
   const device = useDevice()
   const windowPort = useWindow()
@@ -24,14 +24,18 @@ const StartScreen = () => {
     workspaceActions: { setRecent },
     modalActions: { openModal },
     deviceActions: { setAvailableOptions },
+    sharedWorkspaceActions: { handleOpenProjectResponse },
   } = useOpenPLCStore()
 
   const handleCreateProject = () => {
     openModal('create-project', null)
   }
 
-  const handleOpenProject = () => {
-    void projectPort.openProject()
+  const handleOpenProject = async () => {
+    const result = await projectPort.openProject()
+    if (result.success && result.data) {
+      handleOpenProjectResponse(result.data)
+    }
   }
 
   const searchFilter = (value: string) => {
diff --git a/src2/frontend/screens/workspace-screen.tsx b/src/frontend/screens/workspace-screen.tsx
similarity index 96%
rename from src2/frontend/screens/workspace-screen.tsx
rename to src/frontend/screens/workspace-screen.tsx
index 3515cc0c9..1e05d7fc3 100644
--- a/src2/frontend/screens/workspace-screen.tsx
+++ b/src/frontend/screens/workspace-screen.tsx
@@ -1,18 +1,23 @@
-import { AIChatPanel } from '../components/_features/[workspace]/ai-chat/ai-chat-panel'
+import * as Tabs from '@radix-ui/react-tabs'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { ImperativePanelHandle } from 'react-resizable-panels'
+
+import { useCapabilities, useChatPanel, useDebugger, useDevice } from '../../middleware/shared/providers'
+import { ExitIcon } from '../assets/icons/interface/Exit'
 import { ClearConsoleButton } from '../components/_atoms/buttons/console/clear-console'
-import { ConsoleFilters } from '../components/_organisms/console/filters'
 import { DataTypeEditor } from '../components/_features/[workspace]/data-type'
 import { DeviceEditor } from '../components/_features/[workspace]/editor/device'
 import { RemoteDeviceEditor } from '../components/_features/[workspace]/editor/device/remote-device'
+import { GraphicalEditor } from '../components/_features/[workspace]/editor/graphical'
+import { MonacoEditor } from '../components/_features/[workspace]/editor/monaco'
+import { ResourcesEditor } from '../components/_features/[workspace]/editor/resource-editor'
 import { ModbusServerEditor } from '../components/_features/[workspace]/editor/server/modbus-server'
 import { OpcUaServerEditor } from '../components/_features/[workspace]/editor/server/opcua-server'
 import { S7CommServerEditor } from '../components/_features/[workspace]/editor/server/s7comm-server'
-import { MonacoEditor } from '../components/_features/[workspace]/editor/monaco'
-import { GraphicalEditor } from '../components/_features/[workspace]/editor/graphical'
-import { ResourcesEditor } from '../components/_features/[workspace]/editor/resource-editor'
 import { Search } from '../components/_features/[workspace]/search'
 import { VariablesPanel } from '../components/_molecules/variables-panel'
 import { Console as ConsoleComponent } from '../components/_organisms/console'
+import { ConsoleFilters } from '../components/_organisms/console/filters'
 import { Debugger } from '../components/_organisms/debugger'
 import { Explorer } from '../components/_organisms/explorer'
 import { Navigation } from '../components/_organisms/navigation'
@@ -23,19 +28,15 @@ import { VariablesEditor } from '../components/_organisms/variables-editor'
 import { WorkspaceActivityBar } from '../components/_organisms/workspace-activity-bar'
 import { WorkspaceMainContent } from '../components/_templates/[workspace]/main-content'
 import { WorkspaceSideContent } from '../components/_templates/[workspace]/side-content'
-import { ExitIcon } from '../assets/icons/interface/Exit'
 import { useRuntimePolling } from '../hooks/use-runtime-polling'
-import { useCapabilities, useDebugger, useDevice } from '../../middleware/shared/providers'
-import * as Tabs from '@radix-ui/react-tabs'
 import { useOpenPLCStore } from '../store'
 import { cn } from '../utils/cn'
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { ImperativePanelHandle } from 'react-resizable-panels'
 
 const SIMULATOR_BOARD_NAME = 'OpenPLC Simulator'
 
 const WorkspaceScreen = () => {
   const capabilities = useCapabilities()
+  const ChatPanel = useChatPanel()
   const debuggerPort = useDebugger()
   const device = useDevice()
 
@@ -276,7 +277,7 @@ const WorkspaceScreen = () => {
   }, [device, setAvailableOptions, setDeviceBoard])
 
   return (
-    <div className='flex h-full w-full bg-brand-dark dark:bg-neutral-950 overflow-hidden'>
+    <div className='flex h-full w-full overflow-hidden bg-brand-dark dark:bg-neutral-950'>
       <WorkspaceSideContent>
         <WorkspaceActivityBar
           defaultActivityBar={{
@@ -296,7 +297,7 @@ const WorkspaceScreen = () => {
           <ResizablePanel
             id='workspacePanel'
             order={2}
-            defaultSize={87}
+            defaultSize={84}
             className='relative flex h-full min-h-0 w-[400px]'
           >
             <ResizableHandle
@@ -305,14 +306,14 @@ const WorkspaceScreen = () => {
               className='absolute bottom-0 top-0 z-[99] my-[2px] w-[4px] py-2 transition-colors duration-200 data-[resize-handle-active="pointer"]:bg-brand-light data-[resize-handle-state="hover"]:bg-brand-light data-[resize-handle-active="pointer"]:dark:bg-neutral-700  data-[resize-handle-state="hover"]:dark:bg-neutral-700'
             />
 
-            <div id='workspaceContentPanel' className='flex h-full min-h-0 flex-1 grow flex-col gap-2'>
+            <div id='workspaceContentPanel' className='flex h-full min-h-0 flex-1 grow flex-col gap-2 overflow-hidden'>
               {tabs.length > 0 && <Navigation />}
               <ResizablePanelGroup id='editorPanelGroup' className={`flex h-full gap-2`} direction='vertical'>
                 <ResizablePanel
                   id='editorPanel'
                   order={1}
                   minSize={15}
-                  defaultSize={75}
+                  defaultSize={69}
                   className={cn(
                     'relative  flex flex-1 grow flex-col overflow-hidden rounded-lg border-2 border-neutral-200 bg-white px-4 py-4 dark:border-neutral-800 dark:bg-neutral-950',
                     {
@@ -427,12 +428,12 @@ const WorkspaceScreen = () => {
                   collapsible
                   defaultSize={31}
                   minSize={22}
-                  className='flex-1 grow min-h-0 rounded-lg border-2 border-neutral-200 bg-white p-4 data-[panel-size="0.0"]:hidden dark:border-neutral-800 dark:bg-neutral-950'
+                  className='min-h-0 flex-1 grow rounded-lg border-2 border-neutral-200 bg-white p-4 data-[panel-size="0.0"]:hidden dark:border-neutral-800 dark:bg-neutral-950'
                 >
                   <Tabs.Root
                     value={activeTab}
                     onValueChange={setActiveTab}
-                    className='relative flex h-full min-h-0 w-full flex-col gap-2'
+                    className='relative flex h-full min-h-0 w-full flex-col gap-2 overflow-hidden'
                   >
                     <Tabs.List className='flex h-7 w-64 select-none gap-4'>
                       <Tabs.Trigger
@@ -469,7 +470,7 @@ const WorkspaceScreen = () => {
                     <Tabs.Content
                       aria-label='Console panel content'
                       value='console'
-                      className='flex flex-col h-full min-h-0 w-full overflow-hidden p-2 data-[state=inactive]:hidden'
+                      className='flex h-full min-h-0 w-full flex-col overflow-hidden p-2 data-[state=inactive]:hidden'
                     >
                       <ConsoleComponent />
                     </Tabs.Content>
@@ -517,7 +518,7 @@ const WorkspaceScreen = () => {
                       <Tabs.Content
                         aria-label='PLC Logs panel content'
                         value='plc-logs'
-                        className='flex flex-col h-full min-h-0 w-full overflow-hidden p-2 data-[state=inactive]:hidden'
+                        className='flex h-full min-h-0 w-full flex-col overflow-hidden p-2 data-[state=inactive]:hidden'
                       >
                         <PlcLogs />
                       </Tabs.Content>
@@ -543,7 +544,7 @@ const WorkspaceScreen = () => {
               </ResizablePanelGroup>
             </div>
           </ResizablePanel>
-          {capabilities.hasAIAssistant && isChatOpen && isAIEnabled && hasAIConsented && (
+          {ChatPanel && capabilities.hasAIAssistant && isChatOpen && isAIEnabled && hasAIConsented && (
             <>
               <ResizableHandle
                 id='chatHandle'
@@ -555,9 +556,9 @@ const WorkspaceScreen = () => {
                 order={3}
                 defaultSize={16}
                 maxSize={25}
-                className='relative flex h-full min-h-0 w-full min-w-xs'
+                className='min-w-xs relative flex h-full min-h-0 w-full'
               >
-                <AIChatPanel />
+                <ChatPanel />
               </ResizablePanel>
             </>
           )}
diff --git a/src2/frontend/store/__tests__/ai-slice.test.ts b/src/frontend/store/__tests__/ai-slice.test.ts
similarity index 96%
rename from src2/frontend/store/__tests__/ai-slice.test.ts
rename to src/frontend/store/__tests__/ai-slice.test.ts
index 184710f0b..cd9988fff 100644
--- a/src2/frontend/store/__tests__/ai-slice.test.ts
+++ b/src/frontend/store/__tests__/ai-slice.test.ts
@@ -211,9 +211,7 @@ describe('createAISlice', () => {
 
       // Add MAX + 5 messages
       for (let i = 0; i < MAX_CONVERSATION_MESSAGES + 5; i++) {
-        store
-          .getState()
-          .aiActions.addMessage('MyPou', makeMessage({ id: `msg-${i}`, content: `Message ${i}` }))
+        store.getState().aiActions.addMessage('MyPou', makeMessage({ id: `msg-${i}`, content: `Message ${i}` }))
       }
 
       const messages = store.getState().ai.conversations[0].messages
@@ -368,18 +366,14 @@ describe('createAISliceFactory', () => {
   })
 
   it('overrides isEnabled and hasConsented from config', () => {
-    const store = createStore<AISlice>()(
-      createAISliceFactory({ isFeatureEnabled: true, hasUserConsented: true }),
-    )
+    const store = createStore<AISlice>()(createAISliceFactory({ isFeatureEnabled: true, hasUserConsented: true }))
     const { ai } = store.getState()
     expect(ai.isEnabled).toBe(true)
     expect(ai.hasConsented).toBe(true)
   })
 
   it('preserves other default values when config is provided', () => {
-    const store = createStore<AISlice>()(
-      createAISliceFactory({ isFeatureEnabled: true, hasUserConsented: false }),
-    )
+    const store = createStore<AISlice>()(createAISliceFactory({ isFeatureEnabled: true, hasUserConsented: false }))
     const { ai } = store.getState()
     expect(ai.model).toBe('haiku')
     expect(ai.creditsUsed).toBe(0)
@@ -393,9 +387,7 @@ describe('createAISliceFactory', () => {
   })
 
   it('creates functional actions when config is provided', () => {
-    const store = createStore<AISlice>()(
-      createAISliceFactory({ isFeatureEnabled: true, hasUserConsented: true }),
-    )
+    const store = createStore<AISlice>()(createAISliceFactory({ isFeatureEnabled: true, hasUserConsented: true }))
     store.getState().aiActions.setAIEnabled(false)
     expect(store.getState().ai.isEnabled).toBe(false)
   })
diff --git a/src2/frontend/store/__tests__/clipboard.test.ts b/src/frontend/store/__tests__/clipboard.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/clipboard.test.ts
rename to src/frontend/store/__tests__/clipboard.test.ts
diff --git a/src2/frontend/store/__tests__/console-slice.test.ts b/src/frontend/store/__tests__/console-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/console-slice.test.ts
rename to src/frontend/store/__tests__/console-slice.test.ts
diff --git a/src2/frontend/store/__tests__/device-pins-validation.test.ts b/src/frontend/store/__tests__/device-pins-validation.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/device-pins-validation.test.ts
rename to src/frontend/store/__tests__/device-pins-validation.test.ts
index fa0d12362..3bd6f6a40 100644
--- a/src2/frontend/store/__tests__/device-pins-validation.test.ts
+++ b/src/frontend/store/__tests__/device-pins-validation.test.ts
@@ -558,7 +558,7 @@ describe('checkIfPinNameIsValid', () => {
 
   it('returns Unknown when findIndex fails to locate the duplicate name', () => {
     // Force findIndex to return -1 even though some() returned true
-    const originalFindIndex = Array.prototype.findIndex
+    const _originalFindIndex = Array.prototype.findIndex
     const spied = vi.spyOn(Array.prototype, 'findIndex').mockReturnValueOnce(-1)
     const result = checkIfPinNameIsValid(pins, 'motor1')
     expect(result.ok).toBe(false)
diff --git a/src2/frontend/store/__tests__/device-slice.test.ts b/src/frontend/store/__tests__/device-slice.test.ts
similarity index 94%
rename from src2/frontend/store/__tests__/device-slice.test.ts
rename to src/frontend/store/__tests__/device-slice.test.ts
index 5a20e1664..bebfbe20a 100644
--- a/src2/frontend/store/__tests__/device-slice.test.ts
+++ b/src/frontend/store/__tests__/device-slice.test.ts
@@ -1,6 +1,6 @@
-import type { BoardInfo, CommunicationPort, DevicePin, TimingStats } from '../../../middleware/shared/ports/types'
 import { createStore } from 'zustand/vanilla'
 
+import type { BoardInfo, CommunicationPort, DevicePin, TimingStats } from '../../../middleware/shared/ports/types'
 import { createDeviceSlice, DeviceSlice } from '../slices/device'
 import { defaultDeviceConfiguration } from '../slices/device/data/constants'
 import * as pinsValidation from '../slices/device/validation/pins'
@@ -53,12 +53,7 @@ describe('createDeviceSlice', () => {
       expect(s.deviceAvailableOptions.availableBoards).toBeInstanceOf(Map)
       expect(s.deviceAvailableOptions.availableBoards.size).toBe(0)
       expect(s.deviceAvailableOptions.availableCommunicationPorts).toEqual([])
-      expect(s.deviceAvailableOptions.availableRTUInterfaces).toEqual([
-        'Serial',
-        'Serial1',
-        'Serial2',
-        'Serial3',
-      ])
+      expect(s.deviceAvailableOptions.availableRTUInterfaces).toEqual(['Serial', 'Serial1', 'Serial2', 'Serial3'])
       expect(s.deviceAvailableOptions.availableRTUBaudRates).toEqual([
         '9600',
         '14400',
@@ -171,8 +166,7 @@ describe('createDeviceSlice', () => {
           communicationConfiguration: {
             modbusRTU: { rtuInterface: 'Serial2', rtuBaudRate: '9600', rtuSlaveId: 5, rtuRS485ENPin: null },
             modbusTCP: defaultDeviceConfiguration.communicationConfiguration.modbusTCP,
-            communicationPreferences:
-              defaultDeviceConfiguration.communicationConfiguration.communicationPreferences,
+            communicationPreferences: defaultDeviceConfiguration.communicationConfiguration.communicationPreferences,
           },
         },
       })
@@ -190,9 +184,10 @@ describe('createDeviceSlice', () => {
             modbusTCP: {
               tcpMacAddress: 'AA:BB:CC:DD:EE:FF',
               tcpStaticHostConfiguration: { ipAddress: '', dns: '', gateway: '', subnet: '' },
-            } as any,
-            communicationPreferences:
-              defaultDeviceConfiguration.communicationConfiguration.communicationPreferences,
+            } as Partial<
+              typeof defaultDeviceConfiguration.communicationConfiguration.modbusTCP
+            > as typeof defaultDeviceConfiguration.communicationConfiguration.modbusTCP,
+            communicationPreferences: defaultDeviceConfiguration.communicationConfiguration.communicationPreferences,
           },
         },
       })
@@ -210,10 +205,14 @@ describe('createDeviceSlice', () => {
             modbusTCP: {
               tcpInterface: 'Wi-Fi',
               tcpMacAddress: '11:22:33:44:55:66',
-              tcpStaticHostConfiguration: { ipAddress: '10.0.0.1', dns: '8.8.8.8', gateway: '10.0.0.1', subnet: '255.255.255.0' },
+              tcpStaticHostConfiguration: {
+                ipAddress: '10.0.0.1',
+                dns: '8.8.8.8',
+                gateway: '10.0.0.1',
+                subnet: '255.255.255.0',
+              },
             },
-            communicationPreferences:
-              defaultDeviceConfiguration.communicationConfiguration.communicationPreferences,
+            communicationPreferences: defaultDeviceConfiguration.communicationConfiguration.communicationPreferences,
           },
         },
       })
@@ -224,9 +223,7 @@ describe('createDeviceSlice', () => {
 
     it('sets pinMapping', () => {
       const store = makeStore()
-      const pins: DevicePin[] = [
-        makePin({ pin: 'A0', pinType: 'analogInput', address: '%IW0', name: 'sensor' }),
-      ]
+      const pins: DevicePin[] = [makePin({ pin: 'A0', pinType: 'analogInput', address: '%IW0', name: 'sensor' })]
       store.getState().deviceActions.setDeviceDefinitions({ pinMapping: pins })
       expect(store.getState().deviceDefinitions.pinMapping.pins).toEqual(pins)
       expect(store.getState().deviceDefinitions.pinMapping.currentSelectedPinTableRow).toBe(-1)
@@ -257,7 +254,6 @@ describe('createDeviceSlice', () => {
       expect(after.configuration).toEqual(before.configuration)
       expect(after.pinMapping.pins).toEqual(before.pinMapping.pins)
     })
-
   })
 
   // -----------------------------------------------------------------------
@@ -360,9 +356,7 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       // Seed with a pin and select it
       store.getState().deviceActions.setDeviceDefinitions({
-        pinMapping: [
-          makePin({ pin: 'D0', pinType: 'digitalInput', address: '%IX0.0', name: 'pin0' }),
-        ],
+        pinMapping: [makePin({ pin: 'D0', pinType: 'digitalInput', address: '%IX0.0', name: 'pin0' })],
       })
       store.getState().deviceActions.selectPinTableRow(0)
       store.getState().deviceActions.createNewPin()
@@ -532,10 +526,7 @@ describe('createDeviceSlice', () => {
       it('returns error for duplicate pin', () => {
         const store = makeStore()
         store.getState().deviceActions.setDeviceDefinitions({
-          pinMapping: [
-            makePin({ pin: 'D0', address: '%IX0.0' }),
-            makePin({ pin: 'D1', address: '%IX0.1' }),
-          ],
+          pinMapping: [makePin({ pin: 'D0', address: '%IX0.0' }), makePin({ pin: 'D1', address: '%IX0.1' })],
         })
         store.getState().deviceActions.selectPinTableRow(1)
         const result = store.getState().deviceActions.updatePin({ pin: 'D0' })
@@ -605,7 +596,7 @@ describe('createDeviceSlice', () => {
           pinMapping: [makePin({ pin: 'D0', pinType: 'digitalInput', address: '%IX0.0' })],
         })
         store.getState().deviceActions.selectPinTableRow(0)
-        const result = store.getState().deviceActions.updatePin({ pinType: undefined } as any)
+        const result = store.getState().deviceActions.updatePin({ pinType: undefined } as Partial<DevicePin>)
         // pinType is falsy so both if-branches are skipped, hitting the break
         expect(result.ok).toBe(true)
       })
@@ -724,8 +715,8 @@ describe('createDeviceSlice', () => {
           pinMapping: [makePin({ pin: 'D0', address: '%IX0.0' })],
         })
         store.getState().deviceActions.selectPinTableRow(0)
-        // Cast to any to simulate an unknown key
-        const result = store.getState().deviceActions.updatePin({ address: '%IX9.9' } as any)
+        // Cast to Partial<DevicePin> to simulate an unknown key
+        const result = store.getState().deviceActions.updatePin({ address: '%IX9.9' } as Partial<DevicePin>)
         expect(result.ok).toBe(true)
       })
     })
@@ -774,8 +765,7 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setCommunicationPreferences({ enableRTU: true })
       expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.communicationPreferences
-          .enabledRTU,
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.communicationPreferences.enabledRTU,
       ).toBe(true)
       expect(store.getState().deviceUpdated.updated).toBe(true)
     })
@@ -784,8 +774,7 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setCommunicationPreferences({ enableTCP: true })
       expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.communicationPreferences
-          .enabledTCP,
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.communicationPreferences.enabledTCP,
       ).toBe(true)
     })
 
@@ -802,8 +791,7 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setCommunicationPreferences({ enableRTU: true })
       store.getState().deviceActions.setCommunicationPreferences({ enableTCP: true })
-      const prefs =
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.communicationPreferences
+      const prefs = store.getState().deviceDefinitions.configuration.communicationConfiguration.communicationPreferences
       expect(prefs.enabledRTU).toBe(true)
       expect(prefs.enabledTCP).toBe(true)
       expect(prefs.enabledDHCP).toBe(true) // default
@@ -817,34 +805,32 @@ describe('createDeviceSlice', () => {
     it('sets rtuInterface', () => {
       const store = makeStore()
       store.getState().deviceActions.setRTUConfig({ rtuConfig: 'rtuInterface', value: 'Serial3' })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuInterface,
-      ).toBe('Serial3')
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuInterface).toBe(
+        'Serial3',
+      )
       expect(store.getState().deviceUpdated.updated).toBe(true)
     })
 
     it('sets rtuBaudRate', () => {
       const store = makeStore()
       store.getState().deviceActions.setRTUConfig({ rtuConfig: 'rtuBaudRate', value: '9600' })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuBaudRate,
-      ).toBe('9600')
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuBaudRate).toBe(
+        '9600',
+      )
     })
 
     it('sets rtuSlaveId', () => {
       const store = makeStore()
       store.getState().deviceActions.setRTUConfig({ rtuConfig: 'rtuSlaveId', value: 10 })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuSlaveId,
-      ).toBe(10)
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuSlaveId).toBe(10)
     })
 
     it('sets rtuRS485ENPin', () => {
       const store = makeStore()
       store.getState().deviceActions.setRTUConfig({ rtuConfig: 'rtuRS485ENPin', value: 'D4' })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuRS485ENPin,
-      ).toBe('D4')
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusRTU.rtuRS485ENPin).toBe(
+        'D4',
+      )
     })
 
     it('sets rtuRS485ENPin to null', () => {
@@ -863,9 +849,9 @@ describe('createDeviceSlice', () => {
     it('sets tcpInterface', () => {
       const store = makeStore()
       store.getState().deviceActions.setTCPConfig({ tcpConfig: 'tcpInterface', value: 'Wi-Fi' })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpInterface,
-      ).toBe('Wi-Fi')
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpInterface).toBe(
+        'Wi-Fi',
+      )
       expect(store.getState().deviceUpdated.updated).toBe(true)
     })
 
@@ -875,9 +861,9 @@ describe('createDeviceSlice', () => {
         tcpConfig: 'tcpMacAddress',
         value: 'AA:BB:CC:DD:EE:FF',
       })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpMacAddress,
-      ).toBe('AA:BB:CC:DD:EE:FF')
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpMacAddress).toBe(
+        'AA:BB:CC:DD:EE:FF',
+      )
     })
   })
 
@@ -889,9 +875,9 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setTCPConfig({ tcpConfig: 'tcpInterface', value: 'Wi-Fi' })
       store.getState().deviceActions.setWifiConfig({ tcpWifiSSID: 'MyNetwork' })
-      expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpWifiSSID,
-      ).toBe('MyNetwork')
+      expect(store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpWifiSSID).toBe(
+        'MyNetwork',
+      )
     })
 
     it('sets wifi password when tcpInterface is Wi-Fi', () => {
@@ -927,8 +913,8 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setStaticHostConfiguration({ ipAddress: '192.168.1.100' })
       expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP
-          .tcpStaticHostConfiguration.ipAddress,
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpStaticHostConfiguration
+          .ipAddress,
       ).toBe('192.168.1.100')
       expect(store.getState().deviceUpdated.updated).toBe(true)
     })
@@ -937,8 +923,8 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setStaticHostConfiguration({ dns: '8.8.8.8' })
       expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP
-          .tcpStaticHostConfiguration.dns,
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpStaticHostConfiguration
+          .dns,
       ).toBe('8.8.8.8')
     })
 
@@ -946,8 +932,8 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setStaticHostConfiguration({ gateway: '192.168.1.1' })
       expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP
-          .tcpStaticHostConfiguration.gateway,
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpStaticHostConfiguration
+          .gateway,
       ).toBe('192.168.1.1')
     })
 
@@ -955,8 +941,8 @@ describe('createDeviceSlice', () => {
       const store = makeStore()
       store.getState().deviceActions.setStaticHostConfiguration({ subnet: '255.255.255.0' })
       expect(
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP
-          .tcpStaticHostConfiguration.subnet,
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpStaticHostConfiguration
+          .subnet,
       ).toBe('255.255.255.0')
     })
 
@@ -965,8 +951,7 @@ describe('createDeviceSlice', () => {
       store.getState().deviceActions.setStaticHostConfiguration({ ipAddress: '10.0.0.1' })
       store.getState().deviceActions.setStaticHostConfiguration({ dns: '1.1.1.1' })
       const hostCfg =
-        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP
-          .tcpStaticHostConfiguration
+        store.getState().deviceDefinitions.configuration.communicationConfiguration.modbusTCP.tcpStaticHostConfiguration
       expect(hostCfg.ipAddress).toBe('10.0.0.1')
       expect(hostCfg.dns).toBe('1.1.1.1')
       expect(hostCfg.gateway).toBe('') // default
diff --git a/src2/frontend/store/__tests__/device-types.test.ts b/src/frontend/store/__tests__/device-types.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/device-types.test.ts
rename to src/frontend/store/__tests__/device-types.test.ts
index bae798225..ca2a50c4a 100644
--- a/src2/frontend/store/__tests__/device-types.test.ts
+++ b/src/frontend/store/__tests__/device-types.test.ts
@@ -1,4 +1,4 @@
-import type { BoardInfo, CommunicationPort, DevicePin, PlcStatus, TimingStats } from '../../../middleware/shared/ports/types'
+import type { BoardInfo, CommunicationPort, TimingStats } from '../../../middleware/shared/ports/types'
 import type {
   ConnectionStatus,
   DeviceActions,
diff --git a/src2/frontend/store/__tests__/editor-slice.test.ts b/src/frontend/store/__tests__/editor-slice.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/editor-slice.test.ts
rename to src/frontend/store/__tests__/editor-slice.test.ts
index 2c982216f..3ad30ce92 100644
--- a/src2/frontend/store/__tests__/editor-slice.test.ts
+++ b/src/frontend/store/__tests__/editor-slice.test.ts
@@ -8,7 +8,10 @@ function makeStore() {
 }
 
 // Helpers to create editor models
-function makeTextualEditor(name: string, overrides?: Partial<{ language: 'il' | 'st' | 'python' | 'cpp'; pouType: 'program' | 'function' | 'function-block' }>): EditorModel {
+function makeTextualEditor(
+  name: string,
+  overrides?: Partial<{ language: 'il' | 'st' | 'python' | 'cpp'; pouType: 'program' | 'function' | 'function-block' }>,
+): EditorModel {
   return {
     type: 'plc-textual',
     meta: {
@@ -36,7 +39,15 @@ function makeGraphicalEditor(name: string, language: 'ld' | 'sfc' | 'fbd' = 'ld'
     return { ...base, graphical: { language: 'ld', openedRungs: [] } }
   }
   if (language === 'fbd') {
-    return { ...base, graphical: { language: 'fbd', hoveringElement: { elementId: null, hovering: false }, canEditorZoom: true, canEditorPan: true } }
+    return {
+      ...base,
+      graphical: {
+        language: 'fbd',
+        hoveringElement: { elementId: null, hovering: false },
+        canEditorZoom: true,
+        canEditorPan: true,
+      },
+    }
   }
   return { ...base, graphical: { language: 'sfc' } }
 }
diff --git a/src2/frontend/store/__tests__/fbd-slice.test.ts b/src/frontend/store/__tests__/fbd-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/fbd-slice.test.ts
rename to src/frontend/store/__tests__/fbd-slice.test.ts
diff --git a/src2/frontend/store/__tests__/fbd-types.test.ts b/src/frontend/store/__tests__/fbd-types.test.ts
similarity index 93%
rename from src2/frontend/store/__tests__/fbd-types.test.ts
rename to src/frontend/store/__tests__/fbd-types.test.ts
index 320ac6e62..3071b31a7 100644
--- a/src2/frontend/store/__tests__/fbd-types.test.ts
+++ b/src/frontend/store/__tests__/fbd-types.test.ts
@@ -91,7 +91,15 @@ describe('FBD Zod schemas', () => {
   })
 
   describe('zodFBDNodeTypesSchema', () => {
-    const validTypes = ['block', 'comment', 'connector', 'connection', 'input-variable', 'output-variable', 'inout-variable']
+    const validTypes = [
+      'block',
+      'comment',
+      'connector',
+      'connection',
+      'input-variable',
+      'output-variable',
+      'inout-variable',
+    ]
 
     it.each(validTypes)('accepts valid node type: %s', (type) => {
       const result = zodFBDNodeTypesSchema.safeParse(type)
diff --git a/src2/frontend/store/__tests__/file-slice.test.ts b/src/frontend/store/__tests__/file-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/file-slice.test.ts
rename to src/frontend/store/__tests__/file-slice.test.ts
diff --git a/src2/frontend/store/__tests__/history-slice.test.ts b/src/frontend/store/__tests__/history-slice.test.ts
similarity index 97%
rename from src2/frontend/store/__tests__/history-slice.test.ts
rename to src/frontend/store/__tests__/history-slice.test.ts
index a008b10fe..095c3c609 100644
--- a/src2/frontend/store/__tests__/history-slice.test.ts
+++ b/src/frontend/store/__tests__/history-slice.test.ts
@@ -1,7 +1,7 @@
 import { createStore } from 'zustand/vanilla'
 
-import { createHistorySlice, HISTORY_LIMIT } from '../slices/history'
 import type { HistorySlice, HistorySnapshot } from '../slices/history'
+import { createHistorySlice, HISTORY_LIMIT } from '../slices/history'
 
 function makeStore() {
   return createStore<HistorySlice>()(createHistorySlice)
@@ -418,8 +418,8 @@ describe('createHistorySlice', () => {
 
       const fullSnapshot = makeSnapshot({
         body: 'full',
-        ladderFlow: { name: 'ladder-1', rungs: [] } as any,
-        fbdFlow: { name: 'fbd-1', rungs: [] } as any,
+        ladderFlow: { name: 'ladder-1', rungs: [] } as unknown as HistorySnapshot['ladderFlow'],
+        fbdFlow: { name: 'fbd-1', rungs: [] } as unknown as HistorySnapshot['fbdFlow'],
         globalVariables: [
           {
             name: 'gVar',
@@ -431,7 +431,7 @@ describe('createHistorySlice', () => {
           },
         ],
         tasks: [{ name: 'task-1', triggering: 'Cyclic', interval: 'T#20ms', priority: 0 }],
-        instances: [{ name: 'inst-1', taskName: 'task-1', pouName: 'myPOU' }],
+        instances: [{ name: 'inst-1', task: 'task-1', program: 'myPOU' }],
         dataTypes: [],
       })
 
@@ -483,11 +483,11 @@ describe('createHistorySlice', () => {
       expect(popped).toBeDefined()
 
       // Mutate nested object in popped result
-      ;(popped!.body as any).nested.value = 999
+      ;(popped!.body as { nested: { value: number } }).nested.value = 999
 
       // Remaining snapshot in store should be unaffected
       const remaining = store.getState().history['deep-pou'].future[0]
-      expect((remaining.body as any).nested.value).toBe(42)
+      expect((remaining.body as { nested: { value: number } }).nested.value).toBe(42)
     })
   })
 })
diff --git a/src2/frontend/store/__tests__/ladder-slice.test.ts b/src/frontend/store/__tests__/ladder-slice.test.ts
similarity index 82%
rename from src2/frontend/store/__tests__/ladder-slice.test.ts
rename to src/frontend/store/__tests__/ladder-slice.test.ts
index 3a2d8ca09..4a46f89ca 100644
--- a/src2/frontend/store/__tests__/ladder-slice.test.ts
+++ b/src/frontend/store/__tests__/ladder-slice.test.ts
@@ -9,12 +9,31 @@ function makeStore() {
   return createStore<LadderFlowSlice>()(createLadderFlowSlice)
 }
 
+const defaultBlockData = {
+  draggable: true,
+  handles: [],
+  inputHandles: [],
+  outputHandles: [],
+  inputConnector: { id: 'in', glbPosition: { x: 0, y: 50 } },
+  outputConnector: { id: 'out', glbPosition: { x: 150, y: 50 } },
+  variant: { variables: [] },
+  connectedVariables: [],
+}
+
+const defaultRailData = {
+  handles: [{ id: 'rail-handle', x: 0, y: 50, position: 'right', glbPosition: { x: 0, y: 50 } }],
+  inputConnector: { id: 'rail-in', glbPosition: { x: 0, y: 50 } },
+  outputConnector: { id: 'rail-out', glbPosition: { x: 0, y: 50 } },
+}
+
 function makeNode(overrides?: Partial<Node>): Node {
+  const type = overrides?.type ?? 'block'
+  const baseData = type === 'powerRail' ? defaultRailData : defaultBlockData
   return {
     id: overrides?.id ?? 'node-1',
-    type: overrides?.type ?? 'block',
+    type,
     position: overrides?.position ?? { x: 0, y: 0 },
-    data: overrides?.data ?? { draggable: true },
+    data: overrides?.data ? { ...baseData, ...overrides.data } : baseData,
     draggable: overrides?.draggable ?? true,
     selectable: overrides?.selectable ?? true,
   }
@@ -55,7 +74,11 @@ function makeFlow(overrides?: Partial<LadderFlowType>): LadderFlowType {
 
 function seedFlowWithRung(store: ReturnType<typeof makeStore>, editorName = 'editor-1', rung?: RungLadderState) {
   const r = rung ?? makeRung()
-  store.getState().ladderFlowActions.startLadderRung({ editorName, rung: r })
+  store.getState().ladderFlowActions.addLadderFlow({
+    name: editorName,
+    updated: true,
+    rungs: [r],
+  })
   return r
 }
 
@@ -144,22 +167,31 @@ describe('createLadderFlowSlice', () => {
   // startLadderRung
   // -------------------------------------------------------------------------
   it('startLadderRung creates a flow and adds the rung', () => {
-    const rung = makeRung({ id: 'rung-1' })
-    store.getState().ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung })
+    store.getState().ladderFlowActions.startLadderRung({
+      editorName: 'editor-1',
+      rungId: 'rung-1',
+      defaultBounds: [800, 200],
+    })
 
     const { ladderFlows } = store.getState()
     expect(ladderFlows).toHaveLength(1)
     expect(ladderFlows[0].name).toBe('editor-1')
     expect(ladderFlows[0].rungs).toHaveLength(1)
     expect(ladderFlows[0].rungs[0].id).toBe('rung-1')
+    expect(ladderFlows[0].rungs[0].nodes.length).toBeGreaterThanOrEqual(2)
   })
 
   it('startLadderRung appends rung to existing flow', () => {
-    const rung1 = makeRung({ id: 'rung-1' })
-    const rung2 = makeRung({ id: 'rung-2' })
-
-    store.getState().ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung: rung1 })
-    store.getState().ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung: rung2 })
+    store.getState().ladderFlowActions.startLadderRung({
+      editorName: 'editor-1',
+      rungId: 'rung-1',
+      defaultBounds: [800, 200],
+    })
+    store.getState().ladderFlowActions.startLadderRung({
+      editorName: 'editor-1',
+      rungId: 'rung-2',
+      defaultBounds: [800, 200],
+    })
 
     const { ladderFlows } = store.getState()
     expect(ladderFlows).toHaveLength(1)
@@ -211,8 +243,12 @@ describe('createLadderFlowSlice', () => {
   // removeRung
   // -------------------------------------------------------------------------
   it('removeRung removes a rung by id', () => {
-    seedFlowWithRung(store, 'editor-1', makeRung({ id: 'rung-1' }))
-    store.getState().ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung: makeRung({ id: 'rung-2' }) })
+    store.getState().ladderFlowActions.addLadderFlow(
+      makeFlow({
+        name: 'editor-1',
+        rungs: [makeRung({ id: 'rung-1' }), makeRung({ id: 'rung-2' })],
+      }),
+    )
 
     store.getState().ladderFlowActions.removeRung('editor-1', 'rung-1')
 
@@ -254,16 +290,20 @@ describe('createLadderFlowSlice', () => {
   // duplicateRung
   // -------------------------------------------------------------------------
   it('duplicateRung inserts new rung after the source rung', () => {
-    seedFlowWithRung(store, 'editor-1', makeRung({ id: 'rung-1' }))
-    store.getState().ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung: makeRung({ id: 'rung-2' }) })
+    store.getState().ladderFlowActions.addLadderFlow(
+      makeFlow({
+        name: 'editor-1',
+        rungs: [makeRung({ id: 'rung-1' }), makeRung({ id: 'rung-2' })],
+      }),
+    )
 
-    const newRung = makeRung({ id: 'rung-dup' })
-    store.getState().ladderFlowActions.duplicateRung({ editorName: 'editor-1', rungId: 'rung-1', newRung })
+    store.getState().ladderFlowActions.duplicateRung({ editorName: 'editor-1', rungId: 'rung-1' })
 
     const flow = store.getState().ladderFlows[0]
     expect(flow.rungs).toHaveLength(3)
     expect(flow.rungs[0].id).toBe('rung-1')
-    expect(flow.rungs[1].id).toBe('rung-dup')
+    // The duplicated rung has a generated ID
+    expect(flow.rungs[1].id).toContain('rung_editor-1_')
     expect(flow.rungs[2].id).toBe('rung-2')
     expect(flow.updated).toBe(true)
   })
@@ -271,15 +311,13 @@ describe('createLadderFlowSlice', () => {
   it('duplicateRung does nothing for nonexistent rung', () => {
     seedFlowWithRung(store)
 
-    store
-      .getState()
-      .ladderFlowActions.duplicateRung({ editorName: 'editor-1', rungId: 'missing', newRung: makeRung() })
+    store.getState().ladderFlowActions.duplicateRung({ editorName: 'editor-1', rungId: 'missing' })
 
     expect(store.getState().ladderFlows[0].rungs).toHaveLength(1)
   })
 
   it('duplicateRung does nothing for nonexistent editor', () => {
-    store.getState().ladderFlowActions.duplicateRung({ editorName: 'nonexistent', rungId: 'rung-1', newRung: makeRung() })
+    store.getState().ladderFlowActions.duplicateRung({ editorName: 'nonexistent', rungId: 'rung-1' })
     expect(store.getState().ladderFlows).toEqual([])
   })
 
@@ -369,7 +407,9 @@ describe('createLadderFlowSlice', () => {
     seedFlowWithRung(store, 'editor-1', rung)
 
     const updated = makeNode({ id: 'n1', data: { label: 'new' } })
-    store.getState().ladderFlowActions.updateNode({ editorName: 'editor-1', rungId: 'rung-1', nodeId: 'n1', node: updated })
+    store
+      .getState()
+      .ladderFlowActions.updateNode({ editorName: 'editor-1', rungId: 'rung-1', nodeId: 'n1', node: updated })
 
     const nodes = store.getState().ladderFlows[0].rungs[0].nodes
     expect(nodes.find((n) => n.id === 'n1')?.data.label).toBe('new')
@@ -404,42 +444,78 @@ describe('createLadderFlowSlice', () => {
   // -------------------------------------------------------------------------
   // removeNodes
   // -------------------------------------------------------------------------
-  it('removeNodes removes specified nodes and their connected edges', () => {
+  it('removeNodes removes node and short-circuits wires via removeElements', () => {
+    const n1 = makeNode({
+      id: 'n1',
+      data: {
+        outputConnector: { id: 'n1-out', glbPosition: { x: 150, y: 50 } },
+        inputConnector: { id: 'n1-in', glbPosition: { x: 0, y: 50 } },
+      },
+    })
+    const n2 = makeNode({
+      id: 'n2',
+      data: {
+        outputConnector: { id: 'n2-out', glbPosition: { x: 300, y: 50 } },
+        inputConnector: { id: 'n2-in', glbPosition: { x: 150, y: 50 } },
+      },
+    })
     const rung = makeRung({
       nodes: [
         makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }),
         makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }),
-        makeNode({ id: 'n1' }),
-        makeNode({ id: 'n2' }),
+        n1,
+        n2,
       ],
       edges: [
-        makeEdge({ id: 'e1', source: 'n1', target: 'n2' }),
-        makeEdge({ id: 'e2', source: 'left-rail-rung-1', target: 'n1' }),
+        makeEdge({
+          id: 'e1',
+          source: 'left-rail-rung-1',
+          target: 'n1',
+          sourceHandle: 'rail-out',
+          targetHandle: 'n1-in',
+        }),
+        makeEdge({ id: 'e2', source: 'n1', target: 'n2', sourceHandle: 'n1-out', targetHandle: 'n2-in' }),
+        makeEdge({
+          id: 'e3',
+          source: 'n2',
+          target: 'right-rail-rung-1',
+          sourceHandle: 'n2-out',
+          targetHandle: 'rail-in',
+        }),
       ],
     })
     seedFlowWithRung(store, 'editor-1', rung)
 
-    store
-      .getState()
-      .ladderFlowActions.removeNodes({ editorName: 'editor-1', rungId: 'rung-1', nodes: [makeNode({ id: 'n1' })] })
+    store.getState().ladderFlowActions.removeNodes({ editorName: 'editor-1', rungId: 'rung-1', nodes: [n1] })
 
     const updatedRung = store.getState().ladderFlows[0].rungs[0]
-    expect(updatedRung.nodes.map((n) => n.id)).toEqual(['left-rail-rung-1', 'right-rail-rung-1', 'n2'])
-    expect(updatedRung.edges).toHaveLength(0) // Both edges reference n1
+    const nodeIds = updatedRung.nodes.filter((n) => n.type !== 'variable').map((n) => n.id)
+    expect(nodeIds.sort()).toEqual(['left-rail-rung-1', 'n2', 'right-rail-rung-1'])
+    // Wire is short-circuited: left-rail -> n2 (instead of deleting edges)
+    const mainEdges = updatedRung.edges.filter((e) => !e.source.includes('variable') && !e.target.includes('variable'))
+    expect(mainEdges).toHaveLength(2) // left-rail->n2 and n2->right-rail
+    expect(mainEdges.find((e) => e.source === 'left-rail-rung-1' && e.target === 'n2')).toBeDefined()
+    expect(mainEdges.find((e) => e.source === 'n2' && e.target === 'right-rail-rung-1')).toBeDefined()
     expect(store.getState().ladderFlows[0].updated).toBe(true)
   })
 
-  it('removeNodes also cleans up selectedNodes', () => {
+  it('removeNodes is a no-op when node has no output edge', () => {
     const n1 = makeNode({ id: 'n1' })
     const rung = makeRung({
-      nodes: [makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }), makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }), n1],
+      nodes: [
+        makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }),
+        makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }),
+        n1,
+      ],
       selectedNodes: [n1],
     })
     seedFlowWithRung(store, 'editor-1', rung)
 
     store.getState().ladderFlowActions.removeNodes({ editorName: 'editor-1', rungId: 'rung-1', nodes: [n1] })
 
-    expect(store.getState().ladderFlows[0].rungs[0].selectedNodes).toEqual([])
+    const updatedRung = store.getState().ladderFlows[0].rungs[0]
+    // removeElements returns original rung when no output edge found
+    expect(updatedRung.nodes.map((n) => n.id)).toContain('n1')
   })
 
   // -------------------------------------------------------------------------
@@ -449,7 +525,12 @@ describe('createLadderFlowSlice', () => {
     const n1 = makeNode({ id: 'n1', data: { draggable: true } })
     const n2 = makeNode({ id: 'n2', data: { draggable: false } })
     const rung = makeRung({
-      nodes: [makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }), makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }), n1, n2],
+      nodes: [
+        makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }),
+        makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }),
+        n1,
+        n2,
+      ],
     })
     seedFlowWithRung(store, 'editor-1', rung)
 
@@ -469,13 +550,16 @@ describe('createLadderFlowSlice', () => {
     const n1 = makeNode({ id: 'n1', data: { draggable: true } })
     const n2 = makeNode({ id: 'n2', data: { draggable: true } })
     const rung = makeRung({
-      nodes: [makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }), makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }), n1, n2],
+      nodes: [
+        makeNode({ id: 'left-rail-rung-1', type: 'powerRail' }),
+        makeNode({ id: 'right-rail-rung-1', type: 'powerRail' }),
+        n1,
+        n2,
+      ],
     })
     seedFlowWithRung(store, 'editor-1', rung)
 
-    store
-      .getState()
-      .ladderFlowActions.setSelectedNodes({ editorName: 'editor-1', rungId: 'rung-1', nodes: [n1, n2] })
+    store.getState().ladderFlowActions.setSelectedNodes({ editorName: 'editor-1', rungId: 'rung-1', nodes: [n1, n2] })
 
     const updatedRung = store.getState().ladderFlows[0].rungs[0]
     expect(updatedRung.selectedNodes).toHaveLength(2)
@@ -485,10 +569,12 @@ describe('createLadderFlowSlice', () => {
   })
 
   it('setSelectedNodes clears other rungs selected state when nodes are selected', () => {
-    seedFlowWithRung(store, 'editor-1', makeRung({ id: 'rung-1' }))
-    store
-      .getState()
-      .ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung: makeRung({ id: 'rung-2' }) })
+    store.getState().ladderFlowActions.addLadderFlow(
+      makeFlow({
+        name: 'editor-1',
+        rungs: [makeRung({ id: 'rung-1' }), makeRung({ id: 'rung-2' })],
+      }),
+    )
 
     const node = makeNode({ id: 'n1', data: { draggable: true } })
     store.getState().ladderFlowActions.setNodes({
@@ -549,7 +635,9 @@ describe('createLadderFlowSlice', () => {
   it('addEdge pushes a new edge to a rung', () => {
     seedFlowWithRung(store)
 
-    store.getState().ladderFlowActions.addEdge({ editorName: 'editor-1', rungId: 'rung-1', edge: makeEdge({ id: 'e1' }) })
+    store
+      .getState()
+      .ladderFlowActions.addEdge({ editorName: 'editor-1', rungId: 'rung-1', edge: makeEdge({ id: 'e1' }) })
 
     expect(store.getState().ladderFlows[0].rungs[0].edges).toHaveLength(1)
     expect(store.getState().ladderFlows[0].updated).toBe(true)
@@ -561,9 +649,11 @@ describe('createLadderFlowSlice', () => {
   it('updateReactFlowViewport updates the viewport', () => {
     seedFlowWithRung(store)
 
-    store
-      .getState()
-      .ladderFlowActions.updateReactFlowViewport({ editorName: 'editor-1', rungId: 'rung-1', reactFlowViewport: [1200, 400] })
+    store.getState().ladderFlowActions.updateReactFlowViewport({
+      editorName: 'editor-1',
+      rungId: 'rung-1',
+      reactFlowViewport: [1200, 400],
+    })
 
     expect(store.getState().ladderFlows[0].rungs[0].reactFlowViewport).toEqual([1200, 400])
   })
@@ -571,9 +661,11 @@ describe('createLadderFlowSlice', () => {
   it('updateReactFlowViewport does nothing for nonexistent rung', () => {
     seedFlowWithRung(store)
 
-    store
-      .getState()
-      .ladderFlowActions.updateReactFlowViewport({ editorName: 'editor-1', rungId: 'missing', reactFlowViewport: [1200, 400] })
+    store.getState().ladderFlowActions.updateReactFlowViewport({
+      editorName: 'editor-1',
+      rungId: 'missing',
+      reactFlowViewport: [1200, 400],
+    })
 
     expect(store.getState().ladderFlows[0].rungs[0].reactFlowViewport).toEqual([800, 200])
   })
@@ -696,13 +788,17 @@ describe('createLadderFlowSlice', () => {
   })
 
   it('updateNode does nothing for nonexistent editor', () => {
-    store.getState().ladderFlowActions.updateNode({ editorName: 'nonexistent', rungId: 'r', nodeId: 'n', node: makeNode() })
+    store
+      .getState()
+      .ladderFlowActions.updateNode({ editorName: 'nonexistent', rungId: 'r', nodeId: 'n', node: makeNode() })
     expect(store.getState().ladderFlows).toEqual([])
   })
 
   it('updateNode does nothing for nonexistent rung', () => {
     seedFlowWithRung(store)
-    store.getState().ladderFlowActions.updateNode({ editorName: 'editor-1', rungId: 'missing', nodeId: 'n', node: makeNode() })
+    store
+      .getState()
+      .ladderFlowActions.updateNode({ editorName: 'editor-1', rungId: 'missing', nodeId: 'n', node: makeNode() })
     expect(store.getState().ladderFlows[0].rungs[0].nodes).toHaveLength(2)
   })
 
@@ -740,8 +836,12 @@ describe('createLadderFlowSlice', () => {
   })
 
   it('setSelectedNodes with empty array does not clear other rungs', () => {
-    seedFlowWithRung(store, 'editor-1', makeRung({ id: 'rung-1' }))
-    store.getState().ladderFlowActions.startLadderRung({ editorName: 'editor-1', rung: makeRung({ id: 'rung-2' }) })
+    store.getState().ladderFlowActions.addLadderFlow(
+      makeFlow({
+        name: 'editor-1',
+        rungs: [makeRung({ id: 'rung-1' }), makeRung({ id: 'rung-2' })],
+      }),
+    )
 
     store.getState().ladderFlowActions.setSelectedNodes({ editorName: 'editor-1', rungId: 'rung-1', nodes: [] })
 
@@ -761,13 +861,17 @@ describe('createLadderFlowSlice', () => {
   })
 
   it('updateEdge does nothing for nonexistent editor', () => {
-    store.getState().ladderFlowActions.updateEdge({ editorName: 'nonexistent', rungId: 'r', edgeId: 'e', edge: makeEdge() })
+    store
+      .getState()
+      .ladderFlowActions.updateEdge({ editorName: 'nonexistent', rungId: 'r', edgeId: 'e', edge: makeEdge() })
     expect(store.getState().ladderFlows).toEqual([])
   })
 
   it('updateEdge does nothing for nonexistent rung', () => {
     seedFlowWithRung(store)
-    store.getState().ladderFlowActions.updateEdge({ editorName: 'editor-1', rungId: 'missing', edgeId: 'e', edge: makeEdge() })
+    store
+      .getState()
+      .ladderFlowActions.updateEdge({ editorName: 'editor-1', rungId: 'missing', edgeId: 'e', edge: makeEdge() })
     expect(store.getState().ladderFlows[0].rungs[0].edges).toEqual([])
   })
 
@@ -783,7 +887,11 @@ describe('createLadderFlowSlice', () => {
   })
 
   it('updateReactFlowViewport does nothing for nonexistent editor', () => {
-    store.getState().ladderFlowActions.updateReactFlowViewport({ editorName: 'nonexistent', rungId: 'r', reactFlowViewport: [100, 100] })
+    store.getState().ladderFlowActions.updateReactFlowViewport({
+      editorName: 'nonexistent',
+      rungId: 'r',
+      reactFlowViewport: [100, 100],
+    })
     expect(store.getState().ladderFlows).toEqual([])
   })
 
diff --git a/src2/frontend/store/__tests__/ladder-types.test.ts b/src/frontend/store/__tests__/ladder-types.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/ladder-types.test.ts
rename to src/frontend/store/__tests__/ladder-types.test.ts
diff --git a/src2/frontend/store/__tests__/library-slice.test.ts b/src/frontend/store/__tests__/library-slice.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/library-slice.test.ts
rename to src/frontend/store/__tests__/library-slice.test.ts
index 62cfa3f38..4d36567c7 100644
--- a/src2/frontend/store/__tests__/library-slice.test.ts
+++ b/src/frontend/store/__tests__/library-slice.test.ts
@@ -1,7 +1,7 @@
 import { createStore } from 'zustand/vanilla'
 
 import { createLibrarySlice } from '../slices/library/slice'
-import type { LibrarySlice, SystemLibrary, UserLibrary } from '../slices/library/types'
+import type { LibrarySlice, SystemLibrary } from '../slices/library/types'
 
 function makeStore() {
   return createStore<LibrarySlice>()(createLibrarySlice)
diff --git a/src2/frontend/store/__tests__/modal-slice.test.ts b/src/frontend/store/__tests__/modal-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/modal-slice.test.ts
rename to src/frontend/store/__tests__/modal-slice.test.ts
diff --git a/src2/frontend/store/__tests__/project-slice.test.ts b/src/frontend/store/__tests__/project-slice.test.ts
similarity index 97%
rename from src2/frontend/store/__tests__/project-slice.test.ts
rename to src/frontend/store/__tests__/project-slice.test.ts
index 77eebec3c..a1164a2c3 100644
--- a/src2/frontend/store/__tests__/project-slice.test.ts
+++ b/src/frontend/store/__tests__/project-slice.test.ts
@@ -55,8 +55,8 @@ function makeTask(name: string): PLCTask {
   return { name, triggering: 'Cyclic', interval: 'T#20ms', priority: 0 }
 }
 
-function makeInstance(name: string, taskName = 'Task0', pouName = 'Main'): PLCInstance {
-  return { name, taskName, pouName }
+function makeInstance(name: string, task = 'Task0', program = 'Main'): PLCInstance {
+  return { name, task, program }
 }
 
 function makeModbusTcpServer(name: string): PLCServer {
@@ -907,7 +907,9 @@ describe('createProjectSlice', () => {
       const updated: PLCDataType = {
         name: 'MyStruct',
         derivation: 'structure',
-        variable: [{ name: 'field1', type: { definition: 'base-type', value: 'BOOL' }, location: '', documentation: '' }],
+        variable: [
+          { name: 'field1', type: { definition: 'base-type', value: 'BOOL' }, location: '', documentation: '' },
+        ],
       }
       store.getState().projectActions.updateDatatype('MyStruct', updated)
       const storedDt = store.getState().project.data.dataTypes[0]
@@ -1500,7 +1502,10 @@ describe('createProjectSlice', () => {
         sizeBytes: 16,
       })
       expect(result.ok).toBe(true)
-      const slaveConfig = store.getState().project.data.servers![0].s7commSlaveConfig as unknown as Record<string, unknown>
+      const slaveConfig = store.getState().project.data.servers![0].s7commSlaveConfig as unknown as Record<
+        string,
+        unknown
+      >
       const peArea = slaveConfig.peArea as { enabled: boolean; sizeBytes: number }
       expect(peArea.enabled).toBe(true)
       expect(peArea.sizeBytes).toBe(16)
@@ -1510,7 +1515,10 @@ describe('createProjectSlice', () => {
       seedServer(store, makeS7CommServer('S7'))
       store.getState().projectActions.updateS7CommSystemArea('S7', 'mkArea', { enabled: true, sizeBytes: 8 })
       store.getState().projectActions.updateS7CommSystemArea('S7', 'mkArea', { sizeBytes: 32 })
-      const slaveConfig = store.getState().project.data.servers![0].s7commSlaveConfig as unknown as Record<string, unknown>
+      const slaveConfig = store.getState().project.data.servers![0].s7commSlaveConfig as unknown as Record<
+        string,
+        unknown
+      >
       const mkArea = slaveConfig.mkArea as { enabled: boolean; sizeBytes: number }
       expect(mkArea.enabled).toBe(true)
       expect(mkArea.sizeBytes).toBe(32)
@@ -1518,7 +1526,9 @@ describe('createProjectSlice', () => {
 
     it('does nothing when server has no s7commSlaveConfig', () => {
       seedServer(store, makeModbusTcpServer('Modbus'))
-      const result = store.getState().projectActions.updateS7CommSystemArea('Modbus', 'peArea', { enabled: true, sizeBytes: 1 })
+      const result = store
+        .getState()
+        .projectActions.updateS7CommSystemArea('Modbus', 'peArea', { enabled: true, sizeBytes: 1 })
       expect(result.ok).toBe(true)
     })
   })
@@ -1669,12 +1679,9 @@ describe('createProjectSlice', () => {
   describe('updateOpcUaServerCertificateStrategy', () => {
     it('updates to custom strategy with certificate and key', () => {
       seedServer(store, makeOpcUaServer('OPC'))
-      const result = store.getState().projectActions.updateOpcUaServerCertificateStrategy(
-        'OPC',
-        'custom',
-        'CERT-PEM',
-        'KEY-PEM',
-      )
+      const result = store
+        .getState()
+        .projectActions.updateOpcUaServerCertificateStrategy('OPC', 'custom', 'CERT-PEM', 'KEY-PEM')
       expect(result.ok).toBe(true)
       const security = store.getState().project.data.servers![0].opcuaServerConfig!.security
       expect(security.serverCertificateStrategy).toBe('custom')
@@ -1738,14 +1745,11 @@ describe('createProjectSlice', () => {
   describe('updateOpcUaAddressSpaceNamespace', () => {
     it('updates namespace URI', () => {
       seedServer(store, makeOpcUaServer('OPC'))
-      const result = store.getState().projectActions.updateOpcUaAddressSpaceNamespace(
-        'OPC',
+      const result = store.getState().projectActions.updateOpcUaAddressSpaceNamespace('OPC', 'urn:custom:namespace')
+      expect(result.ok).toBe(true)
+      expect(store.getState().project.data.servers![0].opcuaServerConfig!.addressSpace.namespaceUri).toBe(
         'urn:custom:namespace',
       )
-      expect(result.ok).toBe(true)
-      expect(
-        store.getState().project.data.servers![0].opcuaServerConfig!.addressSpace.namespaceUri,
-      ).toBe('urn:custom:namespace')
     })
 
     it('does nothing when server has no opcuaServerConfig', () => {
@@ -1930,15 +1934,15 @@ describe('createProjectSlice', () => {
       const ioGroups = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups
       expect(ioGroups).toHaveLength(1)
       expect(ioGroups[0].ioPoints).toHaveLength(3)
-      expect(ioGroups[0].ioPoints[0].iecLocation).toBe('%IW0')
-      expect(ioGroups[0].ioPoints[1].iecLocation).toBe('%IW1')
+      expect(ioGroups[0].ioPoints![0].iecLocation).toBe('%IW0')
+      expect(ioGroups[0].ioPoints![1].iecLocation).toBe('%IW1')
     })
 
     it('generates bit addresses for function code 1 (coils)', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '1', 2)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%IX0.0')
       expect(points[1].iecLocation).toBe('%IX0.1')
     })
@@ -1947,7 +1951,7 @@ describe('createProjectSlice', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '5', 2)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%QX0.0')
     })
 
@@ -1955,7 +1959,7 @@ describe('createProjectSlice', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '6', 1)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%QW0')
     })
 
@@ -1963,7 +1967,7 @@ describe('createProjectSlice', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '2', 1)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%IX0.0')
     })
 
@@ -1971,7 +1975,7 @@ describe('createProjectSlice', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '4', 1)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%IW0')
     })
 
@@ -1979,7 +1983,7 @@ describe('createProjectSlice', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '15', 2)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%QX0.0')
       expect(points[1].iecLocation).toBe('%QX0.1')
     })
@@ -1988,7 +1992,7 @@ describe('createProjectSlice', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       const group = makeIOGroup('g1', '16', 2)
       store.getState().projectActions.addIOGroup('Dev1', group)
-      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints
+      const points = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints!
       expect(points[0].iecLocation).toBe('%QW0')
       expect(points[1].iecLocation).toBe('%QW1')
     })
@@ -1998,7 +2002,7 @@ describe('createProjectSlice', () => {
       store.getState().projectActions.addIOGroup('Dev1', makeIOGroup('g1', '3', 2))
       store.getState().projectActions.addIOGroup('Dev1', makeIOGroup('g2', '3', 2))
       const groups = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups
-      const allLocations = groups.flatMap((g) => g.ioPoints.map((p) => p.iecLocation))
+      const allLocations = groups.flatMap((g) => g.ioPoints!.map((p) => p.iecLocation))
       const uniqueLocations = new Set(allLocations)
       expect(uniqueLocations.size).toBe(allLocations.length)
     })
@@ -2010,12 +2014,12 @@ describe('createProjectSlice', () => {
       // Second group should skip those addresses
       store.getState().projectActions.addIOGroup('Dev1', makeIOGroup('g2', '1', 2))
       const groups = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups
-      const allLocations = groups.flatMap((g) => g.ioPoints.map((p) => p.iecLocation))
+      const allLocations = groups.flatMap((g) => g.ioPoints!.map((p) => p.iecLocation))
       const uniqueLocations = new Set(allLocations)
       expect(uniqueLocations.size).toBe(allLocations.length)
       // Second group should have addresses after the first
-      expect(groups[1].ioPoints[0].iecLocation).toBe('%IX0.2')
-      expect(groups[1].ioPoints[1].iecLocation).toBe('%IX0.3')
+      expect(groups[1].ioPoints![0].iecLocation).toBe('%IX0.2')
+      expect(groups[1].ioPoints![1].iecLocation).toBe('%IX0.3')
     })
 
     it('does nothing when device has no modbusTcpConfig', () => {
@@ -2032,8 +2036,8 @@ describe('createProjectSlice', () => {
       const groups = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups
       expect(groups).toHaveLength(1)
       // Default returns: type 'Unknown', iecPrefix '%MW', isBit false
-      expect(groups[0].ioPoints[0].type).toBe('Unknown')
-      expect(groups[0].ioPoints[0].iecLocation).toBe('%MW0')
+      expect(groups[0].ioPoints![0].type).toBe('Unknown')
+      expect(groups[0].ioPoints![0].iecLocation).toBe('%MW0')
     })
 
     it('skips word addresses that are already used (word-based collision)', () => {
@@ -2060,8 +2064,8 @@ describe('createProjectSlice', () => {
       // The generator should skip %IW0 and %IW1 and start at %IW2
       store.getState().projectActions.addIOGroup('Dev1', makeIOGroup('g2', '3', 2))
       const groups = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups
-      expect(groups[1].ioPoints[0].iecLocation).toBe('%IW2')
-      expect(groups[1].ioPoints[1].iecLocation).toBe('%IW3')
+      expect(groups[1].ioPoints![0].iecLocation).toBe('%IW2')
+      expect(groups[1].ioPoints![1].iecLocation).toBe('%IW3')
     })
 
     it('skips bit addresses that are already used (bit-based collision with gaps)', () => {
@@ -2088,8 +2092,8 @@ describe('createProjectSlice', () => {
       // Add a new group; the generator should skip %IX0.0 (used), use %IX0.1 (free), skip %IX0.2 (used), use %IX0.3
       store.getState().projectActions.addIOGroup('Dev1', makeIOGroup('g2', '1', 2))
       const groups = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups
-      expect(groups[1].ioPoints[0].iecLocation).toBe('%IX0.1')
-      expect(groups[1].ioPoints[1].iecLocation).toBe('%IX0.3')
+      expect(groups[1].ioPoints![0].iecLocation).toBe('%IX0.1')
+      expect(groups[1].ioPoints![1].iecLocation).toBe('%IX0.3')
     })
   })
 
@@ -2138,12 +2142,12 @@ describe('createProjectSlice', () => {
     it('updates a point alias', () => {
       seedRemoteDevice(store, makeRemoteDevice('Dev1'))
       store.getState().projectActions.addIOGroup('Dev1', makeIOGroup('g1', '3', 2))
-      const pointId = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints[0].id
+      const pointId = store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints![0].id
       const result = store.getState().projectActions.updateIOPointAlias('Dev1', 'g1', pointId, 'Temperature')
       expect(result.ok).toBe(true)
-      expect(
-        store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints[0].alias,
-      ).toBe('Temperature')
+      expect(store.getState().project.data.remoteDevices![0].modbusTcpConfig!.ioGroups[0].ioPoints![0].alias).toBe(
+        'Temperature',
+      )
     })
 
     it('does nothing when group not found', () => {
@@ -2339,7 +2343,9 @@ describe('createProjectSlice', () => {
 
     it('updateOpcUaServerCertificateStrategy on a server without opcuaServerConfig', () => {
       seedServer(store, { name: 'Modbus', protocol: 'modbus-tcp' })
-      const result = store.getState().projectActions.updateOpcUaServerCertificateStrategy('Modbus', 'custom', 'cert', 'key')
+      const result = store
+        .getState()
+        .projectActions.updateOpcUaServerCertificateStrategy('Modbus', 'custom', 'cert', 'key')
       expect(result.ok).toBe(true)
     })
 
diff --git a/src2/frontend/store/__tests__/project-utils.test.ts b/src/frontend/store/__tests__/project-utils.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/project-utils.test.ts
rename to src/frontend/store/__tests__/project-utils.test.ts
index 1bd4730a6..cecbe22b3 100644
--- a/src2/frontend/store/__tests__/project-utils.test.ts
+++ b/src/frontend/store/__tests__/project-utils.test.ts
@@ -1,5 +1,4 @@
 import type { PLCVariable } from '../../../middleware/shared/ports/types'
-
 import { getVariableBasedOnRowIdOrVariableId } from '../slices/project/utils'
 
 function makeVariable(name: string): PLCVariable {
diff --git a/src2/frontend/store/__tests__/react-flow-types.test.ts b/src/frontend/store/__tests__/react-flow-types.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/react-flow-types.test.ts
rename to src/frontend/store/__tests__/react-flow-types.test.ts
diff --git a/src2/frontend/store/__tests__/search-slice.test.ts b/src/frontend/store/__tests__/search-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/search-slice.test.ts
rename to src/frontend/store/__tests__/search-slice.test.ts
diff --git a/src2/frontend/store/__tests__/search-utils.test.ts b/src/frontend/store/__tests__/search-utils.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/search-utils.test.ts
rename to src/frontend/store/__tests__/search-utils.test.ts
diff --git a/src2/frontend/store/__tests__/shared-slice.test.ts b/src/frontend/store/__tests__/shared-slice.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/shared-slice.test.ts
rename to src/frontend/store/__tests__/shared-slice.test.ts
index e60fe9e13..f9ab98b67 100644
--- a/src2/frontend/store/__tests__/shared-slice.test.ts
+++ b/src/frontend/store/__tests__/shared-slice.test.ts
@@ -1,6 +1,5 @@
 import { createStore } from 'zustand/vanilla'
 
-import type { PLCPou } from '../../../middleware/shared/ports/types'
 import { createConsoleSlice } from '../slices/console/slice'
 import { createDeviceSlice } from '../slices/device/slice'
 import { createEditorSlice } from '../slices/editor/slice'
@@ -324,7 +323,7 @@ describe('createSharedSlice', () => {
             return { ...p, interface: { variables: p.interface?.variables ?? [], returnType: undefined } }
           }
           return p
-        }) as PLCPou[]
+        })
         store.getState().projectActions.setPous(pous)
 
         const result = store.getState().pouActions.duplicate('FnNoRet', 'FnNoRetCopy')
@@ -342,7 +341,13 @@ describe('createSharedSlice', () => {
         // Create a POU directly at the project level that will collide
         store.getState().projectActions.createPou({
           type: 'program',
-          data: { language: 'st', name: 'CollideName', variables: [], body: { language: 'st', value: '' }, documentation: '' },
+          data: {
+            language: 'st',
+            name: 'CollideName',
+            variables: [],
+            body: { language: 'st', value: '' },
+            documentation: '',
+          },
         })
 
         // Try to duplicate Source to CollideName -- the shared duplicate checks for
@@ -834,7 +839,9 @@ describe('createSharedSlice', () => {
         store.getState().projectActions.setPous(pous)
 
         store.getState().snapshotActions.pushToHistory('Main', {
-          variables: [{ name: 'x', type: { definition: 'base-type' as const, value: 'INT' }, location: '', documentation: '' }],
+          variables: [
+            { name: 'x', type: { definition: 'base-type' as const, value: 'INT' }, location: '', documentation: '' },
+          ],
           body: 'restored-body',
         })
 
@@ -848,7 +855,9 @@ describe('createSharedSlice', () => {
 
       it('restores the last snapshot and moves current state to future', () => {
         const snapshotWithVars = {
-          variables: [{ name: 'x', type: { definition: 'base-type' as const, value: 'INT' }, location: '', documentation: '' }],
+          variables: [
+            { name: 'x', type: { definition: 'base-type' as const, value: 'INT' }, location: '', documentation: '' },
+          ],
           body: 'old-body',
           globalVariables: [],
         }
diff --git a/src2/frontend/store/__tests__/shared-utils.test.ts b/src/frontend/store/__tests__/shared-utils.test.ts
similarity index 99%
rename from src2/frontend/store/__tests__/shared-utils.test.ts
rename to src/frontend/store/__tests__/shared-utils.test.ts
index 17f50112c..505c30bc7 100644
--- a/src2/frontend/store/__tests__/shared-utils.test.ts
+++ b/src/frontend/store/__tests__/shared-utils.test.ts
@@ -109,7 +109,7 @@ describe('shared/utils', () => {
       expect(result.name).toBe('IntArray')
       expect(result.derivation).toBe('array')
       if (result.derivation === 'array') {
-        expect(result.baseType).toEqual({ definition: 'base-type', value: 'bool' })
+        expect(result.baseType).toEqual({ definition: 'base-type', value: 'BOOL' })
         expect(result.initialValue).toBe('false')
         expect(result.dimensions).toEqual([])
       }
diff --git a/src2/frontend/store/__tests__/tabs-slice.test.ts b/src/frontend/store/__tests__/tabs-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/tabs-slice.test.ts
rename to src/frontend/store/__tests__/tabs-slice.test.ts
diff --git a/src2/frontend/store/__tests__/tabs-utils.test.ts b/src/frontend/store/__tests__/tabs-utils.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/tabs-utils.test.ts
rename to src/frontend/store/__tests__/tabs-utils.test.ts
index aae63c0aa..ab967e423 100644
--- a/src2/frontend/store/__tests__/tabs-utils.test.ts
+++ b/src/frontend/store/__tests__/tabs-utils.test.ts
@@ -1,3 +1,4 @@
+import type { TabsProps } from '../slices/tabs/types'
 import {
   CreateDeviceEditor,
   CreateEditorModelObject,
@@ -8,7 +9,6 @@ import {
   CreateResourceEditor,
   CreateServerEditor,
 } from '../slices/tabs/utils'
-import type { TabsProps } from '../slices/tabs/types'
 
 describe('tabs/utils', () => {
   // -------------------------------------------------------------------------
diff --git a/src2/frontend/store/__tests__/webrtc-slice.test.ts b/src/frontend/store/__tests__/webrtc-slice.test.ts
similarity index 100%
rename from src2/frontend/store/__tests__/webrtc-slice.test.ts
rename to src/frontend/store/__tests__/webrtc-slice.test.ts
diff --git a/src2/frontend/store/__tests__/workspace-slice.test.ts b/src/frontend/store/__tests__/workspace-slice.test.ts
similarity index 97%
rename from src2/frontend/store/__tests__/workspace-slice.test.ts
rename to src/frontend/store/__tests__/workspace-slice.test.ts
index e30c4308f..d27a29eda 100644
--- a/src2/frontend/store/__tests__/workspace-slice.test.ts
+++ b/src/frontend/store/__tests__/workspace-slice.test.ts
@@ -205,9 +205,7 @@ describe('createWorkspaceSlice', () => {
         message: `msg${i}`,
       }))
       store.getState().workspaceActions.setPlcLogs(initial)
-      const extra: RuntimeLogEntry[] = [
-        { id: LOG_BUFFER_CAP, timestamp: 'tx', level: 'ERROR', message: 'extra' },
-      ]
+      const extra: RuntimeLogEntry[] = [{ id: LOG_BUFFER_CAP, timestamp: 'tx', level: 'ERROR', message: 'extra' }]
       store.getState().workspaceActions.appendPlcLogs(extra)
       const logs = store.getState().workspace.plcLogs as RuntimeLogEntry[]
       expect(logs.length).toBe(LOG_BUFFER_CAP)
@@ -303,7 +301,10 @@ describe('createWorkspaceSlice', () => {
   })
 
   it('setDebugVariableIndexes', () => {
-    const indexes = new Map([['var1', 0], ['var2', 1]])
+    const indexes = new Map([
+      ['var1', 0],
+      ['var2', 1],
+    ])
     store.getState().workspaceActions.setDebugVariableIndexes(indexes)
     expect(store.getState().workspace.debugVariableIndexes).toEqual(indexes)
   })
@@ -344,7 +345,10 @@ describe('createWorkspaceSlice', () => {
   })
 
   it('setDebugExpandedNodes', () => {
-    const expandedNodes = new Map([['node1', true], ['node2', false]])
+    const expandedNodes = new Map([
+      ['node1', true],
+      ['node2', false],
+    ])
     store.getState().workspaceActions.setDebugExpandedNodes(expandedNodes)
     expect(store.getState().workspace.debugExpandedNodes).toEqual(expandedNodes)
   })
@@ -417,14 +421,11 @@ describe('createWorkspaceSlice', () => {
     store.getState().workspaceActions.setDebugVariableValues(new Map([['x', 'true']]))
     store.getState().workspaceActions.setDebugForcedVariables(new Map([['x', true]]))
     store.getState().workspaceActions.setDebugTick(100)
-    store.getState().workspaceActions.setDebugVariableTree(
-      new Map([
-        [
-          'x',
-          { name: 'x', fullPath: 'x', compositeKey: 'x', type: 'BOOL', isComplex: false },
-        ],
-      ]),
-    )
+    store
+      .getState()
+      .workspaceActions.setDebugVariableTree(
+        new Map([['x', { name: 'x', fullPath: 'x', compositeKey: 'x', type: 'BOOL', isComplex: false }]]),
+      )
     store.getState().workspaceActions.setDebugExpandedNodes(new Map([['n', true]]))
     store.getState().workspaceActions.setFbDebugInstances(
       new Map([
@@ -503,9 +504,11 @@ describe('createWorkspaceSlice', () => {
     store.getState().workspaceActions.setDebugVariableIndexes(new Map([[key, 5]]))
     store.getState().workspaceActions.setDebugVariableValues(new Map([[key, '42']]))
     store.getState().workspaceActions.setDebugForcedVariables(new Map([[key, true]]))
-    store.getState().workspaceActions.setDebugVariableTree(
-      new Map([[key, { name: 'myVar', fullPath: key, compositeKey: key, type: 'INT', isComplex: false }]]),
-    )
+    store
+      .getState()
+      .workspaceActions.setDebugVariableTree(
+        new Map([[key, { name: 'myVar', fullPath: key, compositeKey: key, type: 'INT', isComplex: false }]]),
+      )
     store.getState().workspaceActions.setDebugExpandedNodes(new Map([[key, true]]))
 
     store.getState().workspaceActions.removeDebugVariable(key)
diff --git a/src2/frontend/store/index.ts b/src/frontend/store/index.ts
similarity index 97%
rename from src2/frontend/store/index.ts
rename to src/frontend/store/index.ts
index fcdf7b954..2a65807c4 100644
--- a/src2/frontend/store/index.ts
+++ b/src/frontend/store/index.ts
@@ -6,39 +6,38 @@ import { subscribeWithSelector } from 'zustand/middleware'
 // Enable Immer's MapSet plugin for Map/Set support in store state
 enableMapSet()
 
-import type { AIFeatureConfig } from '../../backend/shared/ai'
-
+import type { AIFeatureConfig } from '../../middleware/shared/ports/types'
 import type { AISlice } from './slices/ai'
-import type { ConsoleSlice } from './slices/console'
-import type { DeviceSlice } from './slices/device'
-import type { EditorSlice } from './slices/editor'
-import type { FBDFlowSlice } from './slices/fbd'
-import type { FileSlice } from './slices/file'
-import type { HistorySlice } from './slices/history'
-import type { LadderFlowSlice } from './slices/ladder'
-import type { LibrarySlice } from './slices/library'
-import type { ModalSlice } from './slices/modal'
-import type { ProjectSlice } from './slices/project'
-import type { SearchSlice } from './slices/search'
-import type { SharedSlice } from './slices/shared'
-import type { TabsSlice } from './slices/tabs'
-import type { WebRTCSlice } from './slices/webrtc'
-import type { WorkspaceSlice } from './slices/workspace'
 import { createAISliceFactory } from './slices/ai'
+import type { ConsoleSlice } from './slices/console'
 import { createConsoleSlice } from './slices/console'
+import type { DeviceSlice } from './slices/device'
 import { createDeviceSlice } from './slices/device'
+import type { EditorSlice } from './slices/editor'
 import { createEditorSlice } from './slices/editor'
+import type { FBDFlowSlice } from './slices/fbd'
 import { createFBDFlowSlice } from './slices/fbd'
+import type { FileSlice } from './slices/file'
 import { createFileSlice } from './slices/file'
+import type { HistorySlice } from './slices/history'
 import { createHistorySlice } from './slices/history'
+import type { LadderFlowSlice } from './slices/ladder'
 import { createLadderFlowSlice } from './slices/ladder'
+import type { LibrarySlice } from './slices/library'
 import { createLibrarySlice } from './slices/library'
+import type { ModalSlice } from './slices/modal'
 import { createModalSlice } from './slices/modal'
+import type { ProjectSlice } from './slices/project'
 import { createProjectSlice } from './slices/project'
+import type { SearchSlice } from './slices/search'
 import { createSearchSlice } from './slices/search'
+import type { SharedSlice } from './slices/shared'
 import { createSharedSlice } from './slices/shared'
+import type { TabsSlice } from './slices/tabs'
 import { createTabsSlice } from './slices/tabs'
+import type { WebRTCSlice } from './slices/webrtc'
 import { createWebRTCSlice } from './slices/webrtc'
+import type { WorkspaceSlice } from './slices/workspace'
 import { createWorkspaceSlice } from './slices/workspace'
 
 export type RootState = AISlice &
diff --git a/src/frontend/store/slices/ai/index.ts b/src/frontend/store/slices/ai/index.ts
new file mode 100644
index 000000000..0059bdef7
--- /dev/null
+++ b/src/frontend/store/slices/ai/index.ts
@@ -0,0 +1,3 @@
+export { createAISlice, createAISliceFactory } from './slice'
+export type { AIActions, AIModel, AISlice, AIState, ChatConversation, ChatMessage, ChatMessageRole } from './types'
+export { MAX_CONVERSATION_MESSAGES } from './types'
diff --git a/src2/frontend/store/slices/ai/slice.ts b/src/frontend/store/slices/ai/slice.ts
similarity index 95%
rename from src2/frontend/store/slices/ai/slice.ts
rename to src/frontend/store/slices/ai/slice.ts
index 56108858d..3a9f79331 100644
--- a/src2/frontend/store/slices/ai/slice.ts
+++ b/src/frontend/store/slices/ai/slice.ts
@@ -1,9 +1,7 @@
 import { produce } from 'immer'
 import { StateCreator } from 'zustand'
 
-import { resolveAIInitialState } from '../../../../backend/shared/ai'
-import type { AIFeatureConfig } from '../../../../backend/shared/ai'
-
+import type { AIFeatureConfig } from '../../../../middleware/shared/ports/types'
 import type { AISlice } from './types'
 import { MAX_CONVERSATION_MESSAGES } from './types'
 
@@ -23,7 +21,7 @@ const DEFAULT_AI_STATE: AISlice['ai'] = {
 }
 
 export function createAISliceFactory(config?: AIFeatureConfig): StateCreator<AISlice, [], [], AISlice> {
-  const overrides = config ? resolveAIInitialState(config) : {}
+  const overrides = config ? { isEnabled: config.isFeatureEnabled, hasConsented: config.hasUserConsented } : {}
   return (setState) => ({
     ai: { ...DEFAULT_AI_STATE, ...overrides },
 
diff --git a/src2/frontend/store/slices/ai/types.ts b/src/frontend/store/slices/ai/types.ts
similarity index 92%
rename from src2/frontend/store/slices/ai/types.ts
rename to src/frontend/store/slices/ai/types.ts
index 2af2f425c..cb07edc71 100644
--- a/src2/frontend/store/slices/ai/types.ts
+++ b/src/frontend/store/slices/ai/types.ts
@@ -1,18 +1,13 @@
+import type { ChatMessage, ChatMessageRole } from '../../../../middleware/shared/ports/types'
+
+export type { ChatMessage, ChatMessageRole }
+
 // ---------------------------------------------------------------------------
 // AI model and message types
 // ---------------------------------------------------------------------------
 
 export type AIModel = 'haiku' | 'sonnet'
 export type AIAction = 'complete' | 'chat'
-export type ChatMessageRole = 'user' | 'assistant'
-
-export type ChatMessage = {
-  id: string
-  role: ChatMessageRole
-  content: string
-  timestamp: number
-  rating?: 'up' | 'down'
-}
 
 export type ChatConversation = {
   pouName: string
diff --git a/src2/frontend/store/slices/clipboard.ts b/src/frontend/store/slices/clipboard.ts
similarity index 99%
rename from src2/frontend/store/slices/clipboard.ts
rename to src/frontend/store/slices/clipboard.ts
index 99de05daa..5efe5221e 100644
--- a/src2/frontend/store/slices/clipboard.ts
+++ b/src/frontend/store/slices/clipboard.ts
@@ -1,6 +1,7 @@
-import { edgeSchema, nodeSchema } from './react-flow'
 import z from 'zod'
 
+import { edgeSchema, nodeSchema } from './react-flow'
+
 export const clipboardSchema = z.discriminatedUnion('language', [
   z.object({
     language: z.literal('fbd'),
diff --git a/src2/frontend/store/slices/console/index.ts b/src/frontend/store/slices/console/index.ts
similarity index 100%
rename from src2/frontend/store/slices/console/index.ts
rename to src/frontend/store/slices/console/index.ts
diff --git a/src2/frontend/store/slices/console/slice.ts b/src/frontend/store/slices/console/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/console/slice.ts
rename to src/frontend/store/slices/console/slice.ts
diff --git a/src2/frontend/store/slices/console/types.ts b/src/frontend/store/slices/console/types.ts
similarity index 100%
rename from src2/frontend/store/slices/console/types.ts
rename to src/frontend/store/slices/console/types.ts
diff --git a/src2/frontend/store/slices/device/data/constants.ts b/src/frontend/store/slices/device/data/constants.ts
similarity index 100%
rename from src2/frontend/store/slices/device/data/constants.ts
rename to src/frontend/store/slices/device/data/constants.ts
diff --git a/src2/frontend/store/slices/device/index.ts b/src/frontend/store/slices/device/index.ts
similarity index 100%
rename from src2/frontend/store/slices/device/index.ts
rename to src/frontend/store/slices/device/index.ts
diff --git a/src2/frontend/store/slices/device/slice.ts b/src/frontend/store/slices/device/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/device/slice.ts
rename to src/frontend/store/slices/device/slice.ts
index 3b13725a9..0f7ce6d7e 100644
--- a/src2/frontend/store/slices/device/slice.ts
+++ b/src/frontend/store/slices/device/slice.ts
@@ -1,7 +1,7 @@
-import type { DeviceConfiguration, DevicePin } from '../../../../middleware/shared/ports/types'
 import { produce } from 'immer'
 import { StateCreator } from 'zustand'
 
+import type { DeviceConfiguration, DevicePin } from '../../../../middleware/shared/ports/types'
 import { defaultDeviceConfiguration } from './data/constants'
 import type { DeviceSlice, PinUpdateResponse } from './types'
 import {
diff --git a/src2/frontend/store/slices/device/types.ts b/src/frontend/store/slices/device/types.ts
similarity index 94%
rename from src2/frontend/store/slices/device/types.ts
rename to src/frontend/store/slices/device/types.ts
index a43bef3cd..f45594245 100644
--- a/src2/frontend/store/slices/device/types.ts
+++ b/src/frontend/store/slices/device/types.ts
@@ -121,20 +121,11 @@ export type DeviceActions = {
   updatePin: (updatedData: Partial<DevicePin>) => PinUpdateResponse
   setDeviceBoard: (board: string) => void
   setCommunicationPort: (port: string) => void
-  setCommunicationPreferences: (prefs: {
-    enableRTU?: boolean
-    enableTCP?: boolean
-    enableDHCP?: boolean
-  }) => void
+  setCommunicationPreferences: (prefs: { enableRTU?: boolean; enableTCP?: boolean; enableDHCP?: boolean }) => void
   setRTUConfig: (config: RTUConfigParam) => void
   setTCPConfig: (config: TCPConfigParam) => void
   setWifiConfig: (config: { tcpWifiSSID?: string; tcpWifiPassword?: string }) => void
-  setStaticHostConfiguration: (config: {
-    ipAddress?: string
-    dns?: string
-    gateway?: string
-    subnet?: string
-  }) => void
+  setStaticHostConfiguration: (config: { ipAddress?: string; dns?: string; gateway?: string; subnet?: string }) => void
   setCompileOnly: (compileOnly: boolean) => void
   setRuntimeIpAddress: (ipAddress: string) => void
   setRuntimeJwtToken: (token: string | null) => void
diff --git a/src2/frontend/store/slices/device/validation/pins.ts b/src/frontend/store/slices/device/validation/pins.ts
similarity index 82%
rename from src2/frontend/store/slices/device/validation/pins.ts
rename to src/frontend/store/slices/device/validation/pins.ts
index e423d9bb5..056d23339 100644
--- a/src2/frontend/store/slices/device/validation/pins.ts
+++ b/src/frontend/store/slices/device/validation/pins.ts
@@ -1,11 +1,16 @@
 import type { DevicePin, PinType } from '../../../../../middleware/shared/ports/types'
+import { PLC_ADDRESS_PREFIX } from '../../../../utils/PLC/address-constants'
 
 // ---------------------------------------------------------------------------
 // Address manipulation
 // ---------------------------------------------------------------------------
 
 const removeAddressPrefix = (address: string) => {
-  return address.replace('%IX', '').replace('%QX', '').replace('%IW', '').replace('%QW', '')
+  return address
+    .replace(PLC_ADDRESS_PREFIX.BOOL_INPUT, '')
+    .replace(PLC_ADDRESS_PREFIX.BOOL_OUTPUT, '')
+    .replace(PLC_ADDRESS_PREFIX.WORD_INPUT, '')
+    .replace(PLC_ADDRESS_PREFIX.WORD_OUTPUT, '')
 }
 
 const extractPositionForAnalogAddress = (address: string) => {
@@ -14,7 +19,9 @@ const extractPositionForAnalogAddress = (address: string) => {
 }
 
 const extractPositionsForDigitalAddress = (address: string) => {
-  const stringWithNoPrefix = address.replace('%IX', '').replace('%QX', '')
+  const stringWithNoPrefix = address
+    .replace(PLC_ADDRESS_PREFIX.BOOL_INPUT, '')
+    .replace(PLC_ADDRESS_PREFIX.BOOL_OUTPUT, '')
   const position = parseInt(stringWithNoPrefix.split('.')[0])
   const dotPosition = parseInt(stringWithNoPrefix.split('.')[1])
   return { position, dotPosition }
@@ -56,27 +63,27 @@ const handleAnalogAddress = (prefix: string, action: (typeof ADDRESS_ACTIONS)[nu
 const createNewAddress = (action: (typeof ADDRESS_ACTIONS)[number], address: string) => {
   const isFirstAddress = address.match(/(\d+)$/)
 
-  if (address.includes('%IX')) {
+  if (address.includes(PLC_ADDRESS_PREFIX.BOOL_INPUT)) {
     if (isFirstAddress === null) {
-      return '%IX0.0'
+      return `${PLC_ADDRESS_PREFIX.BOOL_INPUT}0.0`
     }
-    return handleDigitalAddress('%IX', action, address)
-  } else if (address.includes('%QX')) {
+    return handleDigitalAddress(PLC_ADDRESS_PREFIX.BOOL_INPUT, action, address)
+  } else if (address.includes(PLC_ADDRESS_PREFIX.BOOL_OUTPUT)) {
     if (isFirstAddress === null) {
-      return '%QX0.0'
+      return `${PLC_ADDRESS_PREFIX.BOOL_OUTPUT}0.0`
     }
-    return handleDigitalAddress('%QX', action, address)
-  } else if (address.includes('%IW')) {
+    return handleDigitalAddress(PLC_ADDRESS_PREFIX.BOOL_OUTPUT, action, address)
+  } else if (address.includes(PLC_ADDRESS_PREFIX.WORD_INPUT)) {
     if (isFirstAddress === null) {
-      return '%IW0'
+      return `${PLC_ADDRESS_PREFIX.WORD_INPUT}0`
     }
-    return handleAnalogAddress('%IW', action, address)
+    return handleAnalogAddress(PLC_ADDRESS_PREFIX.WORD_INPUT, action, address)
   }
 
   if (isFirstAddress === null) {
-    return '%QW0'
+    return `${PLC_ADDRESS_PREFIX.WORD_OUTPUT}0`
   }
-  return handleAnalogAddress('%QW', action, address)
+  return handleAnalogAddress(PLC_ADDRESS_PREFIX.WORD_OUTPUT, action, address)
 }
 
 const getHighestPinAddress = (pinMap: DevicePin[], pinType: PinType) => {
@@ -96,25 +103,25 @@ const getHighestPinAddress = (pinMap: DevicePin[], pinType: PinType) => {
   switch (pinType) {
     case 'digitalInput': {
       const ordered = pinMap.filter((pin) => pin.pinType === 'digitalInput').sort(compareAddressPosition)
-      if (ordered.length === 0) return '%IX'
+      if (ordered.length === 0) return PLC_ADDRESS_PREFIX.BOOL_INPUT
       pinWithHighestAddress = ordered[ordered.length - 1]
       break
     }
     case 'digitalOutput': {
       const ordered = pinMap.filter((pin) => pin.pinType === 'digitalOutput').sort(compareAddressPosition)
-      if (ordered.length === 0) return '%QX'
+      if (ordered.length === 0) return PLC_ADDRESS_PREFIX.BOOL_OUTPUT
       pinWithHighestAddress = ordered[ordered.length - 1]
       break
     }
     case 'analogInput': {
       const ordered = pinMap.filter((pin) => pin.pinType === 'analogInput').sort(compareAddressPosition)
-      if (ordered.length === 0) return '%IW'
+      if (ordered.length === 0) return PLC_ADDRESS_PREFIX.WORD_INPUT
       pinWithHighestAddress = ordered[ordered.length - 1]
       break
     }
     case 'analogOutput': {
       const ordered = pinMap.filter((pin) => pin.pinType === 'analogOutput').sort(compareAddressPosition)
-      if (ordered.length === 0) return '%QW'
+      if (ordered.length === 0) return PLC_ADDRESS_PREFIX.WORD_OUTPUT
       pinWithHighestAddress = ordered[ordered.length - 1]
       break
     }
diff --git a/src2/frontend/store/slices/editor/index.ts b/src/frontend/store/slices/editor/index.ts
similarity index 100%
rename from src2/frontend/store/slices/editor/index.ts
rename to src/frontend/store/slices/editor/index.ts
diff --git a/src2/frontend/store/slices/editor/slice.ts b/src/frontend/store/slices/editor/slice.ts
similarity index 95%
rename from src2/frontend/store/slices/editor/slice.ts
rename to src/frontend/store/slices/editor/slice.ts
index fb3e1f55a..7aece0e0b 100644
--- a/src2/frontend/store/slices/editor/slice.ts
+++ b/src/frontend/store/slices/editor/slice.ts
@@ -84,7 +84,8 @@ export const createEditorSlice: StateCreator<EditorSlice, [], [], EditorSlice> =
 
           if (targetEditor.type === 'plc-resource') {
             if (variables.display === 'table') {
-              const prevSelectedRow = targetEditor.variable.display === 'table' ? targetEditor.variable.selectedRow : '-1'
+              const prevSelectedRow =
+                targetEditor.variable.display === 'table' ? targetEditor.variable.selectedRow : '-1'
               const prevDescription = targetEditor.variable.display === 'table' ? targetEditor.variable.description : ''
               targetEditor.variable = {
                 display: 'table',
@@ -100,8 +101,10 @@ export const createEditorSlice: StateCreator<EditorSlice, [], [], EditorSlice> =
             }
           } else if (targetEditor.type === 'plc-textual' || targetEditor.type === 'plc-graphical') {
             if (variables.display === 'table') {
-              const prevSelectedRow = targetEditor.variable.display === 'table' ? targetEditor.variable.selectedRow : '-1'
-              const prevClassFilter = targetEditor.variable.display === 'table' ? targetEditor.variable.classFilter : 'All'
+              const prevSelectedRow =
+                targetEditor.variable.display === 'table' ? targetEditor.variable.selectedRow : '-1'
+              const prevClassFilter =
+                targetEditor.variable.display === 'table' ? targetEditor.variable.classFilter : 'All'
               const prevDescription = targetEditor.variable.display === 'table' ? targetEditor.variable.description : ''
               targetEditor.variable = {
                 display: 'table',
@@ -251,9 +254,7 @@ export const createEditorSlice: StateCreator<EditorSlice, [], [], EditorSlice> =
           if (oldEditor.meta.name === newEditor.meta.name) return
 
           if (oldEditor.type !== 'available') {
-            state.editors = state.editors.map((model) =>
-              model.meta.name === oldEditor.meta.name ? oldEditor : model,
-            )
+            state.editors = state.editors.map((model) => (model.meta.name === oldEditor.meta.name ? oldEditor : model))
           }
 
           state.editor = newEditor
diff --git a/src2/frontend/store/slices/editor/types.ts b/src/frontend/store/slices/editor/types.ts
similarity index 96%
rename from src2/frontend/store/slices/editor/types.ts
rename to src/frontend/store/slices/editor/types.ts
index 9af18190a..6c22dc9b2 100644
--- a/src2/frontend/store/slices/editor/types.ts
+++ b/src/frontend/store/slices/editor/types.ts
@@ -30,13 +30,9 @@ export type StructureTableType = {
   selectedRow: string
 }
 
-export type TaskType =
-  | { display: 'table'; selectedRow: string }
-  | { display: 'code' }
+export type TaskType = { display: 'table'; selectedRow: string } | { display: 'code' }
 
-export type InstanceType =
-  | { display: 'table'; selectedRow: string }
-  | { display: 'code' }
+export type InstanceType = { display: 'table'; selectedRow: string } | { display: 'code' }
 
 // ---------------------------------------------------------------------------
 // Graphical schemas
diff --git a/src/renderer/store/slices/console/index.ts b/src/frontend/store/slices/fbd/index.ts
similarity index 100%
rename from src/renderer/store/slices/console/index.ts
rename to src/frontend/store/slices/fbd/index.ts
diff --git a/src2/frontend/store/slices/fbd/slice.ts b/src/frontend/store/slices/fbd/slice.ts
similarity index 96%
rename from src2/frontend/store/slices/fbd/slice.ts
rename to src/frontend/store/slices/fbd/slice.ts
index 5e71a2229..7b7252cd6 100644
--- a/src2/frontend/store/slices/fbd/slice.ts
+++ b/src/frontend/store/slices/fbd/slice.ts
@@ -19,7 +19,8 @@ export const createFBDFlowSlice: StateCreator<FBDFlowSlice, [], [], FBDFlowSlice
             ...flow.rung,
             selectedNodes: [],
           }
-          const newFlow = { ...flow, rung }
+          // Reset updated to false on load — the flow is being loaded from a saved project.
+          const newFlow = { ...flow, rung, updated: false }
 
           if (flowIndex === -1) {
             fbdFlows.push(newFlow)
@@ -327,7 +328,9 @@ export const createFBDFlowSlice: StateCreator<FBDFlowSlice, [], [], FBDFlowSlice
                 ...snapshot.rung,
                 selectedNodes: [],
               },
-              updated: true,
+              // Don't set updated: true — snapshot restore is managed by the undo/redo
+              // handler which controls the saved flag directly.
+              updated: false,
             }
 
             if (index === -1) {
diff --git a/src2/frontend/store/slices/fbd/types.ts b/src/frontend/store/slices/fbd/types.ts
similarity index 96%
rename from src2/frontend/store/slices/fbd/types.ts
rename to src/frontend/store/slices/fbd/types.ts
index 2d7a25b2d..e10ef077c 100644
--- a/src2/frontend/store/slices/fbd/types.ts
+++ b/src/frontend/store/slices/fbd/types.ts
@@ -32,17 +32,14 @@ const zodFBDNodeTypesSchema = z.enum([
 ])
 type ZodFBDNodeType = z.infer<typeof zodFBDNodeTypesSchema>
 
+import type { FBDRungState } from '../../../../middleware/shared/ports/types'
+
+export type { FBDRungState }
+
 /**
  * Types used at the slice
  */
 
-type FBDRungState = {
-  comment: string
-  selectedNodes: Node[]
-  nodes: Node[]
-  edges: Edge[]
-}
-
 type FBDFlowType = {
   name: string
   updated: boolean
diff --git a/src2/frontend/store/slices/fbd/utils/index.ts b/src/frontend/store/slices/fbd/utils/index.ts
similarity index 95%
rename from src2/frontend/store/slices/fbd/utils/index.ts
rename to src/frontend/store/slices/fbd/utils/index.ts
index 666042715..450f85e6a 100644
--- a/src2/frontend/store/slices/fbd/utils/index.ts
+++ b/src/frontend/store/slices/fbd/utils/index.ts
@@ -1,10 +1,15 @@
+import { Edge, Node } from '@xyflow/react'
+
 import { CustomFbdNodeTypes } from '../../../../components/_atoms/graphical-editor/fbd'
-import { BlockNodeData, CommentNode, ConnectionNode, VariableNode } from '../../../../components/_atoms/graphical-editor/fbd/utils/types'
+import {
+  BlockNodeData,
+  CommentNode,
+  ConnectionNode,
+  VariableNode,
+} from '../../../../components/_atoms/graphical-editor/fbd/utils/types'
 import { BlockVariant } from '../../../../components/_atoms/graphical-editor/types/block'
 import { buildGenericNode } from '../../../../components/_molecules/graphical-editor/fbd/fbd-utils/nodes'
 import { newGraphicalEditorNodeID } from '../../../../utils/new-graphical-editor-node-id'
-import { Edge, Node } from '@xyflow/react'
-
 import { FBDRungState } from '../types'
 
 export const pasteNodesAtFBD = (nodes: Node[], edges: Edge[], mouse: { x: number; y: number }) => {
diff --git a/src2/frontend/store/slices/file/index.ts b/src/frontend/store/slices/file/index.ts
similarity index 100%
rename from src2/frontend/store/slices/file/index.ts
rename to src/frontend/store/slices/file/index.ts
diff --git a/src2/frontend/store/slices/file/slice.ts b/src/frontend/store/slices/file/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/file/slice.ts
rename to src/frontend/store/slices/file/slice.ts
diff --git a/src2/frontend/store/slices/file/types.ts b/src/frontend/store/slices/file/types.ts
similarity index 87%
rename from src2/frontend/store/slices/file/types.ts
rename to src/frontend/store/slices/file/types.ts
index 8c73c64c1..1fd8d416e 100644
--- a/src2/frontend/store/slices/file/types.ts
+++ b/src/frontend/store/slices/file/types.ts
@@ -21,7 +21,13 @@ export type FileSliceDataObject = Record<string, FileSliceData>
 
 export type FileActions = {
   setFiles: (args: { files: FileSliceDataObject }) => void
-  addFile: (args: { name: string; type: FileSliceType; filePath: string; isNew?: boolean; cleanState?: unknown }) => boolean
+  addFile: (args: {
+    name: string
+    type: FileSliceType
+    filePath: string
+    isNew?: boolean
+    cleanState?: unknown
+  }) => boolean
   removeFile: (args: { name: string }) => void
   updateFile: (args: {
     name: string
diff --git a/src2/frontend/store/slices/history/index.ts b/src/frontend/store/slices/history/index.ts
similarity index 100%
rename from src2/frontend/store/slices/history/index.ts
rename to src/frontend/store/slices/history/index.ts
diff --git a/src2/frontend/store/slices/history/slice.ts b/src/frontend/store/slices/history/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/history/slice.ts
rename to src/frontend/store/slices/history/slice.ts
diff --git a/src2/frontend/store/slices/history/types.ts b/src/frontend/store/slices/history/types.ts
similarity index 93%
rename from src2/frontend/store/slices/history/types.ts
rename to src/frontend/store/slices/history/types.ts
index 66593c31d..d8561da3a 100644
--- a/src2/frontend/store/slices/history/types.ts
+++ b/src/frontend/store/slices/history/types.ts
@@ -24,6 +24,8 @@ export type HistorySnapshot = {
 export type PouHistoryBucket = {
   past: HistorySnapshot[]
   future: HistorySnapshot[]
+  /** Depth of the past stack when the file was last saved. null = never saved or diverged. */
+  savedAtDepth: number | null
 }
 
 export type HistoryState = Record<string, PouHistoryBucket>
diff --git a/src2/frontend/store/slices/index.ts b/src/frontend/store/slices/index.ts
similarity index 100%
rename from src2/frontend/store/slices/index.ts
rename to src/frontend/store/slices/index.ts
index e93524b60..a30846341 100644
--- a/src2/frontend/store/slices/index.ts
+++ b/src/frontend/store/slices/index.ts
@@ -1,33 +1,33 @@
-export { createAISlice, createAISliceFactory } from './ai'
 export type { AISlice } from './ai'
+export { createAISlice, createAISliceFactory } from './ai'
 export { MAX_CONVERSATION_MESSAGES } from './ai'
-export { createConsoleSlice } from './console'
 export type { ConsoleSlice } from './console'
-export { createDeviceSlice } from './device'
+export { createConsoleSlice } from './console'
 export type { DeviceSlice } from './device'
-export { createEditorSlice } from './editor'
+export { createDeviceSlice } from './device'
 export type { EditorModel, EditorSlice, EditorState, GlobalVariablesTableType, VariablesTable } from './editor'
-export { createFBDFlowSlice } from './fbd'
+export { createEditorSlice } from './editor'
 export type { FBDFlowActions, FBDFlowSlice, FBDFlowState, FBDFlowType, FBDRungState } from './fbd'
-export { createFileSlice } from './file'
+export { createFBDFlowSlice } from './fbd'
 export type { FileSlice } from './file'
-export { createHistorySlice, HISTORY_LIMIT } from './history'
+export { createFileSlice } from './file'
 export type { HistorySlice } from './history'
-export { createLadderFlowSlice } from './ladder'
+export { createHistorySlice, HISTORY_LIMIT } from './history'
 export type { LadderFlowActions, LadderFlowSlice, LadderFlowState, LadderFlowType, RungLadderState } from './ladder'
-export { createLibrarySlice } from './library'
+export { createLadderFlowSlice } from './ladder'
 export type { LibrarySlice, LibraryState } from './library'
-export { createModalSlice } from './modal'
+export { createLibrarySlice } from './library'
 export type { ModalSlice } from './modal'
-export { createProjectSlice } from './project'
+export { createModalSlice } from './modal'
 export type { ProjectResponse, ProjectSlice, StructureVariableDTO, VariableDTO } from './project'
-export { createSearchSlice } from './search'
+export { createProjectSlice } from './project'
 export type { SearchSlice } from './search'
-export { createSharedSlice } from './shared'
+export { createSearchSlice } from './search'
 export type { SharedSlice, SharedWorkspaceActions } from './shared'
-export { createTabsSlice } from './tabs'
+export { createSharedSlice } from './shared'
 export type { TabsSlice } from './tabs'
-export { createWebRTCSlice } from './webrtc'
+export { createTabsSlice } from './tabs'
 export type { WebRTCSlice } from './webrtc'
-export { createWorkspaceSlice } from './workspace'
+export { createWebRTCSlice } from './webrtc'
 export type { WorkspaceSlice } from './workspace'
+export { createWorkspaceSlice } from './workspace'
diff --git a/src/renderer/store/slices/device/index.ts b/src/frontend/store/slices/ladder/index.ts
similarity index 100%
rename from src/renderer/store/slices/device/index.ts
rename to src/frontend/store/slices/ladder/index.ts
diff --git a/src2/frontend/store/slices/ladder/slice.ts b/src/frontend/store/slices/ladder/slice.ts
similarity index 72%
rename from src2/frontend/store/slices/ladder/slice.ts
rename to src/frontend/store/slices/ladder/slice.ts
index c91bdb1c5..97bf3814c 100644
--- a/src2/frontend/store/slices/ladder/slice.ts
+++ b/src/frontend/store/slices/ladder/slice.ts
@@ -2,7 +2,15 @@ import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react'
 import { produce } from 'immer'
 import { StateCreator } from 'zustand'
 
+import type { PLCVariable } from '../../../../middleware/shared/ports/types'
+import {
+  defaultCustomNodesStyles,
+  nodesBuilder,
+} from '../../../components/_atoms/graphical-editor/ladder/node-builders'
+import type { LadderBlockConnectedVariables } from '../../../components/_atoms/graphical-editor/ladder/utils/types'
+import { removeElements } from '../../../components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements'
 import { LadderFlowSlice, LadderFlowState } from './types'
+import { duplicateLadderRung } from './utils'
 
 export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], LadderFlowSlice> = (setState) => ({
   ladderFlows: [],
@@ -15,11 +23,42 @@ export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], Ladder
       setState(
         produce(({ ladderFlows }: LadderFlowState) => {
           const flowIndex = ladderFlows.findIndex((f) => f.name === flow.name)
-          const rungs = flow.rungs.map((rung) => ({
-            ...rung,
-            selectedNodes: [],
-          }))
-          const newFlow = { ...flow, rungs }
+
+          // Check if any block node has legacy connectedVariables (object instead of array).
+          // Only scan + migrate if legacy data is detected — modern projects skip this entirely.
+          const needsMigration = flow.rungs.some((rung) =>
+            rung.nodes.some((node) => {
+              if (node.type !== 'block') return false
+              const cv = (node.data as { connectedVariables?: unknown }).connectedVariables
+              return cv != null && !Array.isArray(cv)
+            }),
+          )
+
+          const rungs = needsMigration
+            ? flow.rungs.map((rung) => ({
+                ...rung,
+                selectedNodes: [],
+                nodes: rung.nodes.map((node) => {
+                  if (node.type !== 'block') return node
+                  const data = node.data as { connectedVariables?: unknown }
+                  if (data.connectedVariables && !Array.isArray(data.connectedVariables)) {
+                    const converted: LadderBlockConnectedVariables = Object.entries(
+                      data.connectedVariables as Record<string, { variable?: PLCVariable; type?: string }>,
+                    ).map(([key, cv]) => ({
+                      handleId: key,
+                      variable: cv.variable,
+                      type: (cv.type as 'input' | 'output') ?? 'input',
+                    }))
+                    return { ...node, data: { ...node.data, connectedVariables: converted } }
+                  }
+                  return node
+                }),
+              }))
+            : flow.rungs.map((rung) => ({ ...rung, selectedNodes: [] }))
+
+          // Reset updated to false on load — the flow is being loaded from a saved project.
+          // Only mark as updated if legacy data was migrated so the next save writes the new format.
+          const newFlow = { ...flow, rungs, updated: needsMigration }
 
           if (flowIndex === -1) {
             ladderFlows.push(newFlow)
@@ -43,20 +82,58 @@ export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], Ladder
     /**
      * Control the rungs of the flow
      */
-    startLadderRung: ({ editorName, rung }) => {
+    startLadderRung: ({ editorName, rungId, defaultBounds, reactFlowViewport }) => {
       setState(
         produce(({ ladderFlows }: LadderFlowState) => {
-          let flow = ladderFlows.find((f) => f.name === editorName)
-          if (!flow) {
-            flow = {
+          if (!ladderFlows.find((flow) => flow.name === editorName)) {
+            ladderFlows.push({
               name: editorName,
               updated: true,
               rungs: [],
-            }
-            ladderFlows.push(flow)
+            })
           }
 
-          flow.rungs.push(rung)
+          const flow = ladderFlows.find((flow) => flow.name === editorName)
+          if (!flow) return
+
+          const { powerRail } = defaultCustomNodesStyles
+          const railNodes = [
+            nodesBuilder.powerRail({
+              id: `left-rail-${rungId}`,
+              posX: 0,
+              posY: defaultBounds[1] / 2 - powerRail.height / 2,
+              connector: 'right',
+              handleX: powerRail.width,
+              handleY: defaultBounds[1] / 2,
+            }),
+            nodesBuilder.powerRail({
+              id: `right-rail-${rungId}`,
+              posX: defaultBounds[0],
+              posY: defaultBounds[1] / 2 - powerRail.height / 2,
+              connector: 'left',
+              handleX: defaultBounds[0] - powerRail.width,
+              handleY: defaultBounds[1] / 2,
+            }),
+          ]
+          flow.rungs.push({
+            id: rungId,
+            comment: '',
+            defaultBounds,
+            reactFlowViewport:
+              reactFlowViewport && reactFlowViewport > defaultBounds ? reactFlowViewport : defaultBounds,
+            nodes: [...railNodes],
+            edges: [
+              {
+                id: `e_${railNodes[0].id}_${railNodes[1].id}`,
+                source: railNodes[0].id,
+                target: railNodes[1].id,
+                sourceHandle: railNodes[0].data.handles[0].id,
+                targetHandle: railNodes[1].data.handles[0].id,
+                type: 'smoothstep',
+              },
+            ],
+            selectedNodes: [],
+          })
         }),
       )
     },
@@ -111,7 +188,7 @@ export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], Ladder
         }),
       )
     },
-    duplicateRung({ editorName, rungId, newRung }) {
+    duplicateRung({ editorName, rungId }) {
       setState(
         produce(({ ladderFlows }: LadderFlowState) => {
           const flow = ladderFlows.find((flow) => flow.name === editorName)
@@ -120,6 +197,8 @@ export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], Ladder
           const rungIndex = flow.rungs.findIndex((rung) => rung.id === rungId)
           if (rungIndex === -1) return
 
+          const rung = flow.rungs[rungIndex]
+          const newRung = duplicateLadderRung(flow.name, rung)
           flow.rungs.splice(rungIndex + 1, 0, newRung)
           flow.updated = true
         }),
@@ -236,10 +315,9 @@ export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], Ladder
           const rung = flow.rungs.find((rung) => rung.id === rungId)
           if (!rung) return
 
-          const removedIds = new Set(nodes.map((n) => n.id))
-          rung.nodes = rung.nodes.filter((node) => !removedIds.has(node.id))
-          rung.edges = rung.edges.filter((edge) => !removedIds.has(edge.source) && !removedIds.has(edge.target))
-          rung.selectedNodes = rung.selectedNodes.filter((node) => !removedIds.has(node.id))
+          const { nodes: newNodes, edges: newEdges } = removeElements(rung, nodes)
+          rung.nodes = newNodes
+          rung.edges = newEdges
           flow.updated = true
         }),
       )
@@ -395,7 +473,9 @@ export const createLadderFlowSlice: StateCreator<LadderFlowSlice, [], [], Ladder
           if (snapshot) {
             const flowIndex = ladderFlows.findIndex((ladderFlow) => ladderFlow.name === editorName)
             const rungs = snapshot.rungs.map((rung) => ({ ...rung, selectedNodes: [] }))
-            const newFlow = { ...snapshot, name: editorName, rungs }
+            // Don't set updated: true — snapshot restore is managed by the undo/redo
+            // handler which controls the saved flag directly.
+            const newFlow = { ...snapshot, name: editorName, rungs, updated: false }
 
             if (flowIndex === -1) {
               ladderFlows.push(newFlow)
diff --git a/src2/frontend/store/slices/ladder/types.ts b/src/frontend/store/slices/ladder/types.ts
similarity index 92%
rename from src2/frontend/store/slices/ladder/types.ts
rename to src/frontend/store/slices/ladder/types.ts
index 69d0e3ebf..def5c6833 100644
--- a/src2/frontend/store/slices/ladder/types.ts
+++ b/src/frontend/store/slices/ladder/types.ts
@@ -30,20 +30,14 @@ type ZodLadderFlowState = z.infer<typeof zodLadderFlowStateSchema>
 const zodLadderNodeTypesSchema = z.enum(['block', 'contact', 'coil', 'parallel', 'powerRail', 'variable'])
 type ZodLadderNodeType = z.infer<typeof zodLadderNodeTypesSchema>
 
+import type { RungLadderState } from '../../../../middleware/shared/ports/types'
+
+export type { RungLadderState }
+
 /**
  * Types used at the slice
  */
 
-type RungLadderState = {
-  id: string
-  comment: string
-  defaultBounds: number[]
-  reactFlowViewport: number[]
-  selectedNodes: Node[]
-  nodes: Node[]
-  edges: Edge[]
-}
-
 type LadderFlowType = {
   name: string
   updated: boolean
@@ -62,19 +56,21 @@ type LadderFlowActions = {
   /**
    * Control the rungs of the flow
    */
-  startLadderRung: ({ editorName, rung }: { editorName: string; rung: RungLadderState }) => void
-  setRungs: ({ rungs, editorName }: { rungs: RungLadderState[]; editorName: string }) => void
-  removeRung: (editorName: string, rungId: string) => void
-  addComment: ({ editorName, rungId, comment }: { editorName: string; rungId: string; comment: string }) => void
-  duplicateRung: ({
+  startLadderRung: ({
     editorName,
     rungId,
-    newRung,
+    defaultBounds,
+    reactFlowViewport,
   }: {
     editorName: string
     rungId: string
-    newRung: RungLadderState
+    defaultBounds: [number, number]
+    reactFlowViewport?: [number, number]
   }) => void
+  setRungs: ({ rungs, editorName }: { rungs: RungLadderState[]; editorName: string }) => void
+  removeRung: (editorName: string, rungId: string) => void
+  addComment: ({ editorName, rungId, comment }: { editorName: string; rungId: string; comment: string }) => void
+  duplicateRung: ({ editorName, rungId }: { editorName: string; rungId: string }) => void
 
   /**
    * Control the rungs transactions
diff --git a/src/frontend/store/slices/ladder/utils/index.ts b/src/frontend/store/slices/ladder/utils/index.ts
new file mode 100644
index 000000000..4b5248543
--- /dev/null
+++ b/src/frontend/store/slices/ladder/utils/index.ts
@@ -0,0 +1,254 @@
+import { Edge, Node } from '@xyflow/react'
+
+import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
+import { nodesBuilder } from '../../../../components/_atoms/graphical-editor/ladder/node-builders'
+import type { LadderBlockConnectedVariables } from '../../../../components/_atoms/graphical-editor/ladder/utils/types'
+import type {
+  BlockNode,
+  BlockVariant,
+  CoilNode,
+  ContactNode,
+  ParallelNode,
+  PowerRailNode,
+  VariableNode,
+} from '../../../../components/_atoms/graphical-editor/ladder/utils/types'
+import { generateNumericUUID } from '../../../../utils/generate-uuid'
+import { newGraphicalEditorNodeID } from '../../../../utils/new-graphical-editor-node-id'
+import { RungLadderState } from '../types'
+
+export const duplicateLadderRung = (editorName: string, rung: RungLadderState): RungLadderState => {
+  const nodeMaps: { [key: string]: Node } = rung.nodes.reduce(
+    (acc, node) => {
+      acc[node.id] = {
+        ...node,
+        id: node.type === 'powerRail' ? node.id : newGraphicalEditorNodeID(node.type?.toUpperCase()),
+      }
+      return acc
+    },
+    {} as { [key: string]: Node },
+  )
+
+  const edgeMaps: { [key: string]: Edge } = rung.edges.reduce(
+    (acc, edge) => {
+      acc[edge.id] = {
+        id: `e_${nodeMaps[edge.source].id}_${nodeMaps[edge.target].id}__${edge.sourceHandle}_${edge.targetHandle}`,
+        source: nodeMaps[edge.source].id,
+        target: nodeMaps[edge.target].id,
+        sourceHandle: edge.sourceHandle,
+        targetHandle: edge.targetHandle,
+      }
+      return acc
+    },
+    {} as { [key: string]: Edge },
+  )
+
+  const newNodes = rung.nodes.map((node) => {
+    switch (node.type) {
+      case 'block': {
+        const newBlock = nodesBuilder.block({
+          id: nodeMaps[node.id].id,
+          posX: node.position.x,
+          posY: node.position.y,
+          handleX: (node as BlockNode<BlockVariant>).data.inputConnector?.glbPosition.x ?? 0,
+          handleY: (node as BlockNode<BlockVariant>).data.inputConnector?.glbPosition.y ?? 0,
+          variant: (node as BlockNode<BlockVariant>).data.variant,
+          executionControl: (node as BlockNode<BlockVariant>).data.executionControl,
+        })
+        return {
+          ...newBlock,
+          data: {
+            ...newBlock.data,
+            variable:
+              (node as BlockNode<BlockVariant>).data.variant.type === 'function-block'
+                ? { name: '' }
+                : node.data.variable,
+            connectedVariables: normalizeConnectedVariables((node as BlockNode<BlockVariant>).data.connectedVariables),
+          },
+        } as BlockNode<BlockVariant>
+      }
+      case 'coil': {
+        const newCoil = nodesBuilder.coil({
+          id: nodeMaps[node.id].id,
+          posX: node.position.x,
+          posY: node.position.y,
+          handleX: (node as CoilNode).data.inputConnector?.glbPosition.x ?? 0,
+          handleY: (node as CoilNode).data.inputConnector?.glbPosition.y ?? 0,
+          variant: (node as CoilNode).data.variant,
+        })
+        return {
+          ...newCoil,
+          data: {
+            ...newCoil.data,
+            variable: (node as CoilNode).data.variable,
+          },
+        } as CoilNode
+      }
+      case 'contact': {
+        const newContact = nodesBuilder.contact({
+          id: nodeMaps[node.id].id,
+          posX: node.position.x,
+          posY: node.position.y,
+          handleX: (node as ContactNode).data.inputConnector?.glbPosition.x ?? 0,
+          handleY: (node as ContactNode).data.inputConnector?.glbPosition.y ?? 0,
+          variant: (node as ContactNode).data.variant,
+        })
+        return {
+          ...newContact,
+          data: {
+            ...newContact.data,
+            variable: (node as ContactNode).data.variable,
+          },
+        } as ContactNode
+      }
+      case 'parallel': {
+        return {
+          ...node,
+          id: nodeMaps[node.id].id,
+          data: {
+            ...node.data,
+            numericId: generateNumericUUID(),
+            parallelCloseReference: (node as ParallelNode).data.parallelCloseReference
+              ? nodeMaps[(node as ParallelNode).data.parallelCloseReference ?? ''].id
+              : undefined,
+            parallelOpenReference: (node as ParallelNode).data.parallelOpenReference
+              ? nodeMaps[(node as ParallelNode).data.parallelOpenReference ?? ''].id
+              : undefined,
+          },
+        } as ParallelNode
+      }
+      case 'powerRail': {
+        return {
+          ...node,
+          id: nodeMaps[node.id].id,
+          data: {
+            ...node.data,
+            numericId: generateNumericUUID(),
+          },
+        } as PowerRailNode
+      }
+      case 'variable': {
+        return {
+          ...node,
+          id: nodeMaps[node.id].id,
+          data: {
+            ...node.data,
+            numericId: generateNumericUUID(),
+            block: {
+              ...(node as VariableNode).data.block,
+              id: nodeMaps[(node as VariableNode).data.block.id]?.id ?? (node as VariableNode).data.block.id,
+            },
+          },
+        } as VariableNode
+      }
+      default: {
+        return node
+      }
+    }
+  })
+
+  const newEdges = rung.edges.map((edge) => ({
+    ...edge,
+    id: edgeMaps[edge.id].id,
+    source: edgeMaps[edge.id].source,
+    target: edgeMaps[edge.id].target,
+  }))
+
+  const newRung = {
+    id: `rung_${editorName}_${crypto.randomUUID()}`,
+    comment: rung.comment,
+    defaultBounds: rung.defaultBounds,
+    reactFlowViewport: rung.reactFlowViewport,
+    selectedNodes: [],
+    nodes: newNodes,
+    edges: newEdges,
+  }
+
+  return newRung
+}
+
+/**
+ * Checks if a function block variable is still in use by any block in the flows.
+ * This is used to determine if a variable should be deleted when a function block is removed.
+ *
+ * @param variableName - Name of the variable to check (case-insensitive)
+ * @param allRungs - All rungs/diagrams (must have nodes property)
+ * @returns true if the variable is still in use, false otherwise
+ */
+export const isFunctionBlockVariableInUse = (variableName: string, allRungs: Array<{ nodes: Node[] }>): boolean => {
+  const normalizedName = variableName.toLowerCase()
+
+  for (const rung of allRungs) {
+    for (const node of rung.nodes) {
+      if (node.type === 'block') {
+        const blockNode = node as BlockNode<BlockVariant>
+        const blockVariableName = blockNode.data.variable?.name?.toLowerCase()
+
+        if (blockVariableName === normalizedName && blockNode.data.variant.type === 'function-block') {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Gets all function block variables that should be cleaned up after nodes are removed.
+ * Returns an array of variable names that are no longer in use.
+ *
+ * @param removedNodes - Nodes that were removed
+ * @param allRungs - All rungs/diagrams (must have nodes property)
+ * @param allVariables - All variables in the POU
+ * @returns Array of variable names to delete
+ */
+export const getFunctionBlockVariablesToCleanup = (
+  removedNodes: Node[],
+  allRungs: Array<{ nodes: Node[] }>,
+  allVariables: PLCVariable[],
+): string[] => {
+  const variablesToCheck = new Set<string>()
+
+  for (const node of removedNodes) {
+    if (node.type === 'block') {
+      const blockNode = node as BlockNode<BlockVariant>
+      if (blockNode.data.variant.type === 'function-block') {
+        const variableName = blockNode.data.variable?.name
+        if (variableName) {
+          variablesToCheck.add(variableName)
+        }
+      }
+    }
+  }
+
+  const variablesToDelete: string[] = []
+
+  for (const variableName of variablesToCheck) {
+    const variable = allVariables.find((v) => v.name.toLowerCase() === variableName.toLowerCase())
+
+    if (variable && variable.type.definition === 'derived') {
+      if (!isFunctionBlockVariableInUse(variableName, allRungs)) {
+        variablesToDelete.push(variableName)
+      }
+    }
+  }
+
+  return variablesToDelete
+}
+
+/**
+ * Normalize connectedVariables from legacy object format to array format.
+ * Old projects stored { handleId: { variable, type } } instead of the
+ * current [{ handleId, variable, type }] array format.
+ */
+function normalizeConnectedVariables(raw: unknown): LadderBlockConnectedVariables {
+  if (Array.isArray(raw)) return raw as LadderBlockConnectedVariables
+  if (raw && typeof raw === 'object') {
+    return Object.entries(raw as Record<string, { variable?: PLCVariable; type?: string }>).map(([key, cv]) => ({
+      handleId: key,
+      variable: cv.variable,
+      type: (cv.type as 'input' | 'output') ?? 'input',
+    }))
+  }
+  return []
+}
diff --git a/src2/frontend/store/slices/library/index.ts b/src/frontend/store/slices/library/index.ts
similarity index 100%
rename from src2/frontend/store/slices/library/index.ts
rename to src/frontend/store/slices/library/index.ts
diff --git a/src2/frontend/store/slices/library/slice.ts b/src/frontend/store/slices/library/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/library/slice.ts
rename to src/frontend/store/slices/library/slice.ts
diff --git a/src/frontend/store/slices/library/types.ts b/src/frontend/store/slices/library/types.ts
new file mode 100644
index 000000000..188583123
--- /dev/null
+++ b/src/frontend/store/slices/library/types.ts
@@ -0,0 +1,23 @@
+export type {
+  LibraryLanguage,
+  LibraryPouType,
+  LibraryState,
+  SystemLibrary,
+  SystemLibraryPou,
+  SystemLibraryVariable,
+  UserLibrary,
+} from '../../../../middleware/shared/ports/library-types'
+
+import type { SystemLibrary } from '../../../../middleware/shared/ports/library-types'
+
+export type LibraryActions = {
+  setSystemLibraries: (libraries: SystemLibrary[]) => void
+  addLibrary: (name: string, type: 'function' | 'function-block') => void
+  updateLibraryName: (name: string, newName: string) => void
+  clearUserLibraries: () => void
+  removeUserLibrary: (name: string) => void
+}
+
+export type LibrarySlice = import('../../../../middleware/shared/ports/library-types').LibraryState & {
+  libraryActions: LibraryActions
+}
diff --git a/src2/frontend/store/slices/modal/index.ts b/src/frontend/store/slices/modal/index.ts
similarity index 100%
rename from src2/frontend/store/slices/modal/index.ts
rename to src/frontend/store/slices/modal/index.ts
diff --git a/src2/frontend/store/slices/modal/slice.ts b/src/frontend/store/slices/modal/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/modal/slice.ts
rename to src/frontend/store/slices/modal/slice.ts
diff --git a/src2/frontend/store/slices/modal/types.ts b/src/frontend/store/slices/modal/types.ts
similarity index 100%
rename from src2/frontend/store/slices/modal/types.ts
rename to src/frontend/store/slices/modal/types.ts
diff --git a/src2/frontend/store/slices/project/index.ts b/src/frontend/store/slices/project/index.ts
similarity index 100%
rename from src2/frontend/store/slices/project/index.ts
rename to src/frontend/store/slices/project/index.ts
index 0c265899a..3eef6c5c9 100644
--- a/src2/frontend/store/slices/project/index.ts
+++ b/src/frontend/store/slices/project/index.ts
@@ -1,5 +1,4 @@
 export { createProjectSlice } from './slice'
-export { getVariableBasedOnRowIdOrVariableId } from './utils'
 export type {
   DataTypeDTO,
   InstanceDTO,
@@ -14,3 +13,4 @@ export type {
   TaskDTO,
   VariableDTO,
 } from './types'
+export { getVariableBasedOnRowIdOrVariableId } from './utils'
diff --git a/src2/frontend/store/slices/project/slice.ts b/src/frontend/store/slices/project/slice.ts
similarity index 87%
rename from src2/frontend/store/slices/project/slice.ts
rename to src/frontend/store/slices/project/slice.ts
index 71876a4bb..2dd91896b 100644
--- a/src2/frontend/store/slices/project/slice.ts
+++ b/src/frontend/store/slices/project/slice.ts
@@ -1,16 +1,24 @@
+import { produce } from 'immer'
+import { StateCreator } from 'zustand'
+
 import type {
   ModbusIOPoint,
   OpcUaServerConfig,
   PLCServer,
+  PLCVariable,
   S7CommLogging,
   S7CommPlcIdentity,
   S7CommServerSettings,
 } from '../../../../middleware/shared/ports/types'
-import { produce } from 'immer'
-import { StateCreator } from 'zustand'
-
+import { isLegalIdentifier } from '../../../utils/keywords'
 import type { ProjectResponse, ProjectSlice } from './types'
 import { getVariableBasedOnRowIdOrVariableId } from './utils'
+import {
+  createGlobalVariableValidation,
+  createVariableValidation,
+  updateGlobalVariableValidation,
+  updateVariableValidation,
+} from './validation/variables'
 
 const ok = (data?: unknown): ProjectResponse => ({ ok: true, data })
 const fail = (message: string, title?: string): ProjectResponse => ({ ok: false, message, title })
@@ -104,9 +112,11 @@ function initializeServerProtocolConfig(serverData: PLCServer): PLCServer {
   return serverData
 }
 
-function getFunctionCodeInfo(
-  functionCode: '1' | '2' | '3' | '4' | '5' | '6' | '15' | '16',
-): { type: string; iecPrefix: string; isBit: boolean } {
+function getFunctionCodeInfo(functionCode: '1' | '2' | '3' | '4' | '5' | '6' | '15' | '16'): {
+  type: string
+  iecPrefix: string
+  isBit: boolean
+} {
   switch (functionCode) {
     case '1':
       return { type: 'Digital Input (Coil Status)', iecPrefix: '%IX', isBit: true }
@@ -142,17 +152,17 @@ function generateIOPoints(
   for (let i = 0; i < length; i++) {
     let iecLocation: string
     if (isBit) {
-      do {
-        iecLocation = `${iecPrefix}${Math.floor(currentAddress / 8)}.${currentAddress % 8}`
-        if (!usedAddresses.has(iecLocation)) break
+      iecLocation = `${iecPrefix}${Math.floor(currentAddress / 8)}.${currentAddress % 8}`
+      while (usedAddresses.has(iecLocation)) {
         currentAddress++
-      } while (true)
+        iecLocation = `${iecPrefix}${Math.floor(currentAddress / 8)}.${currentAddress % 8}`
+      }
     } else {
-      do {
-        iecLocation = `${iecPrefix}${currentAddress}`
-        if (!usedAddresses.has(iecLocation)) break
+      iecLocation = `${iecPrefix}${currentAddress}`
+      while (usedAddresses.has(iecLocation)) {
         currentAddress++
-      } while (true)
+        iecLocation = `${iecPrefix}${currentAddress}`
+      }
     }
 
     points.push({ id: `${groupName}_${i}`, name: `${groupName}_${i}`, type, iecLocation, alias: '' })
@@ -313,38 +323,45 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
     // Variables
     // -----------------------------------------------------------------------
     createVariable: (dto) => {
-      const { scope, associatedPou, data, rowToInsert } = dto
-      if (scope === 'local' && associatedPou) {
-        const pou = getState().project.data.pous.find((p) => p.name === associatedPou)
-        if (!pou) return fail('POU not found')
-        const variables = pou.interface?.variables ?? []
-        if (variables.some((v) => v.name === data.name)) return fail('Variable already exists')
-      } else {
-        const globalVars = getState().project.data.configurations.resource.globalVariables
-        if (globalVars.some((v) => v.name === data.name)) return fail('Variable already exists')
+      const { scope, associatedPou, rowToInsert } = dto
+      let { data } = dto
+
+      const [isNameLegal, reason] = isLegalIdentifier(data.name)
+      if (!isNameLegal) {
+        return fail(`'${data.name}' ${reason}`, 'Illegal Variable Name')
       }
 
+      let response: ProjectResponse = { ok: true }
       setState(
         produce((slice: ProjectSlice) => {
           if (scope === 'local' && associatedPou) {
             const pou = slice.project.data.pous.find((p) => p.name === associatedPou)
-            if (!pou?.interface) return
+            if (!pou?.interface) {
+              response = fail('POU not found')
+              return
+            }
+            data = { ...data, ...createVariableValidation(pou.interface.variables, data) }
             if (rowToInsert !== undefined) {
-              pou.interface.variables.splice(rowToInsert, 0, data)
+              const pouVariables = pou.interface.variables.filter((variable) => variable.name !== 'OUT')
+              pouVariables.splice(rowToInsert, 0, data)
+              pou.interface.variables = [...pouVariables]
             } else {
               pou.interface.variables.push(data)
             }
+            response.data = data
           } else {
             const vars = slice.project.data.configurations.resource.globalVariables
+            data.name = createGlobalVariableValidation(vars, data.name)
             if (rowToInsert !== undefined) {
               vars.splice(rowToInsert, 0, data)
             } else {
               vars.push(data)
             }
+            response.data = data
           }
         }),
       )
-      return ok()
+      return response
     },
     setPouVariables: ({ pouName, variables }) => {
       setState(
@@ -364,20 +381,52 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
       return ok()
     },
     updateVariable: ({ scope, associatedPou, rowId, variableId, data: updates }) => {
+      let response: ProjectResponse = { ok: true }
       setState(
         produce((slice: ProjectSlice) => {
-          const variables =
-            scope === 'local' && associatedPou
-              ? slice.project.data.pous.find((p) => p.name === associatedPou)?.interface?.variables
-              : slice.project.data.configurations.resource.globalVariables
-          if (!variables) return
-
-          const found = getVariableBasedOnRowIdOrVariableId(variables, rowId, variableId)
-          if (!found) return
-          Object.assign(variables[found.index], updates)
+          if (scope === 'local' && associatedPou) {
+            const pou = slice.project.data.pous.find((p) => p.name === associatedPou)
+            if (!pou?.interface) {
+              response = fail('POU not found')
+              return
+            }
+            const found = getVariableBasedOnRowIdOrVariableId(pou.interface.variables, rowId, variableId)
+            if (!found) {
+              response = { ok: false, title: 'Variable not found', message: 'Internal error' }
+              return
+            }
+            const validationResponse = updateVariableValidation(pou.interface.variables, updates, found.variable)
+            if (!validationResponse.ok) {
+              response = validationResponse
+              return
+            }
+            pou.interface.variables[found.index] = {
+              ...pou.interface.variables[found.index],
+              ...updates,
+              ...(validationResponse.data ? validationResponse.data : {}),
+            }
+            response.data = pou.interface.variables[found.index]
+          } else {
+            const globalVars = slice.project.data.configurations.resource.globalVariables
+            const validationResponse = updateGlobalVariableValidation(globalVars, updates)
+            if (!validationResponse.ok) {
+              response = validationResponse
+              return
+            }
+            const found = getVariableBasedOnRowIdOrVariableId(globalVars, rowId, variableId)
+            if (!found) {
+              response = { ok: false, title: 'Variable not found' }
+              return
+            }
+            globalVars[found.index] = {
+              ...globalVars[found.index],
+              ...updates,
+            }
+            response.data = globalVars[found.index]
+          }
         }),
       )
-      return ok()
+      return response
     },
     getVariable: ({ scope, associatedPou, rowId, variableId }) => {
       const variables =
@@ -390,6 +439,34 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
       return found?.variable
     },
     deleteVariable: ({ scope, associatedPou, rowId, variableId, variableName }) => {
+      if (scope === 'global') {
+        const state = getState()
+        const globalVars = state.project.data.configurations.resource.globalVariables
+
+        let variableToDelete: PLCVariable | undefined
+        if (variableName) {
+          variableToDelete = globalVars.find((v) => v.name.toLowerCase() === variableName.toLowerCase())
+        } else {
+          variableToDelete = getVariableBasedOnRowIdOrVariableId(globalVars, rowId, variableId)?.variable
+        }
+
+        if (variableToDelete) {
+          const externalReferences = state.project.data.pous.filter((pou) =>
+            pou.interface?.variables?.some(
+              (v) => v.class === 'external' && v.name.toLowerCase() === variableToDelete.name.toLowerCase(),
+            ),
+          )
+
+          if (externalReferences.length > 0) {
+            const pouNames = externalReferences.map((pou) => pou.name).join(', ')
+            return fail(
+              `The global variable "${variableToDelete.name}" is referenced by external variables in the following POUs: ${pouNames}. Please remove these references before deleting the global variable.`,
+              'Cannot Delete Global Variable',
+            )
+          }
+        }
+      }
+
       setState(
         produce((slice: ProjectSlice) => {
           const variables =
@@ -399,7 +476,7 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
           if (!variables) return
 
           if (variableName) {
-            const idx = variables.findIndex((v) => v.name === variableName)
+            const idx = variables.findIndex((v) => v.name.toLowerCase() === variableName.toLowerCase())
             if (idx !== -1) variables.splice(idx, 1)
             return
           }
@@ -462,7 +539,7 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
         }),
       )
     },
-    createArrayDimension: ({ name, derivation }) => {
+    createArrayDimension: ({ name, derivation: _derivation }) => {
       setState(
         produce((slice: ProjectSlice) => {
           const dt = slice.project.data.dataTypes.find((d) => d.name === name)
@@ -962,7 +1039,7 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
 
           const usedAddresses = new Set<string>()
           for (const g of device.modbusTcpConfig.ioGroups) {
-            for (const p of g.ioPoints) {
+            for (const p of g.ioPoints ?? []) {
               usedAddresses.add(p.iecLocation)
             }
           }
@@ -1001,7 +1078,7 @@ const createProjectSlice: StateCreator<ProjectSlice, [], [], ProjectSlice> = (se
           if (!device?.modbusTcpConfig) return
           const group = device.modbusTcpConfig.ioGroups.find((g) => g.id === groupId)
           if (!group) return
-          const point = group.ioPoints.find((p) => p.id === pointId)
+          const point = group.ioPoints?.find((p) => p.id === pointId)
           if (point) point.alias = alias
         }),
       )
diff --git a/src2/frontend/store/slices/project/types.ts b/src/frontend/store/slices/project/types.ts
similarity index 96%
rename from src2/frontend/store/slices/project/types.ts
rename to src/frontend/store/slices/project/types.ts
index 3bb7a138c..ff28ba59a 100644
--- a/src2/frontend/store/slices/project/types.ts
+++ b/src/frontend/store/slices/project/types.ts
@@ -3,14 +3,12 @@ import type {
   ModbusIOGroup,
   OpcUaNodeConfig,
   OpcUaSecurityProfile,
-  OpcUaServerConfig,
   OpcUaTrustedCertificate,
   OpcUaUser,
   PLCBody,
   PLCDataType,
   PLCFunction,
   PLCFunctionBlock,
-  PLCGlobalVariable,
   PLCInstance,
   PLCProgram,
   PLCProjectData,
@@ -108,9 +106,7 @@ export type ProjectActions = {
   applyPouSnapshot: (name: string, variables: PLCVariable[], body: PLCBody) => void
 
   // Variables
-  createVariable: (
-    dto: Omit<VariableDTO, 'data'> & { data: PLCVariable; rowToInsert?: number },
-  ) => ProjectResponse
+  createVariable: (dto: Omit<VariableDTO, 'data'> & { data: PLCVariable; rowToInsert?: number }) => ProjectResponse
   setPouVariables: (args: { pouName: string; variables: PLCVariable[] }) => ProjectResponse
   setGlobalVariables: (args: { variables: PLCVariable[] }) => ProjectResponse
   updateVariable: (args: {
@@ -146,11 +142,7 @@ export type ProjectActions = {
   deleteDatatype: (name: string) => void
   updateDatatype: (name: string, data?: PLCDataType) => void
   createArrayDimension: (args: { name: string; derivation: 'array' | 'enumerated' | 'structure' }) => void
-  rearrangeStructureVariables: (args: {
-    associatedDataType?: string
-    rowId: number
-    newIndex: number
-  }) => void
+  rearrangeStructureVariables: (args: { associatedDataType?: string; rowId: number; newIndex: number }) => void
   applyDatatypeSnapshot: (name: string, data: PLCDataType) => void
 
   // Tasks
diff --git a/src2/frontend/store/slices/project/utils.ts b/src/frontend/store/slices/project/utils.ts
similarity index 100%
rename from src2/frontend/store/slices/project/utils.ts
rename to src/frontend/store/slices/project/utils.ts
diff --git a/src2/frontend/store/slices/project/validation/type-change.ts b/src/frontend/store/slices/project/validation/type-change.ts
similarity index 90%
rename from src2/frontend/store/slices/project/validation/type-change.ts
rename to src/frontend/store/slices/project/validation/type-change.ts
index 463e731e2..999851226 100644
--- a/src2/frontend/store/slices/project/validation/type-change.ts
+++ b/src/frontend/store/slices/project/validation/type-change.ts
@@ -1,8 +1,9 @@
-import { validateVariableType } from '../../../../../backend/shared/validate-variable-type'
+import { Node } from '@xyflow/react'
+
+import { validateVariableType } from '../../../../utils/PLC/validate-variable-type'
+import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
 import { FBDFlowState } from '../../fbd'
 import { LadderFlowState } from '../../ladder'
-import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
-import { Node } from '@xyflow/react'
 
 export type NodeUsage = {
   pouName: string
@@ -59,20 +60,21 @@ export const validateTypeChange = (
   ladderFlows: LadderFlowState['ladderFlows'],
   fbdFlows: FBDFlowState['fbdFlows'],
   scope?: 'local' | 'global',
-  pous?: Array<{ data: { name: string; variables: PLCVariable[] } }>,
+  pous?: Array<{ name: string; interface?: { variables: PLCVariable[] } }>,
 ): TypeChangeValidationResult => {
   const affectedNodes: NodeUsage[] = []
   const warnings: string[] = []
 
   if (scope === 'global' && pous) {
     pous.forEach((pou) => {
-      const externalVars = pou.data.variables.filter(
+      const variables = pou.interface?.variables ?? []
+      const externalVars = variables.filter(
         (v) => v.class === 'external' && v.name.toLowerCase() === variableName.toLowerCase(),
       )
 
       if (externalVars.length > 0) {
         warnings.push(
-          `POU "${pou.data.name}" has ${externalVars.length} external variable(s) referencing this global variable. Their types will be updated automatically.`,
+          `POU "${pou.name}" has ${externalVars.length} external variable(s) referencing this global variable. Their types will be updated automatically.`,
         )
       }
     })
@@ -82,11 +84,11 @@ export const validateTypeChange = (
     scope === 'global' && pous
       ? pous
           .filter((pou) =>
-            pou.data.variables.some(
+            (pou.interface?.variables ?? []).some(
               (v) => v.class === 'external' && v.name.toLowerCase() === variableName.toLowerCase(),
             ),
           )
-          .map((pou) => pou.data.name)
+          .map((pou) => pou.name)
       : []
 
   const shouldCheckFlow = (flowName: string) => {
diff --git a/src/frontend/store/slices/project/validation/variables.ts b/src/frontend/store/slices/project/validation/variables.ts
new file mode 100644
index 000000000..bc9df1962
--- /dev/null
+++ b/src/frontend/store/slices/project/validation/variables.ts
@@ -0,0 +1,406 @@
+import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
+import {
+  BOOL_LOCATION_REGEX,
+  DWORD_LOCATION_REGEX,
+  LWORD_LOCATION_REGEX,
+  PLC_ADDRESS_PREFIX,
+  WORD_LOCATION_REGEX,
+} from '../../../../utils/PLC/address-constants'
+import type { ProjectResponse } from '../types'
+
+/**
+ * This function extracts the number at the end of a string.
+ */
+export const extractNumberAtEnd = (str: string): { number: number; string: string; length: number } => {
+  const match = str.match(/(\d+)$/)
+  const number = match ? parseInt(match[0], 10) : -1
+  return {
+    number,
+    string: match ? match[0] : '',
+    length: match ? match[0].length : 0,
+  }
+}
+
+/**
+ * This is a validation to check if the variable name already exists.
+ **/
+const checkIfVariableExists = (variables: PLCVariable[], name: string) => {
+  const nameAlreadyInUse = variables.some((variable) => variable.name.toLowerCase() === name.toLowerCase())
+  return nameAlreadyInUse
+}
+const checkIfGlobalVariableExists = (variables: PLCVariable[], name: string) => {
+  return variables.some((variable) => variable.name === name)
+}
+
+/**
+ * This is a validation to check if the value of the location is unique.
+ */
+const checkIfLocationExists = (variables: PLCVariable[], location: string) => {
+  return variables.some((variable) => variable.location === location)
+}
+
+/**
+ * This is a validation to check if the variable name is correct.
+ * CamelCase, PascalCase or SnakeCase and can not be empty.
+ **/
+const variableNameValidation = (variableName: string) => {
+  const regex =
+    /^([a-zA-Z0-9]+(?:[A-Z][a-z0-9]*)*)|([A-Z][a-z0-9]*(?:[A-Z][a-z0-9]*)*)|([a-zA-Z0-9]+(?:_[a-zA-Z0-9]+)*)$/
+  return regex.test(variableName)
+}
+
+/**
+ * This is a validation to check if the enumerated variable name is correct.
+ *
+ * The validation have to obey this rules:
+ * - CamelCase, PascalCase or SnakeCase
+ * - Can not be empty
+ * - Can not be a reserved word
+ */
+const enumeratedValidation = ({ value }: { value: string }) => {
+  const regex =
+    /^([a-zA-Z0-9]+(?:[A-Z][a-z0-9]*)*)|([A-Z][a-z0-9]*(?:[A-Z][a-z0-9]*)*)|([a-zA-Z0-9]+(?:_[a-zA-Z0-9]+)*)$/
+  if (value === '') {
+    return {
+      ok: false,
+      title: 'Invalid enumerated value',
+      message: `The enumerated value can not be empty.`,
+    }
+  }
+
+  if (!regex.test(value)) {
+    return {
+      ok: false,
+      title: 'Invalid enumerated value',
+      message: `The enumerated value "${value}" is invalid. Valid names: CamelCase, PascalCase or SnakeCase.`,
+    }
+  }
+  return { ok: true }
+}
+
+/**
+ * This is a validation to check if the array variable is correct.
+ *
+ * The validation have to obey this rules:
+ * 1. There CANNOT be space between the numeric values and dots
+ * 2. The second number MUST always be greater than the first
+ * 3. Only integer numbers can be used (shouldn't accept floating numbers or strings of any type)
+ */
+const validateArrayValue = (value: string) => {
+  const [left, right] = value.split('..').map(Number)
+  return Number.isInteger(left) && Number.isInteger(right) && left < right
+}
+const arrayValidation = ({ value }: { value: string }) => {
+  const regex = /^(\d+)\.\.(\d+)$/
+  if (value === '') {
+    return {
+      ok: false,
+      title: 'Invalid array value',
+      message: `The array value can not be empty.`,
+    }
+  }
+  if (!regex.test(value) || !validateArrayValue(value)) {
+    return {
+      ok: false,
+      title: 'Invalid array value',
+      message: `The array value "${value}" is invalid. Pattern: "LEFT_number..RIGHT_number" and RIGHT must be GREATER than LEFT. Example: 0..10.`,
+    }
+  }
+  return { ok: true }
+}
+
+/**
+ * This is a validation to check if the value of the location is valid.
+ */
+const variableLocationValidation = (variableLocation: string, variableType: string) => {
+  switch (variableType.toUpperCase()) {
+    case 'BOOL': {
+      const boolMatch = BOOL_LOCATION_REGEX.test(variableLocation) && variableLocation.split('.')[1] <= '7'
+      return boolMatch
+    }
+    case 'INT':
+    case 'UINT':
+    case 'WORD':
+      return WORD_LOCATION_REGEX.test(variableLocation)
+    case 'DINT':
+    case 'UDINT':
+    case 'REAL':
+    case 'DWORD':
+      return DWORD_LOCATION_REGEX.test(variableLocation)
+    case 'LINT':
+    case 'ULINT':
+    case 'LREAL':
+    case 'LWORD':
+      return LWORD_LOCATION_REGEX.test(variableLocation)
+    default:
+      return false
+  }
+}
+
+const variableLocationValidationErrorMessage = (variableType: string) => {
+  switch (variableType.toUpperCase()) {
+    case 'BOOL':
+      return 'Valid locations: %QX0.0..7, %IX0.0..7 (change the number to the desired location)'
+    case 'INT':
+    case 'UINT':
+    case 'WORD':
+      return 'Valid locations: %QW0, %IW0, %MW0 (change the number to the desired location)'
+    case 'DINT':
+    case 'UDINT':
+    case 'REAL':
+    case 'DWORD':
+      return 'Valid locations: %MD0 (change the number to the desired location)'
+    case 'LINT':
+    case 'ULINT':
+    case 'LREAL':
+    case 'LWORD':
+      return 'Valid locations: %ML0 (change the number to the desired location)'
+    default:
+      return ''
+  }
+}
+
+/**
+ * Check if the variable name exists and if it is needed to change the name of the variable.
+ * Returns an object containing:
+ * - ok: boolean (true if the variable exists, false otherwise)
+ * - name: string (the new name of the variable)
+ * - number: number (the biggest number at the end of the variable name)
+ */
+const checkVariableName = (variables: PLCVariable[], variableName: string) => {
+  // Check if there is a variable with the same name when removing the number at the end
+  const variableNameWithoutNumber = variableName.substring(
+    0,
+    variableName.length - extractNumberAtEnd(variableName).length,
+  )
+  const filteredVariables = variables.filter((variable: PLCVariable) =>
+    variable.name.toLowerCase().includes(variableNameWithoutNumber.toLowerCase()),
+  )
+
+  // If there is a variable with the same name, sort the variables by the number at the end and get the biggest number
+  const sortedVariables = filteredVariables.sort((a, b) => {
+    const numberA = extractNumberAtEnd(a.name).number
+    const numberB = extractNumberAtEnd(b.name).number
+
+    // Treat variables without numbers as having number -1 for sorting purposes
+    // This ensures they come before numbered variables
+    const sortNumberA = numberA === -1 ? -1 : numberA
+    const sortNumberB = numberB === -1 ? -1 : numberB
+
+    return sortNumberA - sortNumberB
+  })
+
+  // Get the biggest number at the end of the variable name
+  // If there is no number at the end of the variable name, return -1 (because the number at the end of the variable name is 0)
+  const biggestVariable =
+    sortedVariables.length > 0 ? extractNumberAtEnd(sortedVariables[sortedVariables.length - 1].name) : { number: -1 }
+
+  return {
+    ok: filteredVariables.length > 0,
+    name: variableNameWithoutNumber,
+    number: biggestVariable.number + 1,
+  }
+}
+
+/**
+ * This is a validation to check if it is needed changing the name of a variable at creation.
+ * If the variable exists change the variable name.
+ **/
+const createVariableValidation = (
+  variables: PLCVariable[],
+  variable: PLCVariable,
+): { name: string; location: string } => {
+  const { name: variableName, location: variableLocation } = variable
+  const response = { name: variableName, location: variableLocation }
+
+  if (checkIfVariableExists(variables, variableName)) {
+    const { name: variableNameWithoutNumber, number } = checkVariableName(variables, variableName)
+    response.name = `${variableNameWithoutNumber}${number}`
+  }
+
+  if (checkIfLocationExists(variables, variableLocation)) {
+    if (variableLocation === '') return response
+
+    const variableFound = variables.find((variable) => variable.location === variableLocation)
+    if (!variableFound) return response
+
+    switch (variable.type.value.toUpperCase()) {
+      case 'BOOL': {
+        const stringWithNoPrefix = variableFound.location
+          .replace(PLC_ADDRESS_PREFIX.BOOL_OUTPUT, '')
+          .replace(PLC_ADDRESS_PREFIX.BOOL_INPUT, '')
+        const position = parseInt(stringWithNoPrefix.split('.')[0])
+        const dotPosition = parseInt(stringWithNoPrefix.split('.')[1])
+
+        const prefix = variableFound?.location.startsWith(PLC_ADDRESS_PREFIX.BOOL_OUTPUT)
+          ? PLC_ADDRESS_PREFIX.BOOL_OUTPUT
+          : PLC_ADDRESS_PREFIX.BOOL_INPUT
+        response.location = `${prefix}${dotPosition === 7 ? position + 1 : position}.${dotPosition === 7 ? 0 : dotPosition + 1}`
+        break
+      }
+
+      case 'INT':
+      case 'UINT':
+      case 'WORD': {
+        const stringWithNoPrefix = variableFound.location
+          .replace(PLC_ADDRESS_PREFIX.WORD_OUTPUT, '')
+          .replace(PLC_ADDRESS_PREFIX.WORD_INPUT, '')
+          .replace(PLC_ADDRESS_PREFIX.WORD_MEMORY, '')
+        const position = parseInt(stringWithNoPrefix)
+        const prefix = variableFound?.location.startsWith(PLC_ADDRESS_PREFIX.WORD_OUTPUT)
+          ? PLC_ADDRESS_PREFIX.WORD_OUTPUT
+          : variableFound?.location.startsWith(PLC_ADDRESS_PREFIX.WORD_INPUT)
+            ? PLC_ADDRESS_PREFIX.WORD_INPUT
+            : PLC_ADDRESS_PREFIX.WORD_MEMORY
+        response.location = `${prefix}${position + 1}`
+        break
+      }
+
+      case 'DINT':
+      case 'UDINT':
+      case 'REAL':
+      case 'DWORD': {
+        const stringWithNoPrefix = variableFound.location.replace(PLC_ADDRESS_PREFIX.DWORD_MEMORY, '')
+        const position = parseInt(stringWithNoPrefix)
+        response.location = `${PLC_ADDRESS_PREFIX.DWORD_MEMORY}${position + 1}`
+        break
+      }
+
+      case 'LINT':
+      case 'ULINT':
+      case 'LREAL':
+      case 'LWORD': {
+        const stringWithNoPrefix = variableFound.location.replace(PLC_ADDRESS_PREFIX.LWORD_MEMORY, '')
+        const position = parseInt(stringWithNoPrefix)
+        response.location = `${PLC_ADDRESS_PREFIX.LWORD_MEMORY}${position + 1}`
+        break
+      }
+
+      default:
+        break
+    }
+  }
+  return response
+}
+
+const createGlobalVariableValidation = (variables: PLCVariable[], variableName: string) => {
+  if (checkIfGlobalVariableExists(variables, variableName)) {
+    const { name: variableNameWithoutNumber, number } = checkVariableName(variables, variableName)
+    return `${variableNameWithoutNumber}${number}`
+  }
+  return variableName
+}
+
+/**
+ * This is a validation to check the name of the variable at update.
+ * If the variable name is invalid, create a response.
+ * If the variable name already exists, create or change a response.
+ **/
+const updateVariableValidation = (
+  variables: PLCVariable[],
+  dataToBeUpdated: Partial<PLCVariable>,
+  variableToUpdate: PLCVariable,
+) => {
+  let response: ProjectResponse = { ok: true }
+
+  if (dataToBeUpdated.class) response.data = { class: dataToBeUpdated.class }
+
+  if (dataToBeUpdated.name || dataToBeUpdated.name === '') {
+    const { name } = dataToBeUpdated
+    if (name === '') {
+      response = {
+        ok: false,
+        title: 'Variable name is empty.',
+        message: 'Please make sure that the name is not empty.',
+      }
+      return response
+    }
+
+    if (checkIfVariableExists(variables, name)) {
+      response = {
+        ok: false,
+        title: 'Variable already exists',
+        message: 'Please make sure that the name is unique.',
+      }
+      return response
+    }
+
+    if (!variableNameValidation(name)) {
+      response = {
+        ok: false,
+        title: 'Variable name is invalid.',
+        message: `Please make sure that the name is valid. Valid names: CamelCase, PascalCase or SnakeCase.`,
+      }
+      return response
+    }
+  }
+
+  if (dataToBeUpdated.location) {
+    const { location } = dataToBeUpdated
+    if (checkIfLocationExists(variables, location)) {
+      response = {
+        ok: false,
+        title: 'Location already exists',
+        message: 'Please make sure that the location is unique.',
+      }
+      return response
+    }
+
+    if (!variableLocationValidation(location, variableToUpdate.type.value)) {
+      response = {
+        ok: false,
+        title: 'Location is invalid.',
+        message: `Please make sure that the location is valid.\n${variableLocationValidationErrorMessage(variableToUpdate.type.value)}`,
+      }
+      return response
+    }
+  }
+
+  if (dataToBeUpdated.type) {
+    if (!variableLocationValidation(variableToUpdate.location, dataToBeUpdated.type.value)) {
+      response.data = { ...(response.data ? response.data : {}), location: '' }
+    }
+    if (dataToBeUpdated.type.definition === 'derived') {
+      response.data = { ...(response.data ? response.data : {}), location: '', initialValue: '', class: 'local' }
+    }
+  }
+
+  return response
+}
+
+const updateGlobalVariableValidation = (variables: PLCVariable[], dataToBeUpdated: Partial<PLCVariable>) => {
+  let response: ProjectResponse = { ok: true }
+
+  if (dataToBeUpdated.name || dataToBeUpdated.name === '') {
+    const { name } = dataToBeUpdated
+    if (name === '') {
+      response = {
+        ok: false,
+        title: 'Global Variable name is empty.',
+        message: 'Please make sure that the name is not empty.',
+      }
+      return response
+    }
+
+    if (checkIfGlobalVariableExists(variables, name)) {
+      response = {
+        ok: false,
+        title: 'Global Variable already exists',
+        message: 'Please make sure that the name is unique.',
+      }
+      return response
+    }
+  }
+
+  return response
+}
+
+export {
+  arrayValidation,
+  checkVariableName,
+  createGlobalVariableValidation,
+  createVariableValidation,
+  enumeratedValidation,
+  updateGlobalVariableValidation,
+  updateVariableValidation,
+}
diff --git a/src/renderer/store/slices/react-flow/index.ts b/src/frontend/store/slices/react-flow/index.ts
similarity index 100%
rename from src/renderer/store/slices/react-flow/index.ts
rename to src/frontend/store/slices/react-flow/index.ts
diff --git a/src/renderer/store/slices/react-flow/types.ts b/src/frontend/store/slices/react-flow/types.ts
similarity index 100%
rename from src/renderer/store/slices/react-flow/types.ts
rename to src/frontend/store/slices/react-flow/types.ts
diff --git a/src2/frontend/store/slices/search/index.ts b/src/frontend/store/slices/search/index.ts
similarity index 100%
rename from src2/frontend/store/slices/search/index.ts
rename to src/frontend/store/slices/search/index.ts
diff --git a/src2/frontend/store/slices/search/slice.ts b/src/frontend/store/slices/search/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/search/slice.ts
rename to src/frontend/store/slices/search/slice.ts
diff --git a/src2/frontend/store/slices/search/types.ts b/src/frontend/store/slices/search/types.ts
similarity index 76%
rename from src2/frontend/store/slices/search/types.ts
rename to src/frontend/store/slices/search/types.ts
index 89c2e5c60..eeff46e18 100644
--- a/src2/frontend/store/slices/search/types.ts
+++ b/src/frontend/store/slices/search/types.ts
@@ -2,13 +2,16 @@ export type Project = {
   searchQuery: string
   projectName: string
   functions: {
-    pous: Record<'program' | 'function' | 'function-block', Array<{
-      name: string
-      language: 'ld' | 'sfc' | 'fbd' | 'il' | 'st' | 'python' | 'cpp'
-      pouType: 'program' | 'function' | 'function-block'
-      body: string
-      variable: string | null
-    }>>
+    pous: Record<
+      'program' | 'function' | 'function-block',
+      Array<{
+        name: string
+        language: 'ld' | 'sfc' | 'fbd' | 'il' | 'st' | 'python' | 'cpp'
+        pouType: 'program' | 'function' | 'function-block'
+        body: string
+        variable: string | null
+      }>
+    >
     dataTypes: Array<{
       name: string
       type: 'array' | 'structure' | 'enumerated'
diff --git a/src2/frontend/store/slices/search/utils.ts b/src/frontend/store/slices/search/utils.ts
similarity index 100%
rename from src2/frontend/store/slices/search/utils.ts
rename to src/frontend/store/slices/search/utils.ts
diff --git a/src2/frontend/store/slices/shared/index.ts b/src/frontend/store/slices/shared/index.ts
similarity index 100%
rename from src2/frontend/store/slices/shared/index.ts
rename to src/frontend/store/slices/shared/index.ts
index a2d7402d4..e3dc35ca9 100644
--- a/src2/frontend/store/slices/shared/index.ts
+++ b/src/frontend/store/slices/shared/index.ts
@@ -1,13 +1,4 @@
 export { createSharedSlice } from './slice'
-export {
-  createDatatypeObject,
-  createEditorObjectForDatatype,
-  createEditorObjectForPou,
-  createEditorObjectForRemoteDevice,
-  createEditorObjectForServer,
-  createPouObject,
-  createTabObject,
-} from './utils'
 export type {
   DatatypeActions,
   PouActions,
@@ -21,3 +12,12 @@ export type {
   SharedWorkspaceActions,
   SnapshotActions,
 } from './types'
+export {
+  createDatatypeObject,
+  createEditorObjectForDatatype,
+  createEditorObjectForPou,
+  createEditorObjectForRemoteDevice,
+  createEditorObjectForServer,
+  createPouObject,
+  createTabObject,
+} from './utils'
diff --git a/src/frontend/store/slices/shared/slice.ts b/src/frontend/store/slices/shared/slice.ts
new file mode 100644
index 000000000..298d615a6
--- /dev/null
+++ b/src/frontend/store/slices/shared/slice.ts
@@ -0,0 +1,681 @@
+import { produce } from 'immer'
+import { StateCreator } from 'zustand'
+
+import type { PLCVariable } from '../../../../middleware/shared/ports/types'
+import { parseIecStringToVariables } from '../../../utils/generate-iec-string-to-variables'
+import { generateIecVariablesToString } from '../../../utils/generate-iec-variables-to-string'
+import { syncNodesWithVariables, syncNodesWithVariablesFBD } from '../../../utils/graphical/sync-nodes-with-variables'
+import { toast } from '../../../utils/toast'
+import type { FBDFlowType } from '../fbd'
+import type { FileSliceDataObject } from '../file'
+import type { HistorySnapshot } from '../history'
+import type { LadderFlowType } from '../ladder'
+import type { TabsProps } from '../tabs'
+import { CreateEditorObjectFromTab } from '../tabs/utils'
+import type { SharedRootState, SharedSlice } from './types'
+import { createDatatypeObject, createEditorObjectForDatatype, createEditorObjectForPou, createPouObject } from './utils'
+
+const MAX_HISTORY_SIZE = 50
+
+function deleteElement(
+  state: SharedRootState,
+  name: string,
+  deleteFromProject: (name: string) => void,
+  afterDelete?: (name: string) => void,
+) {
+  deleteFromProject(name)
+  state.editorActions.removeModel(name)
+  state.fileActions.removeFile({ name })
+  state.tabsActions.removeTab(name)
+  afterDelete?.(name)
+
+  const currentEditor = state.editor
+  if (currentEditor.type !== 'available' && currentEditor.meta.name === name) {
+    state.editorActions.clearEditor()
+  }
+  return { ok: true as const }
+}
+
+function renameElement(
+  state: SharedRootState,
+  oldName: string,
+  newName: string,
+  updateInProject: (oldName: string, newName: string) => { ok: boolean; message?: string } | void,
+  afterRename?: (oldName: string, newName: string) => void,
+) {
+  const result = updateInProject(oldName, newName)
+  if (result && !result.ok) return { ok: false as const, message: result.message }
+
+  state.editorActions.updateEditorName(oldName, newName)
+  state.fileActions.updateFile({ name: oldName, newName })
+  state.tabsActions.updateTabName(oldName, newName)
+  afterRename?.(oldName, newName)
+
+  return { ok: true as const }
+}
+
+const createSharedSlice: StateCreator<SharedRootState, [], [], SharedSlice> = (setState, getState) => ({
+  undoRedo: {},
+
+  pouActions: {
+    create: ({ type, name, language }) => {
+      const state = getState()
+      const existing = state.project.data.pous.find((p) => p.name === name)
+      if (existing) return { ok: false, message: 'POU already exists' }
+
+      const pouDto = createPouObject({ type, name, language })
+      const result = state.projectActions.createPou(pouDto)
+      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
+      if (!result.ok) return { ok: false, message: result.message }
+
+      const editorModel = createEditorObjectForPou(name, type, language)
+      state.editorActions.addModel(editorModel)
+
+      state.fileActions.addFile({ name, type, filePath: name, isNew: true })
+
+      state.tabsActions.updateTabs({
+        name,
+        elementType: { type, language },
+      })
+      state.tabsActions.setSelectedTab(name)
+      state.editorActions.setEditor(editorModel)
+
+      state.libraryActions.addLibrary(name, type === 'program' ? 'function' : type)
+
+      return { ok: true }
+    },
+
+    deleteRequest: (name) => {
+      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'pou' })
+    },
+
+    delete: (name) =>
+      deleteElement(
+        getState(),
+        name,
+        (n) => getState().projectActions.deletePou(n),
+        (n) => getState().libraryActions.removeUserLibrary(n),
+      ),
+
+    rename: (oldName, newName) => {
+      const state = getState()
+      const existing = state.project.data.pous.find((p) => p.name === newName)
+      if (existing) return { ok: false, message: 'POU name already exists' }
+
+      return renameElement(
+        state,
+        oldName,
+        newName,
+        (o, n) => {
+          state.projectActions.updatePouName(o, n)
+        },
+        (o, n) => state.libraryActions.updateLibraryName(o, n),
+      )
+    },
+
+    duplicate: (sourceName, newName) => {
+      const state = getState()
+      const sourcePou = state.project.data.pous.find((p) => p.name === sourceName)
+      if (!sourcePou) return { ok: false, message: 'Source POU not found' }
+
+      const existing = state.project.data.pous.find((p) => p.name === newName)
+      if (existing) return { ok: false, message: 'POU name already exists' }
+
+      // Create a copy of the POU with the new name
+      const language = sourcePou.body.language as 'il' | 'st' | 'ld' | 'sfc' | 'fbd' | 'python' | 'cpp'
+      const pouDto = createPouObject({ type: sourcePou.pouType, name: newName, language })
+
+      // Copy the source POU's content into the new DTO
+      pouDto.data.body = { ...sourcePou.body }
+      pouDto.data.variables = sourcePou.interface?.variables ? [...sourcePou.interface.variables] : []
+      pouDto.data.documentation = sourcePou.documentation ?? ''
+      if (sourcePou.pouType === 'function' && 'returnType' in pouDto.data) {
+        pouDto.data.returnType = sourcePou.interface?.returnType ?? 'BOOL'
+      }
+
+      const result = state.projectActions.createPou(pouDto)
+      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
+      if (!result.ok) return { ok: false, message: result.message }
+
+      const editorModel = createEditorObjectForPou(newName, sourcePou.pouType, language)
+      state.editorActions.addModel(editorModel)
+      state.fileActions.addFile({ name: newName, type: sourcePou.pouType, filePath: newName, isNew: true })
+
+      return { ok: true }
+    },
+  },
+
+  datatypeActions: {
+    create: ({ name, derivation }) => {
+      const state = getState()
+      const existing = state.project.data.dataTypes.find((d) => d.name === name)
+      if (existing) return { ok: false, message: 'Data type already exists' }
+
+      const datatype = createDatatypeObject({ name, derivation })
+      const result = state.projectActions.createDatatype({ data: datatype })
+      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
+      if (!result.ok) return { ok: false, message: result.message }
+
+      const editorModel = createEditorObjectForDatatype(name, derivation)
+      state.editorActions.addModel(editorModel)
+      state.fileActions.addFile({ name, type: 'data-type', filePath: name, isNew: true })
+
+      state.tabsActions.updateTabs({
+        name,
+        elementType: { type: 'data-type', derivation },
+      })
+      state.tabsActions.setSelectedTab(name)
+      state.editorActions.setEditor(editorModel)
+
+      return { ok: true }
+    },
+
+    deleteRequest: (name) => {
+      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'datatype' })
+    },
+
+    delete: (name) => deleteElement(getState(), name, (n) => getState().projectActions.deleteDatatype(n)),
+
+    rename: (oldName, newName) => {
+      const state = getState()
+      const existing = state.project.data.dataTypes.find((d) => d.name === newName)
+      if (existing) return { ok: false, message: 'Data type name already exists' }
+
+      const datatype = state.project.data.dataTypes.find((d) => d.name === oldName)
+      if (!datatype) return { ok: false, message: 'Data type not found' }
+
+      const updatedDatatype = { ...datatype, name: newName }
+
+      return renameElement(state, oldName, newName, () => {
+        state.projectActions.updateDatatype(oldName, updatedDatatype)
+      })
+    },
+
+    duplicate: (sourceName, newName) => {
+      const state = getState()
+      const source = state.project.data.dataTypes.find((d) => d.name === sourceName)
+      if (!source) return { ok: false, message: 'Data type not found' }
+
+      const existing = state.project.data.dataTypes.find((d) => d.name === newName)
+      if (existing) return { ok: false, message: 'Data type name already exists' }
+
+      const copy = { ...source, name: newName }
+      const result = state.projectActions.createDatatype({ data: copy })
+      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
+      if (!result.ok) return { ok: false, message: result.message }
+
+      const editorModel = createEditorObjectForDatatype(newName, source.derivation)
+      state.editorActions.addModel(editorModel)
+      state.fileActions.addFile({ name: newName, type: 'data-type', filePath: newName, isNew: true })
+
+      return { ok: true }
+    },
+  },
+
+  serverActions: {
+    deleteRequest: (name) => {
+      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'server' })
+    },
+
+    delete: (name) => deleteElement(getState(), name, (n) => getState().projectActions.deleteServer(n)),
+
+    rename: (oldName, newName) =>
+      renameElement(getState(), oldName, newName, (o, n) => getState().projectActions.updateServerName(o, n)),
+  },
+
+  remoteDeviceActions: {
+    deleteRequest: (name) => {
+      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'remote-device' })
+    },
+
+    delete: (name) => deleteElement(getState(), name, (n) => getState().projectActions.deleteRemoteDevice(n)),
+
+    rename: (oldName, newName) =>
+      renameElement(getState(), oldName, newName, (o, n) => getState().projectActions.updateRemoteDeviceName(o, n)),
+  },
+
+  sharedWorkspaceActions: {
+    handleFileAndWorkspaceSavedState: (name) => {
+      const { file } = getState().fileActions.getFile({ name })
+      if (!file) {
+        console.warn(`File with name ${name} does not exist.`)
+        return
+      }
+
+      if (file.saved) {
+        getState().fileActions.updateFile({ name, saved: false })
+      }
+
+      if (getState().workspace.editingState !== 'unsaved') {
+        getState().workspaceActions.setEditingState('unsaved')
+      }
+    },
+
+    closeFile: (name) => {
+      // Check if file has unsaved changes
+      const isSaved = getState().fileActions.getSavedState({ name })
+
+      if (!isSaved) {
+        // File has unsaved changes - show save prompt modal
+        getState().modalActions.openModal('save-changes-file', { fileName: name })
+        return { success: false }
+      }
+
+      // File is saved, proceed with close
+      return getState().sharedWorkspaceActions.forceCloseFile(name)
+    },
+
+    forceCloseFile: (name) => {
+      getState().tabsActions.removeTab(name)
+
+      const filteredTabs = getState().tabs
+      const nextTab = filteredTabs[filteredTabs.length - 1]
+      if (!nextTab) {
+        getState().editorActions.setEditor({ type: 'available', meta: { name: '' } })
+        getState().tabsActions.setSelectedTab('')
+        getState().workspaceActions.setSelectedProjectTreeLeaf({ label: '', type: null })
+        return { success: true }
+      }
+
+      const editor = getState().editorActions.getEditorFromEditors(nextTab.name) || CreateEditorObjectFromTab(nextTab)
+      getState().editorActions.setEditor(editor)
+      getState().tabsActions.setSelectedTab(nextTab.name)
+      getState().workspaceActions.setSelectedProjectTreeLeaf({
+        label: nextTab.name,
+        type: nextTab.elementType.type,
+      })
+
+      return { success: true }
+    },
+
+    closeProject: () => {
+      const editingState = getState().workspace.editingState
+      const isFilesSaved = getState().fileActions.checkIfAllFilesAreSaved()
+
+      if (!isFilesSaved || editingState === 'unsaved') {
+        getState().modalActions.openModal('save-changes-project', {
+          validationContext: 'close-project',
+        })
+        return
+      }
+      getState().sharedWorkspaceActions.clearStatesOnCloseProject()
+    },
+
+    clearStatesOnCloseProject: () => {
+      getState().editorActions.clearEditor()
+      getState().tabsActions.clearTabs()
+      getState().libraryActions.clearUserLibraries()
+      getState().fbdFlowActions.clearFBDFlows()
+      getState().ladderFlowActions.clearLadderFlows()
+      getState().projectActions.clearProjects()
+      getState().deviceActions.clearDeviceDefinitions()
+      getState().workspaceActions.clearWorkspace()
+      getState().fileActions.clearFiles()
+      getState().consoleActions.clearLogs()
+      getState().historyActions.clearHistory()
+      getState().searchActions.clearSearch()
+      getState().modalActions.closeModal()
+    },
+
+    handleOpenProjectResponse: (data) => {
+      getState().sharedWorkspaceActions.clearStatesOnCloseProject()
+      getState().workspaceActions.setEditingState('saved')
+
+      // Set project data (setting meta.path triggers navigation from start to workspace)
+      getState().projectActions.setProject({
+        meta: data.meta,
+        data: data.projectData,
+      })
+
+      // Add ladder and FBD flows for graphical POUs
+      const pous = data.projectData.pous
+      pous.forEach((pou) => {
+        if (pou.body.language === 'ld') {
+          getState().ladderFlowActions.addLadderFlow(pou.body.value as LadderFlowType)
+        }
+        if (pou.body.language === 'fbd') {
+          getState().fbdFlowActions.addFBDFlow(pou.body.value as FBDFlowType)
+        }
+      })
+
+      // Register user-defined functions/function-blocks in the library
+      pous.forEach((pou) => {
+        if (pou.pouType !== 'program') {
+          getState().libraryActions.addLibrary(pou.name, pou.pouType)
+        }
+      })
+
+      // Reclassify ALL POUs' variables with full context.
+      // The text parser can't determine type definitions accurately since it doesn't have
+      // the full project context. Re-parse with pous, dataTypes, and libraries to correctly
+      // classify FB instances as 'derived' vs structs as 'user-data-type'.
+      {
+        const reclassState = getState()
+        const {
+          project: {
+            data: { dataTypes: reclassDataTypes },
+          },
+          libraries: reclassLibraries,
+        } = reclassState
+
+        pous.forEach((pou) => {
+          try {
+            const vars = pou.interface?.variables ?? []
+            const iecString = generateIecVariablesToString(vars)
+            const reparsedVariables = parseIecStringToVariables(iecString, pous, reclassDataTypes, reclassLibraries)
+            getState().projectActions.setPouVariables({
+              pouName: pou.name,
+              variables: reparsedVariables,
+            })
+          } catch (err) {
+            console.error(`[Reclassify] Failed to reclassify variables for POU "${pou.name}":`, err)
+          }
+        })
+      }
+
+      // Sync graphical POU nodes with reclassified variables
+      {
+        const ladderPous = pous.filter((pou) => pou.body.language === 'ld')
+        const fbdPous = pous.filter((pou) => pou.body.language === 'fbd')
+        const graphicalPous = [...ladderPous, ...fbdPous]
+        if (graphicalPous.length) {
+          const freshState = getState()
+          const freshLadderFlows = freshState.ladderFlows
+          const freshFBDFlows = freshState.fbdFlows
+          const freshPous = freshState.project.data.pous
+          const updateLadderNode = freshState.ladderFlowActions.updateNode
+          const updateFBDNode = freshState.fbdFlowActions.updateNode
+
+          try {
+            ladderPous.forEach((pou) => {
+              const freshPou = freshPous.find((p) => p.name === pou.name)
+              if (freshPou) {
+                const pouFlow = freshLadderFlows.filter((flow) => flow.name === pou.name)
+                if (pouFlow.length > 0) {
+                  syncNodesWithVariables(freshPou.interface?.variables ?? [], pouFlow, updateLadderNode)
+                }
+              }
+            })
+
+            fbdPous.forEach((pou) => {
+              const freshPou = freshPous.find((p) => p.name === pou.name)
+              if (freshPou) {
+                const pouFlow = freshFBDFlows.filter((flow) => flow.name === pou.name)
+                if (pouFlow.length > 0) {
+                  syncNodesWithVariablesFBD(freshPou.interface?.variables ?? [], pouFlow, updateFBDNode)
+                }
+              }
+            })
+          } catch (err) {
+            console.error('[SYNC] Error during node sync:', err)
+          }
+        }
+      }
+
+      // Set device definitions
+      if (data.deviceConfiguration || data.devicePinMapping) {
+        getState().deviceActions.setDeviceDefinitions({
+          configuration: data.deviceConfiguration,
+          pinMapping: data.devicePinMapping,
+        })
+      }
+
+      // Restore debug flags from debugVariables
+      // Since POU variables are saved as text files, debug flags are stored separately in project.json
+      const debugVariables = data.projectData.debugVariables
+      if (debugVariables) {
+        // Restore global variable debug flags
+        if (debugVariables.global && debugVariables.global.length > 0) {
+          const globalVars = getState().project.data.configurations.resource.globalVariables
+          debugVariables.global.forEach((varName) => {
+            const varIndex = globalVars.findIndex((v) => v.name === varName)
+            if (varIndex !== -1) {
+              getState().projectActions.updateVariable({
+                scope: 'global',
+                rowId: varIndex,
+                data: { debug: true },
+              })
+            }
+          })
+        }
+
+        // Restore POU variable debug flags
+        if (debugVariables.pous) {
+          for (const [pouName, varNames] of Object.entries(debugVariables.pous)) {
+            const pou = getState().project.data.pous.find((p) => p.name === pouName)
+            if (pou) {
+              const pouVars = pou.interface?.variables ?? []
+              varNames.forEach((varName) => {
+                const varIndex = pouVars.findIndex((v) => v.name === varName)
+                if (varIndex !== -1) {
+                  getState().projectActions.updateVariable({
+                    scope: 'local',
+                    associatedPou: pouName,
+                    rowId: varIndex,
+                    data: { debug: true },
+                  })
+                }
+              })
+            }
+          }
+        }
+      }
+
+      // Register files for save-state tracking
+      const files: FileSliceDataObject = {}
+      pous.forEach((pou) => {
+        files[pou.name] = { type: pou.pouType, filePath: pou.name, saved: true }
+      })
+      data.projectData.dataTypes.forEach((dt) => {
+        files[dt.name] = { type: 'data-type', filePath: dt.name, saved: true }
+      })
+      const servers = data.projectData.servers
+      if (servers) {
+        servers.forEach((s) => {
+          files[s.name] = { type: 'server', filePath: s.name, saved: true }
+        })
+      }
+      const remoteDevices = data.projectData.remoteDevices
+      if (remoteDevices) {
+        remoteDevices.forEach((d) => {
+          files[d.name] = { type: 'remote-device', filePath: d.name, saved: true }
+        })
+      }
+      files['Resource'] = { type: 'resource', filePath: 'Resource', saved: true }
+      files['Configuration'] = { type: 'device', filePath: 'Configuration', saved: true }
+      getState().fileActions.setFiles({ files })
+
+      // Open the main POU tab (if present)
+      const mainPou = pous.find((p) => p.name === 'main' && p.pouType === 'program')
+      if (mainPou) {
+        const language = mainPou.body.language as 'il' | 'st' | 'ld' | 'sfc' | 'fbd' | 'python' | 'cpp'
+        const tabToBeCreated: TabsProps = {
+          name: mainPou.name,
+          path: `/data/pous/program/${mainPou.name}`,
+          elementType: { type: 'program', language },
+        }
+        const model = CreateEditorObjectFromTab(tabToBeCreated)
+        getState().editorActions.addModel(model)
+        getState().editorActions.setEditor(model)
+        getState().tabsActions.updateTabs(tabToBeCreated)
+        getState().tabsActions.setSelectedTab(mainPou.name)
+        getState().workspaceActions.setSelectedProjectTreeLeaf({ label: mainPou.name, type: 'program' })
+      }
+
+      // Reset all graphical flow updated flags at the very end of project open.
+      // Various operations during load (syncNodesWithVariables, debug flag restoration,
+      // tab opening) call updateNode which sets flow.updated = true as a side effect.
+      // Since these are internal syncs (not user edits), reset all flags.
+      for (const flow of getState().ladderFlows) {
+        getState().ladderFlowActions.setFlowUpdated({ editorName: flow.name, updated: false })
+      }
+      for (const flow of getState().fbdFlows) {
+        getState().fbdFlowActions.setFlowUpdated({ editorName: flow.name, updated: false })
+      }
+
+      toast({
+        title: 'Project opened!',
+        description: 'Your project was opened, and loaded.',
+        variant: 'default',
+      })
+    },
+  },
+
+  snapshotActions: {
+    pushToHistory: (pouName, snapshot) => {
+      setState(
+        produce((state: SharedRootState) => {
+          if (!state.undoRedo[pouName]) {
+            state.undoRedo[pouName] = { past: [], future: [], savedAtDepth: 0 }
+          }
+          const history = state.undoRedo[pouName]
+          // If the saved state was in the future (ahead of current), it's being discarded
+          if (history.savedAtDepth !== null && history.savedAtDepth > history.past.length) {
+            history.savedAtDepth = null
+          }
+          history.past.push(snapshot)
+          if (history.past.length > MAX_HISTORY_SIZE) {
+            history.past.shift()
+            // Adjust savedAtDepth since we shifted the stack
+            if (history.savedAtDepth !== null) {
+              history.savedAtDepth--
+              if (history.savedAtDepth < 0) history.savedAtDepth = null
+            }
+          }
+          history.future = []
+        }),
+      )
+    },
+
+    markSaved: (pouName) => {
+      setState(
+        produce((state: SharedRootState) => {
+          const history = state.undoRedo[pouName]
+          if (history) {
+            history.savedAtDepth = history.past.length
+          }
+        }),
+      )
+    },
+
+    markAllSaved: () => {
+      setState(
+        produce((state: SharedRootState) => {
+          for (const history of Object.values(state.undoRedo)) {
+            history.savedAtDepth = history.past.length
+          }
+        }),
+      )
+    },
+
+    undo: (pouName) => {
+      const state = getState()
+      const history = state.undoRedo[pouName]
+      if (!history || history.past.length === 0) return
+
+      const snapshot = history.past[history.past.length - 1]
+      const pou = state.project.data.pous.find((p) => p.name === pouName)
+      if (!pou) return
+
+      // Save current state to future (deep copy to avoid mutation)
+      const ladderFlow = state.ladderFlows.find((f) => f.name === pouName)
+      const fbdFlow = state.fbdFlows.find((f) => f.name === pouName)
+      const currentSnapshot: HistorySnapshot = {
+        variables: JSON.parse(JSON.stringify(pou.interface?.variables ?? [])) as PLCVariable[],
+        body: JSON.parse(JSON.stringify(pou.body.value)) as unknown,
+        ladderFlow: ladderFlow ? (JSON.parse(JSON.stringify(ladderFlow)) as LadderFlowType) : undefined,
+        fbdFlow: fbdFlow ? (JSON.parse(JSON.stringify(fbdFlow)) as FBDFlowType) : undefined,
+        globalVariables: JSON.parse(
+          JSON.stringify(state.project.data.configurations.resource.globalVariables),
+        ) as PLCVariable[],
+      }
+
+      setState(
+        produce((s: SharedRootState) => {
+          const h = s.undoRedo[pouName]
+          /* istanbul ignore next -- defensive: history verified above before produce */
+          if (!h) return
+          h.past.pop()
+          h.future.push(currentSnapshot)
+        }),
+      )
+
+      state.projectActions.applyPouSnapshot(pouName, snapshot.variables, {
+        language: pou.body.language,
+        value: snapshot.body,
+      })
+      if (snapshot.globalVariables) {
+        state.projectActions.setGlobalVariables({ variables: snapshot.globalVariables })
+      }
+      // Restore graphical flow state (nodes, edges, positions)
+      if (snapshot.ladderFlow) {
+        state.ladderFlowActions.applyLadderFlowSnapshot({ editorName: pouName, snapshot: snapshot.ladderFlow })
+      }
+      if (snapshot.fbdFlow) {
+        state.fbdFlowActions.applyFBDFlowSnapshot({ editorName: pouName, snapshot: snapshot.fbdFlow })
+      }
+
+      // Check if we've returned to the saved state
+      const afterUndo = getState().undoRedo[pouName]
+      if (afterUndo?.savedAtDepth !== null && afterUndo?.savedAtDepth === afterUndo?.past.length) {
+        getState().fileActions.updateFile({ name: pouName, saved: true })
+      }
+    },
+
+    redo: (pouName) => {
+      const state = getState()
+      const history = state.undoRedo[pouName]
+      if (!history || history.future.length === 0) return
+
+      const snapshot = history.future[history.future.length - 1]
+      const pou = state.project.data.pous.find((p) => p.name === pouName)
+      if (!pou) return
+
+      // Save current state to past (deep copy to avoid mutation)
+      const ladderFlow = state.ladderFlows.find((f) => f.name === pouName)
+      const fbdFlow = state.fbdFlows.find((f) => f.name === pouName)
+      const currentSnapshot: HistorySnapshot = {
+        variables: JSON.parse(JSON.stringify(pou.interface?.variables ?? [])) as PLCVariable[],
+        body: JSON.parse(JSON.stringify(pou.body.value)) as unknown,
+        ladderFlow: ladderFlow ? (JSON.parse(JSON.stringify(ladderFlow)) as LadderFlowType) : undefined,
+        fbdFlow: fbdFlow ? (JSON.parse(JSON.stringify(fbdFlow)) as FBDFlowType) : undefined,
+        globalVariables: JSON.parse(
+          JSON.stringify(state.project.data.configurations.resource.globalVariables),
+        ) as PLCVariable[],
+      }
+
+      setState(
+        produce((s: SharedRootState) => {
+          const h = s.undoRedo[pouName]
+          /* istanbul ignore next -- defensive: history verified above before produce */
+          if (!h) return
+          h.future.pop()
+          h.past.push(currentSnapshot)
+        }),
+      )
+
+      state.projectActions.applyPouSnapshot(pouName, snapshot.variables, {
+        language: pou.body.language,
+        value: snapshot.body,
+      })
+      if (snapshot.globalVariables) {
+        state.projectActions.setGlobalVariables({ variables: snapshot.globalVariables })
+      }
+      // Restore graphical flow state (nodes, edges, positions)
+      if (snapshot.ladderFlow) {
+        state.ladderFlowActions.applyLadderFlowSnapshot({ editorName: pouName, snapshot: snapshot.ladderFlow })
+      }
+      if (snapshot.fbdFlow) {
+        state.fbdFlowActions.applyFBDFlowSnapshot({ editorName: pouName, snapshot: snapshot.fbdFlow })
+      }
+
+      // Check if we've returned to the saved state
+      const afterRedo = getState().undoRedo[pouName]
+      if (afterRedo?.savedAtDepth !== null && afterRedo?.savedAtDepth === afterRedo?.past.length) {
+        getState().fileActions.updateFile({ name: pouName, saved: true })
+      }
+    },
+  },
+})
+
+export { createSharedSlice }
diff --git a/src2/frontend/store/slices/shared/types.ts b/src/frontend/store/slices/shared/types.ts
similarity index 82%
rename from src2/frontend/store/slices/shared/types.ts
rename to src/frontend/store/slices/shared/types.ts
index af68741f4..eda967256 100644
--- a/src2/frontend/store/slices/shared/types.ts
+++ b/src/frontend/store/slices/shared/types.ts
@@ -1,4 +1,10 @@
-import type { PLCBody, PLCDataType, PLCVariable } from '../../../../middleware/shared/ports/types'
+import type {
+  DeviceConfiguration,
+  DevicePin,
+  PLCProjectData,
+  PLCVariable,
+  ProjectMeta,
+} from '../../../../middleware/shared/ports/types'
 import type { ConsoleSlice } from '../console'
 import type { DeviceSlice } from '../device'
 import type { EditorSlice } from '../editor'
@@ -74,10 +80,7 @@ export type PouActions = {
 }
 
 export type DatatypeActions = {
-  create: (args: {
-    name: string
-    derivation: 'array' | 'enumerated' | 'structure'
-  }) => SharedResponse
+  create: (args: { name: string; derivation: 'array' | 'enumerated' | 'structure' }) => SharedResponse
   deleteRequest: (name: string) => void
   delete: (name: string) => SharedResponse
   rename: (oldName: string, newName: string) => SharedResponse
@@ -98,13 +101,24 @@ export type RemoteDeviceActions = {
 
 export type SnapshotActions = {
   pushToHistory: (pouName: string, snapshot: PouHistorySnapshot) => void
+  markSaved: (pouName: string) => void
+  markAllSaved: () => void
   undo: (pouName: string) => void
   redo: (pouName: string) => void
 }
 
+export type OpenProjectResponseData = {
+  meta: ProjectMeta
+  projectData: PLCProjectData
+  deviceConfiguration?: DeviceConfiguration
+  devicePinMapping?: DevicePin[]
+}
+
 export type SharedWorkspaceActions = {
   /** Mark a file as unsaved and set workspace editingState to 'unsaved'. */
   handleFileAndWorkspaceSavedState: (name: string) => void
+  /** Check save state, show modal if unsaved, or close the file. */
+  closeFile: (name: string) => { success: boolean }
   /** Remove a tab and select the next one. Does NOT check save state. */
   forceCloseFile: (name: string) => { success: boolean }
   /**
@@ -114,6 +128,11 @@ export type SharedWorkspaceActions = {
   closeProject: () => void
   /** Reset all slice state for project close. */
   clearStatesOnCloseProject: () => void
+  /**
+   * Populate store with project data returned from a ProjectPort open call.
+   * Sets project state, device config, files, libraries, flows, and opens main POU tab.
+   */
+  handleOpenProjectResponse: (data: OpenProjectResponseData) => void
 }
 
 export type SharedSlice = {
diff --git a/src2/frontend/store/slices/shared/utils.ts b/src/frontend/store/slices/shared/utils.ts
similarity index 97%
rename from src2/frontend/store/slices/shared/utils.ts
rename to src/frontend/store/slices/shared/utils.ts
index f0341eb89..4127e177a 100644
--- a/src2/frontend/store/slices/shared/utils.ts
+++ b/src/frontend/store/slices/shared/utils.ts
@@ -65,7 +65,7 @@ export function createDatatypeObject(data: DatatypeProps): PLCDataType {
       return {
         name: data.name,
         derivation: 'array',
-        baseType: { definition: 'base-type', value: 'bool' },
+        baseType: { definition: 'base-type', value: 'BOOL' },
         initialValue: 'false',
         dimensions: [],
       }
@@ -112,7 +112,7 @@ export function createEditorObjectForPou(
         name,
         path: name,
         pouType,
-        language: pouLanguage as 'ld' | 'sfc' | 'fbd',
+        language: pouLanguage,
       },
       variable: { display: 'table', description: '', classFilter: 'All', selectedRow: '' },
       graphical,
diff --git a/src2/frontend/store/slices/tabs/index.ts b/src/frontend/store/slices/tabs/index.ts
similarity index 100%
rename from src2/frontend/store/slices/tabs/index.ts
rename to src/frontend/store/slices/tabs/index.ts
diff --git a/src2/frontend/store/slices/tabs/slice.ts b/src/frontend/store/slices/tabs/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/tabs/slice.ts
rename to src/frontend/store/slices/tabs/slice.ts
diff --git a/src2/frontend/store/slices/tabs/types.ts b/src/frontend/store/slices/tabs/types.ts
similarity index 100%
rename from src2/frontend/store/slices/tabs/types.ts
rename to src/frontend/store/slices/tabs/types.ts
diff --git a/src2/frontend/store/slices/tabs/utils.ts b/src/frontend/store/slices/tabs/utils.ts
similarity index 100%
rename from src2/frontend/store/slices/tabs/utils.ts
rename to src/frontend/store/slices/tabs/utils.ts
diff --git a/src2/frontend/store/slices/webrtc/index.ts b/src/frontend/store/slices/webrtc/index.ts
similarity index 100%
rename from src2/frontend/store/slices/webrtc/index.ts
rename to src/frontend/store/slices/webrtc/index.ts
diff --git a/src2/frontend/store/slices/webrtc/slice.ts b/src/frontend/store/slices/webrtc/slice.ts
similarity index 100%
rename from src2/frontend/store/slices/webrtc/slice.ts
rename to src/frontend/store/slices/webrtc/slice.ts
diff --git a/src2/frontend/store/slices/webrtc/types.ts b/src/frontend/store/slices/webrtc/types.ts
similarity index 82%
rename from src2/frontend/store/slices/webrtc/types.ts
rename to src/frontend/store/slices/webrtc/types.ts
index 660e1ff66..aab4d88ce 100644
--- a/src2/frontend/store/slices/webrtc/types.ts
+++ b/src/frontend/store/slices/webrtc/types.ts
@@ -1,14 +1,6 @@
-// ---------------------------------------------------------------------------
-// WebRTC connection status
-// ---------------------------------------------------------------------------
+import type { WebRTCConnectionStatus } from '../../../../middleware/shared/ports/types'
 
-export type WebRTCConnectionStatus =
-  | 'disconnected'
-  | 'connecting'
-  | 'connected'
-  | 'reconnecting'
-  | 'error'
-  | 'failed'
+export type { WebRTCConnectionStatus }
 
 export type DebugTransport = 'http' | 'webrtc'
 
diff --git a/src/frontend/store/slices/workspace/index.ts b/src/frontend/store/slices/workspace/index.ts
new file mode 100644
index 000000000..c28418504
--- /dev/null
+++ b/src/frontend/store/slices/workspace/index.ts
@@ -0,0 +1,9 @@
+export { createWorkspaceSlice } from './slice'
+export type {
+  PlcFilters,
+  SystemConfigs,
+  WorkspaceActions,
+  WorkspaceResponse,
+  WorkspaceSlice,
+  WorkspaceState,
+} from './types'
diff --git a/src2/frontend/store/slices/workspace/slice.ts b/src/frontend/store/slices/workspace/slice.ts
similarity index 96%
rename from src2/frontend/store/slices/workspace/slice.ts
rename to src/frontend/store/slices/workspace/slice.ts
index 9e535dbf2..ccefffbb9 100644
--- a/src2/frontend/store/slices/workspace/slice.ts
+++ b/src/frontend/store/slices/workspace/slice.ts
@@ -1,8 +1,8 @@
-import type { DebugTreeNode, FbInstanceInfo, PlcLogs } from '../../../../middleware/shared/ports/types'
-import { isV4Logs, LOG_BUFFER_CAP } from '../../../../middleware/shared/ports/types'
 import { produce } from 'immer'
 import { StateCreator } from 'zustand'
 
+import type { DebugTreeNode, FbInstanceInfo, PlcLogs } from '../../../../middleware/shared/ports/types'
+import { isV4Logs, LOG_BUFFER_CAP } from '../../../../middleware/shared/ports/types'
 import type { WorkspaceSlice } from './types'
 
 const createWorkspaceSlice: StateCreator<WorkspaceSlice, [], [], WorkspaceSlice> = (setState) => ({
@@ -52,6 +52,9 @@ const createWorkspaceSlice: StateCreator<WorkspaceSlice, [], [], WorkspaceSlice>
     debugGraphList: [],
     debugDataStale: false,
     debugMd5Mismatch: null,
+    // Project loading state
+    isProjectLoading: false,
+    projectLoadingMessage: '',
   },
 
   workspaceActions: {
@@ -172,6 +175,8 @@ const createWorkspaceSlice: StateCreator<WorkspaceSlice, [], [], WorkspaceSlice>
             searchTerm: '',
             timestampFormat: 'full',
           }
+          workspace.isProjectLoading = false
+          workspace.projectLoadingMessage = ''
         }),
       )
     },
@@ -396,6 +401,14 @@ const createWorkspaceSlice: StateCreator<WorkspaceSlice, [], [], WorkspaceSlice>
         }),
       )
     },
+    setProjectLoading: (isLoading: boolean, message?: string) => {
+      setState(
+        produce(({ workspace }: WorkspaceSlice) => {
+          workspace.isProjectLoading = isLoading
+          workspace.projectLoadingMessage = message ?? ''
+        }),
+      )
+    },
   },
 })
 
diff --git a/src2/frontend/store/slices/workspace/types.ts b/src/frontend/store/slices/workspace/types.ts
similarity index 94%
rename from src2/frontend/store/slices/workspace/types.ts
rename to src/frontend/store/slices/workspace/types.ts
index 3436e42dd..1ef28ecc6 100644
--- a/src2/frontend/store/slices/workspace/types.ts
+++ b/src/frontend/store/slices/workspace/types.ts
@@ -1,4 +1,10 @@
-import type { DebugTreeNode, FbInstanceInfo, PlcLogs, Platform, Architecture } from '../../../../middleware/shared/ports/types'
+import type {
+  Architecture,
+  DebugTreeNode,
+  FbInstanceInfo,
+  Platform,
+  PlcLogs,
+} from '../../../../middleware/shared/ports/types'
 
 // ---------------------------------------------------------------------------
 // PLC Log Filters
@@ -83,6 +89,9 @@ export type WorkspaceState = {
     debugGraphList: string[]
     debugDataStale: boolean
     debugMd5Mismatch: { runtimeMd5: string; localMd5: string } | null
+    // Project loading state
+    isProjectLoading: boolean
+    projectLoadingMessage: string
   }
 }
 
@@ -143,6 +152,8 @@ export type WorkspaceActions = {
   clearDebugState: () => void
   clearFbDebugContext: () => void
   removeDebugVariable: (compositeKey: string) => void
+  // Project loading
+  setProjectLoading: (isLoading: boolean, message?: string) => void
 }
 
 export type WorkspaceSlice = WorkspaceState & {
diff --git a/src2/frontend/store/slices/workspace/utils/variables.ts b/src/frontend/store/slices/workspace/utils/variables.ts
similarity index 96%
rename from src2/frontend/store/slices/workspace/utils/variables.ts
rename to src/frontend/store/slices/workspace/utils/variables.ts
index 389aea513..9f5f4bdbf 100644
--- a/src2/frontend/store/slices/workspace/utils/variables.ts
+++ b/src/frontend/store/slices/workspace/utils/variables.ts
@@ -1,5 +1,4 @@
 import type { PLCGlobalVariable, PLCVariable } from '../../../../../middleware/shared/ports/types'
-
 import { WorkspaceResponse } from '../types'
 
 /**
@@ -101,7 +100,6 @@ const updateVariableValidation = (variables: PLCVariable[], dataToBeUpdated: Par
   if (dataToBeUpdated.name || dataToBeUpdated.name === '') {
     const { name } = dataToBeUpdated
     if (name === '') {
-      console.error('Variable name is empty')
       response = {
         ok: false,
         title: 'Variable name is empty.',
@@ -111,7 +109,6 @@ const updateVariableValidation = (variables: PLCVariable[], dataToBeUpdated: Par
     }
 
     if (checkIfVariableExists(variables, name)) {
-      console.error(`Variable "${name}" already exists`)
       response = {
         ok: false,
         title: 'Variable already exists',
@@ -121,7 +118,6 @@ const updateVariableValidation = (variables: PLCVariable[], dataToBeUpdated: Par
     }
 
     if (!variableNameValidation(name)) {
-      console.error(`Variable "${name}" name is invalid`)
       response = {
         ok: false,
         title: 'Variable name is invalid.',
@@ -173,7 +169,6 @@ const updateGlobalVariableValidation = (
   if (dataToBeUpdated.name || dataToBeUpdated.name === '') {
     const { name } = dataToBeUpdated
     if (name === '') {
-      console.error('Global Variable name is empty')
       response = {
         ok: false,
         title: 'Global Variable name is empty.',
@@ -183,7 +178,6 @@ const updateGlobalVariableValidation = (
     }
 
     if (checkIfGlobalVariableExists(variables, name)) {
-      console.error(`Global Variable "${name}" already exists`)
       response = {
         ok: false,
         title: 'Global Variable already exists',
diff --git a/src/frontend/utils/PLC/address-constants.ts b/src/frontend/utils/PLC/address-constants.ts
new file mode 100644
index 000000000..6d3bf8688
--- /dev/null
+++ b/src/frontend/utils/PLC/address-constants.ts
@@ -0,0 +1,14 @@
+export const PLC_ADDRESS_PREFIX = {
+  BOOL_OUTPUT: '%QX',
+  BOOL_INPUT: '%IX',
+  WORD_OUTPUT: '%QW',
+  WORD_INPUT: '%IW',
+  WORD_MEMORY: '%MW',
+  DWORD_MEMORY: '%MD',
+  LWORD_MEMORY: '%ML',
+} as const
+
+export const BOOL_LOCATION_REGEX = /^%[QI]X\d+\.\d$/
+export const WORD_LOCATION_REGEX = /^%[QIM]W\d+$/
+export const DWORD_LOCATION_REGEX = /^%MD\d+$/
+export const LWORD_LOCATION_REGEX = /^%ML\d+$/
diff --git a/src/frontend/utils/PLC/array-codegen-helpers.ts b/src/frontend/utils/PLC/array-codegen-helpers.ts
new file mode 100644
index 000000000..f121dcf41
--- /dev/null
+++ b/src/frontend/utils/PLC/array-codegen-helpers.ts
@@ -0,0 +1,109 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { parseDimensionRange } from './dimension-range'
+
+const BASE_TYPE_TO_IEC: Record<string, string> = {
+  bool: 'IEC_BOOL',
+  sint: 'IEC_SINT',
+  int: 'IEC_INT',
+  dint: 'IEC_DINT',
+  lint: 'IEC_LINT',
+  usint: 'IEC_USINT',
+  uint: 'IEC_UINT',
+  udint: 'IEC_UDINT',
+  ulint: 'IEC_ULINT',
+  byte: 'IEC_BYTE',
+  word: 'IEC_WORD',
+  dword: 'IEC_DWORD',
+  lword: 'IEC_LWORD',
+  real: 'IEC_REAL',
+  lreal: 'IEC_LREAL',
+  string: 'IEC_STRING',
+}
+
+/**
+ * Check if a PLCVariable has an array type definition.
+ */
+const isArrayVariable = (variable: PLCVariable): boolean => {
+  return variable.type.definition === 'array'
+}
+
+/**
+ * Get the total number of elements in an array variable (product of all dimension sizes).
+ * Returns 0 if the variable is not an array or has invalid dimensions.
+ */
+const getArrayTotalElements = (variable: PLCVariable): number => {
+  if (variable.type.definition !== 'array' || !variable.type.data) return 0
+
+  const dimensions = variable.type.data.dimensions
+  return dimensions.reduce((total, dim) => {
+    const range = parseDimensionRange(dim.dimension)
+    if (!range) return 0
+    return total * (range.upper - range.lower + 1)
+  }, 1)
+}
+
+/**
+ * Get the base type string (lowercase) of an array variable.
+ * Returns an empty string if the variable is not an array.
+ */
+const getArrayBaseTypeValue = (variable: PLCVariable): string => {
+  if (variable.type.definition !== 'array' || !variable.type.data) return ''
+  return variable.type.data.baseType.value
+}
+
+/**
+ * Map a base type string to its IEC C type name.
+ * Falls back to uppercasing the type value if not found.
+ */
+const mapBaseTypeToIEC = (baseType: string): string => {
+  return BASE_TYPE_TO_IEC[baseType.toLowerCase()] || baseType.toUpperCase()
+}
+
+/**
+ * Get the IEC C type for a variable — works for both scalars and arrays.
+ * For arrays, returns the IEC type of the base element type.
+ * For scalars, returns the IEC type of the variable's type.
+ */
+const getVariableIECType = (variable: PLCVariable): string => {
+  if (variable.type.definition === 'array' && variable.type.data) {
+    return mapBaseTypeToIEC(variable.type.data.baseType.value)
+  }
+  if (variable.type.definition === 'base-type') {
+    return mapBaseTypeToIEC(variable.type.value)
+  }
+  return variable.type.value.toUpperCase()
+}
+
+/**
+ * Get the start index of the first dimension of an array variable.
+ * Returns 0 if the variable is not an array or has invalid dimensions.
+ */
+const getArrayStartIndex = (variable: PLCVariable): number => {
+  if (variable.type.definition !== 'array' || !variable.type.data) return 0
+  const dimensions = variable.type.data.dimensions
+  if (dimensions.length === 0) return 0
+  const range = parseDimensionRange(dimensions[0].dimension)
+  return range ? range.lower : 0
+}
+
+/**
+ * Generate a C struct member declaration for a variable.
+ * Both scalars and arrays use pointers:
+ * - Scalars: pointer to the single value
+ * - Arrays: pointer to the first element of the table
+ */
+const generateStructMember = (variable: PLCVariable): string => {
+  const iecType = getVariableIECType(variable)
+  const name = variable.name.toUpperCase()
+  return `  ${iecType} *${name};\n`
+}
+
+export {
+  generateStructMember,
+  getArrayBaseTypeValue,
+  getArrayStartIndex,
+  getArrayTotalElements,
+  getVariableIECType,
+  isArrayVariable,
+  mapBaseTypeToIEC,
+}
diff --git a/src2/backend/shared/array-variable-utils.ts b/src/frontend/utils/PLC/array-variable-utils.ts
similarity index 87%
rename from src2/backend/shared/array-variable-utils.ts
rename to src/frontend/utils/PLC/array-variable-utils.ts
index 7b993fefc..14cedd7bb 100644
--- a/src2/backend/shared/array-variable-utils.ts
+++ b/src/frontend/utils/PLC/array-variable-utils.ts
@@ -1,4 +1,6 @@
-import type { PLCVariable } from '../../middleware/shared/ports/types'
+import type { DimensionRange } from './dimension-range'
+import { parseDimensionRange } from './dimension-range'
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
 
 const MAX_EXPANSION = 100
 
@@ -7,11 +9,6 @@ interface ParsedArrayAccess {
   indices: number[]
 }
 
-interface DimensionRange {
-  lower: number
-  upper: number
-}
-
 /**
  * Parse an array access expression like "Sensor[0]" or "Matrix[0,1]".
  * Returns null if the name is not a valid array access pattern.
@@ -37,20 +34,7 @@ export const parseArrayAccess = (name: string): ParsedArrayAccess | null => {
   return { baseName, indices }
 }
 
-/**
- * Parse a dimension range string like "0..5" into lower and upper bounds.
- */
-export const parseDimensionRange = (dimension: string): DimensionRange | null => {
-  const match = dimension.match(/^(-?\d+)\.\.(-?\d+)$/)
-  if (!match) return null
-
-  const lower = parseInt(match[1], 10)
-  const upper = parseInt(match[2], 10)
-
-  if (lower > upper) return null
-
-  return { lower, upper }
-}
+export { parseDimensionRange }
 
 /**
  * Validate that indices are within the declared array dimensions.
@@ -83,7 +67,7 @@ export const resolveArrayElement = (baseVariable: PLCVariable, access: ParsedArr
     name: `${access.baseName}[${indexStr}]`,
     type: {
       definition: data.baseType.definition as PLCVariable['type']['definition'],
-      value: data.baseType.value as string,
+      value: data.baseType.value,
     },
   } as PLCVariable
 }
@@ -129,7 +113,7 @@ export const expandArrayVariable = (variable: PLCVariable): PLCVariable[] => {
       name: `${variable.name}[${indexStr}]`,
       type: {
         definition: data.baseType.definition as PLCVariable['type']['definition'],
-        value: data.baseType.value as string,
+        value: data.baseType.value,
       },
     } as PLCVariable
   })
diff --git a/src/frontend/utils/PLC/dimension-range.ts b/src/frontend/utils/PLC/dimension-range.ts
new file mode 100644
index 000000000..1c0ad74da
--- /dev/null
+++ b/src/frontend/utils/PLC/dimension-range.ts
@@ -0,0 +1,22 @@
+interface DimensionRange {
+  lower: number
+  upper: number
+}
+
+/**
+ * Parse a dimension range string like "0..5" into lower and upper bounds.
+ */
+const parseDimensionRange = (dimension: string): DimensionRange | null => {
+  const match = dimension.match(/^(-?\d+)\.\.(-?\d+)$/)
+  if (!match) return null
+
+  const lower = parseInt(match[1], 10)
+  const upper = parseInt(match[2], 10)
+
+  if (lower > upper) return null
+
+  return { lower, upper }
+}
+
+export { parseDimensionRange }
+export type { DimensionRange }
diff --git a/src/utils/PLC/extensible-block-variables.ts b/src/frontend/utils/PLC/extensible-block-variables.ts
similarity index 100%
rename from src/utils/PLC/extensible-block-variables.ts
rename to src/frontend/utils/PLC/extensible-block-variables.ts
diff --git a/src/utils/PLC/pou-file-extensions.ts b/src/frontend/utils/PLC/pou-file-extensions.ts
similarity index 100%
rename from src/utils/PLC/pou-file-extensions.ts
rename to src/frontend/utils/PLC/pou-file-extensions.ts
diff --git a/src/frontend/utils/PLC/pou-text-parser.ts b/src/frontend/utils/PLC/pou-text-parser.ts
new file mode 100644
index 000000000..821daaf63
--- /dev/null
+++ b/src/frontend/utils/PLC/pou-text-parser.ts
@@ -0,0 +1,359 @@
+import type { PLCPou, PLCVariable, PouType } from '../../../middleware/shared/ports/types'
+import { parseIecStringToVariables } from '../generate-iec-string-to-variables'
+import { getLanguageFromExtension } from './pou-file-extensions'
+
+/**
+ * Helper function to extract documentation from leading comments
+ * @param content - The content to extract documentation from
+ * @returns Object with documentation and remaining content
+ */
+const extractDocumentation = (content: string): { documentation: string; remainingContent: string } => {
+  const docMatch = content.match(/^\s*\(\*\s*(.*?)\s*\*\)\s*\n/s)
+  if (docMatch) {
+    return {
+      documentation: docMatch[1].trim(),
+      remainingContent: content.slice(docMatch[0].length),
+    }
+  }
+  return {
+    documentation: '',
+    remainingContent: content,
+  }
+}
+
+/**
+ * Helper function to provide clear error messages with line numbers
+ * @param message - The error message
+ * @param lineNumber - Optional line number where the error occurred
+ * @returns Formatted error message
+ */
+const formatParseError = (message: string, lineNumber?: number): string => {
+  if (lineNumber !== undefined) {
+    return `Parse error on line ${lineNumber}: ${message}`
+  }
+  return `Parse error: ${message}`
+}
+
+/**
+ * Helper function to find the last END_VAR in the content
+ * @param content - The content to search
+ * @param startIndex - The index to start searching from
+ * @returns The index after the last END_VAR, or -1 if not found
+ */
+const findLastEndVarIndex = (content: string, startIndex: number): number => {
+  let lastEndVarIndex = -1
+  let searchIndex = startIndex
+
+  let endVarMatch = content.slice(searchIndex).match(/\bEND_VAR\b/i)
+  while (endVarMatch && endVarMatch.index !== undefined) {
+    lastEndVarIndex = searchIndex + endVarMatch.index + endVarMatch[0].length
+    searchIndex = lastEndVarIndex
+    endVarMatch = content.slice(searchIndex).match(/\bEND_VAR\b/i)
+  }
+
+  return lastEndVarIndex
+}
+
+/**
+ * Parse a textual POU (ST, IL) from string to PLCPou object
+ * @param content - The text content to parse
+ * @param language - The language code (st, il)
+ * @param type - The POU type (program, function, function-block)
+ * @returns Parsed PLCPou object
+ * @throws Error if parsing fails
+ */
+export const parseTextualPouFromString = (content: string, language: string, type: string): PLCPou => {
+  try {
+    const { documentation, remainingContent } = extractDocumentation(content)
+
+    const pouTypeKeywords = {
+      program: 'PROGRAM',
+      function: 'FUNCTION',
+      'function-block': 'FUNCTION_BLOCK',
+    }
+
+    const typeKeyword = pouTypeKeywords[type as keyof typeof pouTypeKeywords]
+    if (!typeKeyword) {
+      throw new Error(formatParseError(`Unsupported POU type: ${type}`))
+    }
+
+    const declarationRegex = new RegExp(`^\\s*(${typeKeyword})\\s+(\\w+)(?:\\s*:\\s*(\\w+))?`, 'i')
+    const declarationMatch = remainingContent.match(declarationRegex)
+
+    if (!declarationMatch) {
+      throw new Error(formatParseError(`Could not find ${typeKeyword} declaration`))
+    }
+
+    const pouName = declarationMatch[2]
+    const returnType = declarationMatch[3] // Only present for functions
+
+    if (type === 'function' && !returnType) {
+      throw new Error(formatParseError(`Function ${pouName} must have a return type`))
+    }
+
+    const varStartIndex = remainingContent.search(
+      /\b(VAR_INPUT|VAR_OUTPUT|VAR_IN_OUT|VAR_EXTERNAL|VAR_TEMP|VAR_GLOBAL|VAR)\b/i,
+    )
+
+    let variablesString = ''
+    let bodyStartIndex = declarationMatch[0].length
+
+    if (varStartIndex !== -1) {
+      const varSectionStart = varStartIndex
+      const lastEndVarIndex = findLastEndVarIndex(remainingContent, varSectionStart)
+
+      if (lastEndVarIndex !== -1) {
+        variablesString = remainingContent.slice(varSectionStart, lastEndVarIndex)
+        bodyStartIndex = lastEndVarIndex
+      }
+    }
+
+    const variables = variablesString.trim()
+      ? parseIecStringToVariables(variablesString).map((v) => ({ ...v, debug: false }))
+      : []
+
+    const endKeywords = {
+      program: 'END_PROGRAM',
+      function: 'END_FUNCTION',
+      'function-block': 'END_FUNCTION_BLOCK',
+    }
+
+    const endKeyword = endKeywords[type as keyof typeof endKeywords]
+    const endKeywordRegex = new RegExp(`\\b${endKeyword}\\b`, 'i')
+    const endMatch = remainingContent.slice(bodyStartIndex).search(endKeywordRegex)
+
+    if (endMatch === -1) {
+      throw new Error(formatParseError(`Could not find ${endKeyword}`))
+    }
+
+    const bodyContent = remainingContent.slice(bodyStartIndex, bodyStartIndex + endMatch).trim()
+
+    return {
+      name: pouName,
+      pouType: type as PouType,
+      interface: {
+        ...(type === 'function' ? { returnType: returnType || '' } : {}),
+        variables,
+      },
+      body: {
+        language: language as 'st' | 'il',
+        value: bodyContent,
+      },
+      documentation,
+    }
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse textual POU: ${error.message}`)
+    }
+    throw new Error('Failed to parse textual POU: Unknown error')
+  }
+}
+
+/**
+ * Parse a hybrid POU (Python, C++) from string to PLCPou object
+ * @param content - The text content to parse
+ * @param language - The language code (python, cpp)
+ * @param type - The POU type (program, function, function-block)
+ * @returns Parsed PLCPou object
+ * @throws Error if parsing fails
+ */
+export const parseHybridPouFromString = (content: string, language: string, type: string): PLCPou => {
+  try {
+    const { documentation, remainingContent } = extractDocumentation(content)
+
+    const pouTypeKeywords = {
+      program: 'PROGRAM',
+      function: 'FUNCTION',
+      'function-block': 'FUNCTION_BLOCK',
+    }
+
+    const typeKeyword = pouTypeKeywords[type as keyof typeof pouTypeKeywords]
+    if (!typeKeyword) {
+      throw new Error(formatParseError(`Unsupported POU type: ${type}`))
+    }
+
+    const declarationRegex = new RegExp(`^\\s*(${typeKeyword})\\s+(\\w+)(?:\\s*:\\s*(\\w+))?`, 'i')
+    const declarationMatch = remainingContent.match(declarationRegex)
+
+    if (!declarationMatch) {
+      throw new Error(formatParseError(`Could not find ${typeKeyword} declaration`))
+    }
+
+    const pouName = declarationMatch[2]
+    const returnType = declarationMatch[3] // Only present for functions
+
+    if (type === 'function' && !returnType) {
+      throw new Error(formatParseError(`Function ${pouName} must have a return type`))
+    }
+
+    const varStartIndex = remainingContent.search(
+      /\b(VAR_INPUT|VAR_OUTPUT|VAR_IN_OUT|VAR_EXTERNAL|VAR_TEMP|VAR_GLOBAL|VAR)\b/i,
+    )
+
+    let variablesString = ''
+    let bodyStartIndex = declarationMatch[0].length
+
+    if (varStartIndex !== -1) {
+      const varSectionStart = varStartIndex
+      const lastEndVarIndex = findLastEndVarIndex(remainingContent, varSectionStart)
+
+      if (lastEndVarIndex !== -1) {
+        variablesString = remainingContent.slice(varSectionStart, lastEndVarIndex)
+        bodyStartIndex = lastEndVarIndex
+      }
+    }
+
+    const variables = variablesString.trim()
+      ? parseIecStringToVariables(variablesString).map((v) => ({ ...v, debug: false }))
+      : []
+
+    // Strip the trailing END keyword from the body content, matching how textual/graphical parsers handle it
+    const endKeywords: Record<string, string> = {
+      program: 'END_PROGRAM',
+      function: 'END_FUNCTION',
+      'function-block': 'END_FUNCTION_BLOCK',
+    }
+    const endKeyword = endKeywords[type]
+    let bodyContent = remainingContent.slice(bodyStartIndex).trim()
+    if (endKeyword) {
+      const endKeywordRegex = new RegExp(`\\s*\\b${endKeyword}\\b\\s*$`, 'i')
+      bodyContent = bodyContent.replace(endKeywordRegex, '').trim()
+    }
+
+    return {
+      name: pouName,
+      pouType: type as PouType,
+      interface: {
+        ...(type === 'function' ? { returnType: returnType || '' } : {}),
+        variables,
+      },
+      body: {
+        language: language as 'python' | 'cpp',
+        value: bodyContent,
+      },
+      documentation,
+    }
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse hybrid POU: ${error.message}`)
+    }
+    throw new Error('Failed to parse hybrid POU: Unknown error')
+  }
+}
+
+/**
+ * Parse a graphical POU (LD, FBD) from string to PLCPou object.
+ * Graphical POUs store their body as JSON between the variable declarations and the END keyword.
+ * @param content - The text content to parse
+ * @param language - The language code (ld, fbd)
+ * @param type - The POU type (program, function, function-block)
+ * @returns Parsed PLCPou object
+ * @throws Error if parsing fails
+ */
+export const parseGraphicalPouFromString = (content: string, language: string, type: string): PLCPou => {
+  try {
+    const { documentation, remainingContent } = extractDocumentation(content)
+
+    const pouTypeKeywords: Record<string, string> = {
+      program: 'PROGRAM',
+      function: 'FUNCTION',
+      'function-block': 'FUNCTION_BLOCK',
+    }
+
+    const typeKeyword = pouTypeKeywords[type]
+    if (!typeKeyword) {
+      throw new Error(formatParseError(`Unsupported POU type: ${type}`))
+    }
+
+    const declarationRegex = new RegExp(`^\\s*(${typeKeyword})\\s+(\\w+)(?:\\s*:\\s*(\\w+))?`, 'i')
+    const declarationMatch = remainingContent.match(declarationRegex)
+
+    if (!declarationMatch) {
+      throw new Error(formatParseError(`Could not find ${typeKeyword} declaration`))
+    }
+
+    const pouName = declarationMatch[2]
+    const returnType = declarationMatch[3]
+
+    if (type === 'function' && !returnType) {
+      throw new Error(formatParseError(`Function ${pouName} must have a return type`))
+    }
+
+    const varStartIndex = remainingContent.search(
+      /\b(VAR_INPUT|VAR_OUTPUT|VAR_IN_OUT|VAR_EXTERNAL|VAR_TEMP|VAR_GLOBAL|VAR)\b/i,
+    )
+
+    let variablesString = ''
+    let bodyStartIndex = declarationMatch[0].length
+
+    if (varStartIndex !== -1) {
+      const varSectionStart = varStartIndex
+      const lastEndVarIndex = findLastEndVarIndex(remainingContent, varSectionStart)
+
+      if (lastEndVarIndex !== -1) {
+        variablesString = remainingContent.slice(varSectionStart, lastEndVarIndex)
+        bodyStartIndex = lastEndVarIndex
+      }
+    }
+
+    const variables: PLCVariable[] = variablesString.trim()
+      ? parseIecStringToVariables(variablesString).map((v) => ({ ...v, debug: false }))
+      : []
+
+    const endKeywords: Record<string, string> = {
+      program: 'END_PROGRAM',
+      function: 'END_FUNCTION',
+      'function-block': 'END_FUNCTION_BLOCK',
+    }
+
+    const endKeyword = endKeywords[type]
+    const endKeywordRegex = new RegExp(`\\b${endKeyword}\\b`, 'i')
+    const endMatch = remainingContent.slice(bodyStartIndex).search(endKeywordRegex)
+
+    if (endMatch === -1) {
+      throw new Error(formatParseError(`Could not find ${endKeyword}`))
+    }
+
+    const bodyContent = remainingContent.slice(bodyStartIndex, bodyStartIndex + endMatch).trim()
+
+    let parsedBody: unknown
+    try {
+      parsedBody = JSON.parse(bodyContent)
+    } catch (jsonError: unknown) {
+      if (jsonError instanceof Error) {
+        throw new Error(formatParseError(`Invalid JSON in graphical body: ${jsonError.message}`))
+      }
+      throw new Error(formatParseError('Invalid JSON in graphical body'))
+    }
+
+    return {
+      name: pouName,
+      pouType: type as PouType,
+      interface: {
+        ...(type === 'function' ? { returnType: returnType || '' } : {}),
+        variables,
+      },
+      body: {
+        language: language as 'ld' | 'fbd',
+        value: parsedBody,
+      },
+      documentation,
+    }
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse graphical POU: ${error.message}`)
+    }
+    throw new Error('Failed to parse graphical POU: Unknown error')
+  }
+}
+
+/**
+ * Detect language from file extension
+ * @param filePath - The file path with extension
+ * @returns The language code
+ * @throws Error if extension is not supported
+ */
+export const detectLanguageFromExtension = (filePath: string): string => {
+  const extension = filePath.slice(filePath.lastIndexOf('.'))
+  return getLanguageFromExtension(extension)
+}
diff --git a/src/frontend/utils/PLC/pou-text-serializer.ts b/src/frontend/utils/PLC/pou-text-serializer.ts
new file mode 100644
index 000000000..2b1c31a7c
--- /dev/null
+++ b/src/frontend/utils/PLC/pou-text-serializer.ts
@@ -0,0 +1,83 @@
+import type { PLCPou } from '../../../middleware/shared/ports/types'
+import { generateIecVariablesToString } from '../generate-iec-variables-to-string'
+import { getEndKeyword, getStartKeyword } from './pou-file-extensions'
+
+/** PLCPou extended with optional variablesText from code-mode editing */
+type SerializablePou = PLCPou & { variablesText?: string }
+
+const formatDocumentation = (documentation: string | undefined): string => {
+  if (documentation && documentation.trim()) {
+    return `(* ${documentation.trim()} *)\n\n`
+  }
+  return ''
+}
+
+const buildDeclaration = (pou: SerializablePou): string => {
+  const startKeyword = getStartKeyword(pou.pouType)
+  if (pou.pouType === 'function' && pou.interface?.returnType) {
+    return `${startKeyword} ${pou.name} : ${pou.interface.returnType}\n`
+  }
+  return `${startKeyword} ${pou.name}\n`
+}
+
+const buildVariables = (pou: SerializablePou): string => {
+  if (pou.variablesText != null) return pou.variablesText
+  const variables = pou.interface?.variables ?? []
+  return generateIecVariablesToString(variables)
+}
+
+export const serializeTextualPouToString = (pou: SerializablePou): string => {
+  if (pou.body.language !== 'st' && pou.body.language !== 'il') {
+    throw new Error(`serializeTextualPouToString only supports ST and IL languages, got: ${pou.body.language}`)
+  }
+
+  let result = formatDocumentation(pou.documentation)
+  result += buildDeclaration(pou)
+  result += buildVariables(pou) + '\n\n'
+  result += pou.body.value + '\n\n'
+  result += getEndKeyword(pou.pouType)
+
+  return result
+}
+
+export const serializeHybridPouToString = (pou: SerializablePou): string => {
+  if (pou.body.language !== 'python' && pou.body.language !== 'cpp') {
+    throw new Error(`serializeHybridPouToString only supports Python and C++ languages, got: ${pou.body.language}`)
+  }
+
+  let result = formatDocumentation(pou.documentation)
+  result += buildDeclaration(pou)
+  result += buildVariables(pou) + '\n'
+  result += pou.body.value + '\n\n'
+  result += getEndKeyword(pou.pouType)
+
+  return result
+}
+
+export const serializeGraphicalPouToString = (pou: SerializablePou): string => {
+  if (pou.body.language !== 'ld' && pou.body.language !== 'fbd') {
+    throw new Error(`serializeGraphicalPouToString only supports LD and FBD languages, got: ${pou.body.language}`)
+  }
+
+  let result = formatDocumentation(pou.documentation)
+  result += buildDeclaration(pou)
+  result += buildVariables(pou) + '\n\n'
+  result += JSON.stringify(pou.body.value, null, 2) + '\n'
+  result += getEndKeyword(pou.pouType)
+
+  return result
+}
+
+export const serializePouToText = (pou: SerializablePou): string => {
+  const language = pou.body.language
+
+  if (language === 'st' || language === 'il') {
+    return serializeTextualPouToString(pou)
+  } else if (language === 'python' || language === 'cpp') {
+    return serializeHybridPouToString(pou)
+  } else if (language === 'ld' || language === 'fbd') {
+    return serializeGraphicalPouToString(pou)
+  } else {
+    throw new Error(`Unsupported language: ${language}`)
+  }
+}
diff --git a/src/frontend/utils/PLC/preprocess-pous.ts b/src/frontend/utils/PLC/preprocess-pous.ts
new file mode 100644
index 000000000..0e116ec7c
--- /dev/null
+++ b/src/frontend/utils/PLC/preprocess-pous.ts
@@ -0,0 +1,186 @@
+import type { PLCPou, PLCProjectData } from '../../../middleware/shared/ports/types'
+import { addCppLocalVariables } from '../cpp/addCppLocalVariables'
+import { generateSTCode as generateCppSTCode } from '../cpp/generateSTCode'
+import { validateCppCode } from '../cpp/validateCppCode'
+import { addPythonLocalVariables } from '../python/addPythonLocalVariables'
+import { generateSTCode } from '../python/generateSTCode'
+import { injectPythonCode } from '../python/injectPythonCode'
+import { wrapUnsupportedComments } from './wrap-unsupported-comments'
+
+type CppPouData = {
+  name: string
+  code: string
+  variables: unknown[]
+}
+
+type ProjectDataWithCpp = PLCProjectData & {
+  originalCppPous?: CppPouData[]
+}
+
+type LogFn = (level: 'info' | 'error', message: string) => void
+
+type PreprocessResult = {
+  projectData: ProjectDataWithCpp
+  validationFailed: boolean
+}
+
+const extractPythonData = (pous: PLCPou[]) => {
+  return pous
+    .filter((pou) => pou.body.language === 'python')
+    .map((pou) => ({
+      name: pou.name,
+      type: pou.pouType,
+      code: pou.body.language === 'python' ? (pou.body as { language: string; value: string }).value : '',
+      documentation: pou.documentation,
+      variables: pou.interface?.variables ?? [],
+    }))
+}
+
+const applyEarlyCommentWrapping = (projectData: PLCProjectData): PLCProjectData => {
+  return {
+    ...projectData,
+    pous: projectData.pous.map((pou: PLCPou) => {
+      if (pou.body.language === 'st' || pou.body.language === 'il') {
+        const wrappedValue = wrapUnsupportedComments(pou.body.value as string)
+        return {
+          ...pou,
+          body: {
+            language: pou.body.language,
+            value: wrappedValue,
+          },
+        }
+      }
+      return pou
+    }),
+  }
+}
+
+function preprocessPous(projectData: PLCProjectData, isSimulator: boolean, log: LogFn): PreprocessResult {
+  let processedProjectData: PLCProjectData = applyEarlyCommentWrapping(projectData)
+
+  // --- Python processing ---
+  const hasPythonCode = projectData.pous.some((pou: PLCPou) => pou.body.language === 'python')
+
+  if (hasPythonCode) {
+    const pythonPous = projectData.pous.filter((pou: PLCPou) => pou.body.language === 'python')
+
+    pythonPous.forEach((pou) => {
+      log('info', `Found Python POU: "${pou.name}" (${pou.pouType})`)
+    })
+
+    log('info', `Processing ${pythonPous.length} Python POU(s)...`)
+
+    processedProjectData = addPythonLocalVariables(projectData)
+
+    if (isSimulator) {
+      // Simulator: keep runtime variables but replace body with a no-op ST statement
+      processedProjectData.pous = processedProjectData.pous.map((pou: PLCPou) => {
+        if (pou.body.language === 'python') {
+          return {
+            ...pou,
+            body: {
+              language: 'st' as const,
+              value: 'first_run := 0;',
+            },
+          }
+        }
+        return pou
+      })
+    } else {
+      // Full pipeline for runtime targets
+      const pythonData = extractPythonData(processedProjectData.pous)
+      const processedPythonCodes = injectPythonCode(pythonData)
+
+      let pythonIndex = 0
+      processedProjectData.pous = processedProjectData.pous.map((pou: PLCPou) => {
+        if (pou.body.language === 'python') {
+          if (processedPythonCodes[pythonIndex]) {
+            const stCode = generateSTCode({
+              pouName: pou.name,
+              allVariables: pou.interface?.variables ?? [],
+              processedPythonCode: processedPythonCodes[pythonIndex],
+            })
+
+            pythonIndex++
+            return {
+              ...pou,
+              body: {
+                language: 'st' as const,
+                value: stCode,
+              },
+            }
+          }
+        }
+        return pou
+      })
+
+      log('info', `Successfully processed ${processedPythonCodes.length} Python POU(s)`)
+    }
+
+    if (isSimulator) {
+      log('info', `Compiled ${pythonPous.length} Python POU(s) as empty stubs for simulator`)
+    }
+  }
+
+  // --- C++ processing ---
+  const hasCppCode = processedProjectData.pous.some((pou: PLCPou) => pou.body.language === 'cpp')
+
+  if (hasCppCode) {
+    const cppPous = processedProjectData.pous.filter((pou: PLCPou) => pou.body.language === 'cpp')
+
+    cppPous.forEach((pou) => {
+      log('info', `Found C/C++ POU: "${pou.name}" (${pou.pouType})`)
+    })
+
+    log('info', `Processing ${cppPous.length} C/C++ POU(s)...`)
+
+    let validationFailed = false
+    for (const pou of cppPous) {
+      const code = pou.body.language === 'cpp' ? (pou.body as { language: string; value: string }).value : ''
+      const validation = validateCppCode(code)
+      if (!validation.valid) {
+        log('error', `Validation failed for "${pou.name}": ${validation.error}`)
+        validationFailed = true
+      }
+    }
+
+    if (validationFailed) {
+      return { projectData: processedProjectData as ProjectDataWithCpp, validationFailed: true }
+    }
+
+    processedProjectData = addCppLocalVariables(processedProjectData)
+
+    const originalCppPousData = cppPous.map((pou) => ({
+      name: pou.name,
+      code: pou.body.language === 'cpp' ? (pou.body as { language: string; value: string }).value : '',
+      variables: pou.interface?.variables ?? [],
+    }))
+
+    processedProjectData.pous = processedProjectData.pous.map((pou: PLCPou) => {
+      if (pou.body.language === 'cpp') {
+        const stCode = generateCppSTCode({
+          pouName: pou.name,
+          allVariables: pou.interface?.variables ?? [],
+        })
+
+        return {
+          ...pou,
+          body: {
+            language: 'st' as const,
+            value: stCode,
+          },
+        }
+      }
+      return pou
+    })
+
+    const projectDataWithCpp = processedProjectData as ProjectDataWithCpp
+    projectDataWithCpp.originalCppPous = originalCppPousData
+
+    log('info', `Successfully processed ${cppPous.length} C/C++ POU(s)`)
+  }
+
+  return { projectData: processedProjectData as ProjectDataWithCpp, validationFailed: false }
+}
+
+export { preprocessPous, type ProjectDataWithCpp }
diff --git a/src2/backend/shared/validate-variable-type.ts b/src/frontend/utils/PLC/validate-variable-type.ts
similarity index 95%
rename from src2/backend/shared/validate-variable-type.ts
rename to src/frontend/utils/PLC/validate-variable-type.ts
index 4306eabe8..151e5d272 100644
--- a/src2/backend/shared/validate-variable-type.ts
+++ b/src/frontend/utils/PLC/validate-variable-type.ts
@@ -1,6 +1,7 @@
-import { baseTypeSchema, genericTypeSchema } from '../../middleware/shared/ports/plc-schemas'
 import { ZodLiteral } from 'zod'
 
+import { baseTypeSchema, genericTypeSchema } from '../../../middleware/shared/ports/plc-schemas'
+
 export const validateVariableType = (
   selectedType: string,
   expectedType: string,
@@ -99,7 +100,7 @@ export const getVariableRestrictionType = (variableType: string) => {
     }
   }
 
-  const isABaseType = baseTypeSchema.safeParse(variableType)
+  const isABaseType = baseTypeSchema.safeParse(variableType.toLowerCase())
 
   return {
     // For base types, lowercase is fine (they're standardized and compared case-insensitively)
diff --git a/src/utils/PLC/wrap-unsupported-comments.ts b/src/frontend/utils/PLC/wrap-unsupported-comments.ts
similarity index 100%
rename from src/utils/PLC/wrap-unsupported-comments.ts
rename to src/frontend/utils/PLC/wrap-unsupported-comments.ts
diff --git a/src/frontend/utils/PLC/xml-generator.ts b/src/frontend/utils/PLC/xml-generator.ts
new file mode 100644
index 000000000..acb454715
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator.ts
@@ -0,0 +1,71 @@
+import type { PLCProjectData } from '@root/types/PLC/open-plc'
+import { BaseXml as codeSysBaseXml } from '@root/types/PLC/xml-data/codesys'
+import { BaseXml as oldBaseXml } from '@root/types/PLC/xml-data/old-editor'
+import { create } from 'xmlbuilder2'
+
+import {
+  codeSysInstanceToXml,
+  codeSysParseDataTypesToXML,
+  codeSysParsePousToXML,
+  getBaseCodeSysXmlStructure,
+} from './xml-generator/codesys'
+import {
+  getBaseOldEditorXmlStructure,
+  oldEditorInstanceToXml,
+  oldEditorParseDataTypesToXML,
+  oldEditorParsePousToXML,
+} from './xml-generator/old-editor'
+
+const XmlGenerator = (
+  projectToGenerateXML: PLCProjectData,
+  xmlFormatTarget: 'old-editor' | 'codesys' = 'old-editor',
+) => {
+  let xmlResult = xmlFormatTarget === 'old-editor' ? getBaseOldEditorXmlStructure() : getBaseCodeSysXmlStructure()
+
+  /**
+   * Parse POUs
+   */
+  const pous = projectToGenerateXML.pous
+
+  const mainPou = pous.find((pou) => pou.data.name === 'main' && pou.type === 'program')
+  if (!mainPou) return { ok: false, message: 'Main POU not found.', data: undefined }
+
+  if (xmlFormatTarget === 'old-editor') {
+    let oldXml = xmlResult as oldBaseXml
+    oldXml = oldEditorParsePousToXML(oldXml, pous)
+
+    /**
+     * Parse data types
+     */
+    const dataTypes = projectToGenerateXML.dataTypes
+    oldXml = oldEditorParseDataTypesToXML(oldXml, dataTypes)
+
+    /**
+     * Parse instances
+     */
+    const configuration = projectToGenerateXML.configuration
+    xmlResult = oldEditorInstanceToXml(oldXml, configuration)
+  } else {
+    let csXml = xmlResult as codeSysBaseXml
+    csXml = codeSysParsePousToXML(csXml, pous)
+
+    /**
+     * Parse data types
+     */
+    const dataTypes = projectToGenerateXML.dataTypes
+    csXml = codeSysParseDataTypesToXML(csXml, dataTypes)
+
+    /**
+     * Parse instances
+     */
+    const configuration = projectToGenerateXML.configuration
+    xmlResult = codeSysInstanceToXml(csXml, configuration)
+  }
+
+  const doc = create(xmlResult)
+  doc.dec({ version: '1.0', encoding: 'utf-8' })
+
+  return { ok: true, message: 'XML generated', data: doc.end({ prettyPrint: true }) }
+}
+
+export { XmlGenerator }
diff --git a/src/frontend/utils/PLC/xml-generator/codesys/base-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/base-xml.ts
new file mode 100644
index 000000000..f9e9fcf86
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/codesys/base-xml.ts
@@ -0,0 +1,62 @@
+import { BaseXml } from '@root/types/PLC/xml-data/codesys/base-diagram'
+
+import { formatDate } from '../../../format-date'
+
+const getBaseCodeSysXmlStructure = (): BaseXml => ({
+  project: {
+    '@xmlns': 'http://www.plcopen.org/xml/tc6_0200',
+    fileHeader: {
+      '@companyName': 'Unknown',
+      '@productName': 'Unnamed',
+      '@productVersion': '1',
+      '@creationDateTime': formatDate(new Date()),
+    },
+    contentHeader: {
+      '@name': 'Unnamed',
+      '@modificationDateTime': formatDate(new Date()),
+      coordinateInfo: {
+        fbd: {
+          scaling: {
+            '@x': '16',
+            '@y': '16',
+          },
+        },
+        ld: {
+          scaling: {
+            '@x': '16',
+            '@y': '16',
+          },
+        },
+        sfc: {
+          scaling: {
+            '@x': '16',
+            '@y': '16',
+          },
+        },
+      },
+    },
+
+    types: {
+      dataTypes: {
+        dataType: [],
+      },
+      pous: {
+        pou: [],
+      },
+    },
+
+    instances: {
+      configurations: {
+        configuration: {
+          '@name': 'Config0',
+          resource: {
+            '@name': 'Res0',
+            task: [],
+          },
+        },
+      },
+    },
+  },
+})
+
+export { getBaseCodeSysXmlStructure }
diff --git a/src/utils/PLC/xml-generator/codesys/data-type-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/data-type-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/data-type-xml.ts
rename to src/frontend/utils/PLC/xml-generator/codesys/data-type-xml.ts
diff --git a/src/utils/PLC/xml-generator/codesys/index.ts b/src/frontend/utils/PLC/xml-generator/codesys/index.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/index.ts
rename to src/frontend/utils/PLC/xml-generator/codesys/index.ts
diff --git a/src/utils/PLC/xml-generator/codesys/instances-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/instances-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/instances-xml.ts
rename to src/frontend/utils/PLC/xml-generator/codesys/instances-xml.ts
diff --git a/src/frontend/utils/PLC/xml-generator/codesys/language/fbd-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
new file mode 100644
index 000000000..a9b72f5e6
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
@@ -0,0 +1,310 @@
+import { CustomFbdNodeTypes } from '@root/frontend/components/_atoms/graphical-editor/fbd'
+import { BlockNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/block'
+import { CommentNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/comment'
+import { ConnectionNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/connection'
+import { BasicNodeData } from '@root/frontend/components/_atoms/graphical-editor/fbd/utils'
+import { VariableNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/variable'
+import { BlockVariant } from '@root/frontend/components/_atoms/graphical-editor/types/block'
+import { FBDRungState } from '@root/frontend/store/slices'
+import {
+  BlockFbdXML,
+  CommentFbdXML,
+  ConnectorFbdXML,
+  ContinuationFbdXML,
+  FbdXML,
+  InVariableFbdXML,
+  OutVariableFbdXML,
+} from '@root/types/PLC/xml-data/codesys/pous/languages/fbd-diagram'
+
+/**
+ * Translate react flow nodes to XML
+ */
+
+const blockToXml = (node: BlockNode<BlockVariant>, rung: FBDRungState): BlockFbdXML => {
+  const inputVariables: BlockFbdXML['inputVariables']['variable'] = node.data.inputHandles
+    .flatMap((handle) => {
+      const edges = rung.edges.filter((edge) => edge.target === node.id && edge.targetHandle === handle.id)
+      if (edges.length === 0)
+        return {
+          '@formalParameter': handle.id || '',
+          connectionPointIn: {
+            connection: [],
+          },
+        }
+
+      return edges.map((edge) => {
+        const sourceNode = rung.nodes.find((node) => node.id === edge.source)
+        if (!sourceNode) return undefined
+
+        return {
+          '@formalParameter': handle.id || '',
+          connectionPointIn: {
+            connection: [
+              {
+                '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+                '@formalParameter':
+                  sourceNode.type === 'block'
+                    ? (edge.sourceHandle as string) === 'OUT'
+                      ? '   '
+                      : (edge.sourceHandle as string)
+                    : undefined,
+              },
+            ],
+          },
+        }
+      })
+    })
+    .filter((variable) => variable !== undefined)
+
+  const outputVariable: BlockFbdXML['outputVariables']['variable'] = node.data.outputHandles
+    .flatMap((handle, handleIndex) => {
+      const edges = rung.edges.filter((edge) => edge.source === node.id && edge.sourceHandle === handle.id)
+      if (edges.length === 0)
+        return {
+          '@formalParameter': handle.id || '',
+          connectionPointOut: {
+            expression: undefined,
+          },
+        }
+
+      return edges.map((edge) => {
+        const targetNode = rung.nodes.find((node) => node.id === edge.target)
+        if (!targetNode) return undefined
+
+        return {
+          '@formalParameter': handle.id === 'OUT' ? '   ' : handle.id || '',
+          connectionPointOut: {
+            expression:
+              handleIndex !== 0 && targetNode.type?.includes('variable')
+                ? (targetNode as VariableNode).data.variable.name
+                : undefined,
+          },
+        }
+      })
+    })
+    .filter((variable) => variable !== undefined)
+
+  const blockXML: BlockFbdXML = {
+    '@localId': node.data.numericId,
+    '@typeName': node.data.variant.name,
+    '@instanceName': node.data.variant.type === 'function-block' ? node.data.variable.name : undefined,
+    '@executionOrderId': node.data.executionOrder,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    inputVariables: {
+      variable: inputVariables,
+    },
+    inOutVariables: '',
+    outputVariables: {
+      variable: outputVariable,
+    },
+  }
+
+  return blockXML
+}
+
+const inputVariableToXml = (node: VariableNode): InVariableFbdXML => {
+  const inputVariableXML: InVariableFbdXML = {
+    '@localId': node.data.numericId,
+    '@executionOrderId': node.data.executionOrder,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    '@negated': node.data.negated,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointOut: '',
+    expression: node.data.variable.name,
+  }
+
+  return inputVariableXML
+}
+
+const outputVariableToXml = (node: VariableNode, rung: FBDRungState): OutVariableFbdXML | undefined => {
+  const inputEdges = rung.edges.filter((edge) => edge.target === node.id)
+
+  const inputConnection: OutVariableFbdXML['connectionPointIn'] = {
+    connection: inputEdges
+      .map((edge) => {
+        const sourceNode = rung.nodes.find((node) => node.id === edge.source)
+        const isConnectedToOutputConnector =
+          (sourceNode?.data as BasicNodeData).outputConnector?.id === edge.sourceHandle
+
+        return {
+          '@refLocalId': sourceNode
+            ? isConnectedToOutputConnector
+              ? (sourceNode?.data as BasicNodeData).numericId
+              : 'undefined'
+            : 'undefined',
+          '@formalParameter':
+            sourceNode?.type === 'block'
+              ? (edge.sourceHandle as string) === 'OUT'
+                ? '   '
+                : (edge.sourceHandle as string)
+              : undefined,
+        }
+      })
+      .filter((connection) => connection['@refLocalId'] !== 'undefined'),
+  }
+
+  if (inputConnection.connection.length === 0) {
+    return undefined
+  }
+
+  const outputVariableXML: OutVariableFbdXML = {
+    '@localId': node.data.numericId,
+    '@executionOrderId': node.data.executionOrder,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    '@negated': node.data.negated,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointIn: inputConnection,
+    expression: node.data.variable.name,
+  }
+
+  return outputVariableXML
+}
+
+const connectorToXml = (node: ConnectionNode, rung: FBDRungState): ConnectorFbdXML => {
+  const inputEdges = rung.edges.filter((edge) => edge.target === node.id)
+
+  const inputConnection: ConnectorFbdXML['connectionPointIn'] = {
+    relPosition: {
+      '@x': node.data.inputConnector?.relPosition.x || 0,
+      '@y': node.data.inputConnector?.relPosition.y || 0,
+    },
+    connection: inputEdges
+      .map((edge) => {
+        const sourceNode = rung.nodes.find((node) => node.id === edge.source)
+        if (!sourceNode) return undefined
+
+        return {
+          '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+          '@formalParameter':
+            sourceNode.type === 'block'
+              ? (edge.sourceHandle as string) === 'OUT'
+                ? '   '
+                : (edge.sourceHandle as string)
+              : undefined,
+        }
+      })
+      .filter((connection) => connection !== undefined),
+  }
+
+  const connectorXML: ConnectorFbdXML = {
+    '@name': node.data.variable.name,
+    '@localId': node.data.numericId,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointIn: inputConnection,
+  }
+
+  return connectorXML
+}
+
+const continuationToXml = (node: ConnectionNode): ContinuationFbdXML => {
+  const continuationXML: ContinuationFbdXML = {
+    '@name': node.data.variable.name,
+    '@localId': node.data.numericId,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointOut: {
+      relPosition: {
+        '@x': node.data.outputConnector?.relPosition.x || 0,
+        '@y': node.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+  }
+
+  return continuationXML
+}
+
+const commentToXml = (node: CommentNode): CommentFbdXML => {
+  const commentXML: CommentFbdXML = {
+    '@localId': node.data.numericId,
+    '@height': node.height ?? (node.measured?.height as number),
+    '@width': node.width ?? (node.measured?.width as number),
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    content: {
+      xhtml: {
+        '@xmlns': 'http://www.w3.org/1999/xhtml',
+        $: node.data.content,
+      },
+    },
+  }
+
+  return commentXML
+}
+
+/**
+ * Entry point to parse nodes to XML
+ */
+const fbdToXml = (rung: FBDRungState) => {
+  const fbdXML: {
+    body: {
+      FBD: FbdXML
+    }
+  } = {
+    body: {
+      FBD: {
+        block: [],
+        inVariable: [],
+        outVariable: [],
+        connector: [],
+        continuation: [],
+        comment: [],
+      },
+    },
+  }
+
+  const { nodes, edges: _edges } = rung
+  nodes.forEach((node) => {
+    switch (node.type as CustomFbdNodeTypes) {
+      case 'block':
+        fbdXML.body.FBD.block.push(blockToXml(node as BlockNode<BlockVariant>, rung))
+        break
+      case 'input-variable':
+        fbdXML.body.FBD.inVariable.push(inputVariableToXml(node as VariableNode))
+        break
+      case 'output-variable': {
+        const outputVarXml = outputVariableToXml(node as VariableNode, rung)
+        if (outputVarXml) fbdXML.body.FBD.outVariable.push(outputVarXml)
+        break
+      }
+      case 'connector':
+        fbdXML.body.FBD.connector.push(connectorToXml(node as ConnectionNode, rung))
+        break
+      case 'continuation':
+        fbdXML.body.FBD.continuation.push(continuationToXml(node as ConnectionNode))
+        break
+      case 'comment':
+        fbdXML.body.FBD.comment.push(commentToXml(node as CommentNode))
+        break
+      default:
+        break
+    }
+  })
+
+  return fbdXML
+}
+
+export { fbdToXml }
diff --git a/src/utils/PLC/xml-generator/codesys/language/il-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/language/il-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/language/il-xml.ts
rename to src/frontend/utils/PLC/xml-generator/codesys/language/il-xml.ts
diff --git a/src/frontend/utils/PLC/xml-generator/codesys/language/ladder-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
new file mode 100644
index 000000000..a8e8618f6
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
@@ -0,0 +1,644 @@
+import { BlockNode, BlockVariant } from '@root/frontend/components/_atoms/graphical-editor/ladder/block'
+import { CoilNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/coil'
+import { ContactNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/contact'
+import { ParallelNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/parallel'
+import { PowerRailNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/power-rail'
+import { BasicNodeData } from '@root/frontend/components/_atoms/graphical-editor/ladder/utils/types'
+import { VariableNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/variable'
+import { RungLadderState } from '@root/frontend/store/slices'
+import {
+  BlockLadderXML,
+  CoilLadderXML,
+  ContactLadderXML,
+  InVariableLadderXML,
+  LadderXML,
+  LeftPowerRailLadderXML,
+  OutVariableLadderXML,
+  RightPowerRailLadderXML,
+} from '@root/types/PLC/xml-data/codesys/pous/languages/ladder-diagram'
+import { Node } from '@xyflow/react'
+
+/**
+ * Find the connections of a node in a rung.
+ */
+const findNodeBasedOnParallelOpen = (
+  parallelNode: ParallelNode,
+  rung: RungLadderState,
+  path: {
+    nodes: Node<BasicNodeData>[]
+    parallels: ParallelNode[]
+  } = { nodes: [], parallels: [] },
+) => {
+  const { nodes: rungNodes, edges: rungEdges } = rung
+
+  const edgeToParallelNode = rungEdges.find((edge) => edge.target === parallelNode.id)?.source
+  const sourceNodeOfParallelNode = rungNodes.find((node) => node.id === edgeToParallelNode) as Node<BasicNodeData>
+  path.parallels.push(parallelNode)
+
+  if (sourceNodeOfParallelNode.type !== 'parallel') {
+    path.nodes.push(sourceNodeOfParallelNode)
+    return path
+  } else if ((sourceNodeOfParallelNode as ParallelNode).data.type === 'close') {
+    return findNodesBasedOnParallelClose(sourceNodeOfParallelNode as ParallelNode, rung, path)
+  } else {
+    return findNodeBasedOnParallelOpen(sourceNodeOfParallelNode as ParallelNode, rung, path)
+  }
+}
+
+const findNodesBasedOnParallelClose = (
+  parallelNode: ParallelNode,
+  rung: RungLadderState,
+  path: {
+    nodes: Node<BasicNodeData>[]
+    parallels: ParallelNode[]
+  } = { nodes: [], parallels: [] },
+) => {
+  const { nodes: rungNodes, edges: rungEdges } = rung
+
+  const edgesToParallelNode = rungEdges.filter((edge) => edge.target === parallelNode.id)
+  const serialNode = rungNodes.find((node) =>
+    edgesToParallelNode.find(
+      (edge) => edge.source === node.id && edge.targetHandle === parallelNode.data.inputConnector?.id,
+    ),
+  ) as Node<BasicNodeData>
+
+  if (!path.nodes.includes(serialNode)) path.nodes.push(serialNode)
+
+  const bottomNode = rungNodes.find((node) =>
+    edgesToParallelNode.find(
+      (edge) => edge.source === node.id && edge.targetHandle === parallelNode.data.parallelInputConnector?.id,
+    ),
+  ) as Node<BasicNodeData>
+
+  path.parallels.push(parallelNode)
+
+  if (bottomNode.type !== 'parallel') {
+    path.nodes.push(bottomNode)
+    return path
+  }
+
+  return findNodesBasedOnParallelClose(bottomNode as ParallelNode, rung, path)
+}
+
+const findConnections = (node: Node<BasicNodeData>, rung: RungLadderState, offsetY: number = 0) => {
+  const { nodes: rungNodes, edges: rungEdges } = rung
+
+  const connectedEdges = rungEdges.filter((edge) => edge.target === node.id)
+  if (!connectedEdges.length) return []
+
+  const connections = connectedEdges.map((edge) => {
+    const sourceNode = rungNodes.find((node) => node.id === edge.source) as Node<BasicNodeData>
+    // If the source node is not found or it is a variable node, return undefined
+    if (!sourceNode || sourceNode.type === 'variable') return undefined
+
+    // Node is not a parallel node
+    if (sourceNode.type !== 'parallel') {
+      return {
+        '@refLocalId': sourceNode.data.numericId,
+        '@formalParameter':
+          sourceNode.data.outputConnector?.id === 'OUT' ? '' : sourceNode.data.outputConnector?.id || '',
+        position: [
+          // Final edge destination
+          {
+            '@x': node.data.inputConnector?.glbPosition.x ?? 0,
+            '@y': (node.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+          },
+          // Initial edge source
+          {
+            '@x': sourceNode.data.outputConnector?.glbPosition.x ?? 0,
+            '@y': (sourceNode.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+          },
+        ],
+      }
+    }
+
+    // Node is a parallel node
+    const parallelNode = sourceNode as ParallelNode
+
+    /**
+     * TODO: This is a temporary solution to find the connections of a parallel node.
+     * This should be refactored so that the lines are placed correctly
+     */
+
+    // If the parallel node is opening the connection
+    if (parallelNode.data.type === 'open') {
+      // Find the previous node of the parallel node
+      const { nodes, parallels } = findNodeBasedOnParallelOpen(parallelNode, rung)
+      const actualNode = node
+
+      const lastParallelNode = parallels
+        .filter((parallel) => parallel.data.type === 'open')
+        .reverse()
+        .copyWithin(0, 1)[0]
+      const lastParallelSerialEdge = rungEdges.find(
+        (edge) =>
+          edge.source === lastParallelNode.id && edge.sourceHandle === lastParallelNode.data.outputConnector?.id,
+      )
+
+      // If the node is connected serially to the parallel node
+      if (lastParallelSerialEdge && lastParallelSerialEdge.target === node.id) {
+        return nodes.map((node, index) => ({
+          '@refLocalId': node.data.numericId,
+          '@formalParameter': node.data.outputConnector?.id === 'OUT' ? '' : node.data.outputConnector?.id || '',
+          position:
+            index === 0
+              ? [
+                  // Final edge destination
+                  {
+                    '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                    '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Initial edge source
+                  {
+                    '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                    '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                ]
+              : [
+                  // Final edge destination
+                  {
+                    '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                    '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Final position of parallel
+                  {
+                    '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                    '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Initial position of parallel
+                  {
+                    '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                    '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Initial edge source
+                  {
+                    '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                    '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                ],
+        }))
+      }
+
+      // If the node is connected in parallel to the parallel node
+      // const sourceNodeOfParallelNode = nodes[0]
+      // return {
+      //   '@refLocalId': sourceNodeOfParallelNode.data.numericId,
+      //   '@formalParameter': sourceNodeOfParallelNode.data.outputConnector?.id,
+      //   position: [
+      //     // Final edge destination
+      //     {
+      //       '@x': node.data.inputConnector?.glbPosition.x ?? 0,
+      //       '@y': (node.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+      //     },
+      //     // Final position of parallel
+      //     {
+      //       '@x': lastParallelNode.data.parallelOutputConnector?.glbPosition.x ?? 0,
+      //       '@y': (node.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+      //     },
+      //     // Initial position of parallel
+      //     {
+      //       '@x': lastParallelNode.data.parallelOutputConnector?.glbPosition.x ?? 0,
+      //       '@y': (sourceNodeOfParallelNode.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+      //     },
+      //     // Initial edge source
+      //     {
+      //       '@x': sourceNodeOfParallelNode.data.outputConnector?.glbPosition.x ?? 0,
+      //       '@y': (sourceNodeOfParallelNode.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+      //     },
+      //   ],
+      // }
+
+      return nodes.map((node) => {
+        return {
+          '@refLocalId': node.data.numericId,
+          '@formalParameter': node.data.outputConnector?.id === 'OUT' ? '' : node.data.outputConnector?.id || '',
+          position: [
+            // Final edge destination
+            {
+              '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+              '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+            // Final position of parallel
+            {
+              '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+              '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+            // Initial position of parallel
+            {
+              '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+              '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+            // Initial edge source
+            {
+              '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+              '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+          ],
+        }
+      })
+    }
+
+    // If the parallel node is closing the connection
+    const { nodes, parallels } = findNodesBasedOnParallelClose(parallelNode, rung)
+    const actualNode = node
+
+    const firstParallelNode = parallels[0]
+    const closeConnections = nodes.map((node, index) => {
+      return {
+        '@refLocalId': node.data.numericId,
+        '@formalParameter': node.data.outputConnector?.id === 'OUT' ? '' : node.data.outputConnector?.id || '',
+        position:
+          index === 0
+            ? [
+                // Final edge destination
+                {
+                  '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                  '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Initial edge source
+                {
+                  '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                  '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+              ]
+            : [
+                // Final edge destination
+                {
+                  '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                  '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Final position of parallel
+                {
+                  '@x': firstParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                  '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Initial position of parallel
+                {
+                  '@x': firstParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                  '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Initial edge source
+                {
+                  '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                  '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+              ],
+      }
+    })
+
+    return closeConnections
+  })
+
+  return connections.flat().filter((connection) => connection !== undefined) as {
+    '@refLocalId': string
+    '@formalParameter': string
+    position: {
+      '@x': number
+      '@y': number
+    }[]
+  }[]
+}
+
+/**
+ * Parse nodes to XML
+ */
+const leftRailToXML = (leftRail: PowerRailNode, offsetY: number = 0): LeftPowerRailLadderXML => {
+  return {
+    '@localId': leftRail.data.numericId,
+    '@width': leftRail.width as number,
+    '@height': leftRail.height as number,
+    position: {
+      '@x': leftRail.position.x,
+      '@y': (leftRail.position.y ?? 0) + offsetY,
+    },
+    connectionPointOut: {
+      '@formalParameter': 'none',
+    },
+  }
+}
+
+const rightRailToXML = (
+  rightRail: PowerRailNode,
+  _rung: RungLadderState,
+  offsetY: number = 0,
+): RightPowerRailLadderXML => {
+  return {
+    '@localId': rightRail.data.numericId,
+    '@width': rightRail.width as number,
+    '@height': rightRail.height as number,
+    position: {
+      '@x': rightRail.position.x,
+      '@y': (rightRail.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: '',
+  }
+}
+
+const contactToXML = (
+  contact: ContactNode,
+  rung: RungLadderState,
+  offsetY: number = 0,
+  leftRailId: string,
+): ContactLadderXML => {
+  const connections = findConnections(contact, rung, offsetY)
+
+  const railConnection = connections.find((connection) => {
+    const rail = rung.nodes.find((node) => node.type === 'powerRail' && (node as PowerRailNode).data.variant === 'left')
+    if (rail?.data.numericId === connection['@refLocalId']) {
+      return true
+    }
+    return false
+  })
+
+  return {
+    '@localId': contact.data.numericId,
+    '@negated': contact.data.variant === 'negated',
+    '@edge':
+      contact.data.variant === 'risingEdge' ? 'rising' : contact.data.variant === 'fallingEdge' ? 'falling' : undefined,
+    '@width': contact.width as number,
+    '@height': contact.height as number,
+    position: {
+      '@x': contact.position.x,
+      '@y': (contact.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      connection: connections.map((connection) => {
+        const connectionNode = rung.nodes.find((node) => node.data.numericId === connection['@refLocalId'])
+        const refLocalId = railConnection ? leftRailId.toString() : connection['@refLocalId']
+        const formalParameter =
+          connectionNode?.type === 'block'
+            ? (connectionNode as BlockNode<BlockVariant>).data.variant.type === 'function'
+              ? (connectionNode as BlockNode<BlockVariant>).data.variant.name
+              : connection['@formalParameter']
+            : undefined
+        return {
+          '@refLocalId': refLocalId,
+          '@formalParameter': formalParameter,
+        }
+      }),
+    },
+    connectionPointOut: '',
+    variable: contact.data.variable && contact.data.variable.name !== '' ? contact.data.variable.name : 'A',
+  }
+}
+
+const coilToXml = (coil: CoilNode, rung: RungLadderState, offsetY: number = 0, leftRailId: string): CoilLadderXML => {
+  const connections = findConnections(coil, rung, offsetY)
+
+  const railConnection = connections.find((connection) => {
+    const rail = rung.nodes.find((node) => node.type === 'powerRail' && (node as PowerRailNode).data.variant === 'left')
+    if (rail?.data.numericId === connection['@refLocalId']) {
+      return true
+    }
+    return false
+  })
+
+  return {
+    '@localId': coil.data.numericId,
+    '@negated': coil.data.variant === 'negated',
+    '@edge':
+      coil.data.variant === 'risingEdge' ? 'rising' : coil.data.variant === 'fallingEdge' ? 'falling' : undefined,
+    '@storage': coil.data.variant === 'set' ? 'set' : coil.data.variant === 'reset' ? 'reset' : undefined,
+    '@width': coil.width as number,
+    '@height': coil.height as number,
+    position: {
+      '@x': coil.position.x,
+      '@y': (coil.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      connection: connections.map((connection) => {
+        const connectionNode = rung.nodes.find((node) => node.data.numericId === connection['@refLocalId'])
+        const refLocalId = railConnection ? leftRailId.toString() : connection['@refLocalId']
+        const formalParameter =
+          connectionNode?.type === 'block'
+            ? (connectionNode as BlockNode<BlockVariant>).data.variant.type === 'function'
+              ? (connectionNode as BlockNode<BlockVariant>).data.variant.name
+              : connection['@formalParameter']
+            : undefined
+        return {
+          '@refLocalId': refLocalId,
+          '@formalParameter': formalParameter,
+        }
+      }),
+    },
+    connectionPointOut: '',
+    variable: coil.data.variable && coil.data.variable.name !== '' ? coil.data.variable.name : 'A',
+  }
+}
+
+const blockToXml = (
+  block: BlockNode<BlockVariant>,
+  rung: RungLadderState,
+  offsetY: number = 0,
+  leftRailId: string,
+): BlockLadderXML => {
+  const connections = findConnections(block, rung, offsetY)
+
+  // If the block is connected to a power rail, replace the refLocalId with the left rail id at connections
+  const railConnection = connections.find((connection) => {
+    const rail = rung.nodes.find((node) => node.type === 'powerRail' && (node as PowerRailNode).data.variant === 'left')
+    if (rail?.data.numericId === connection['@refLocalId']) {
+      return true
+    }
+    return false
+  })
+
+  const inputVariables = block.data.inputHandles.map((handle) => {
+    // Only the input of the block contains connections from other blocks
+    // The other handles are connected to variables
+    if (handle.id === block.data.inputConnector?.id) {
+      return {
+        '@formalParameter': handle.id || '',
+        connectionPointIn: {
+          connection: connections.map((connection) => {
+            const connectionNode = rung.nodes.find((node) => node.data.numericId === connection['@refLocalId'])
+            const refLocalId = railConnection ? leftRailId.toString() : connection['@refLocalId']
+            const formalParameter = connectionNode?.type === 'block' ? connection['@formalParameter'] : undefined
+            return {
+              '@refLocalId': refLocalId,
+              '@formalParameter': formalParameter,
+            }
+          }),
+        },
+      }
+    }
+
+    // Check if the handle is connected to an existing variable node
+    const variableNode = rung.nodes.find(
+      (node) =>
+        node.type === 'variable' &&
+        (node as VariableNode).data.block.id === block.id &&
+        (node as VariableNode).data.block.handleId === handle.id,
+    ) as Node<BasicNodeData>
+    if (!variableNode) return undefined
+
+    return {
+      '@formalParameter': handle.id || '',
+      connectionPointIn: {
+        connection: [
+          {
+            '@refLocalId': variableNode.data.numericId,
+          },
+        ],
+      },
+    }
+  })
+
+  const outputVariable = block.data.outputHandles.map((handle, handleIndex) => {
+    const edge = rung.edges.find((edge) => edge.source === block.id && edge.sourceHandle === handle.id)
+    const connectedNode = rung.nodes.find((node) => node.id === edge?.target)
+
+    return {
+      '@formalParameter':
+        handle.id === 'OUT' ? (block.data.variant.type === 'function' ? block.data.variant.name : '') : handle.id || '',
+      connectionPointOut: {
+        expression:
+          handleIndex !== 0
+            ? connectedNode && connectedNode.type === 'variable'
+              ? (connectedNode as VariableNode).data.variable.name
+              : ''
+            : undefined,
+      },
+    }
+  })
+
+  return {
+    '@localId': block.data.numericId,
+    '@typeName': block.data.variant.name,
+    '@instanceName': block.data.variant.type === 'function-block' ? block.data.variable.name : undefined,
+    '@width': block.width as number,
+    '@height': block.height as number,
+    '@executionOrderId': block.data.executionOrder,
+    position: {
+      '@x': block.position.x,
+      '@y': (block.position.y ?? 0) + offsetY,
+    },
+    inputVariables: {
+      variable: inputVariables.filter((variable) => variable !== undefined),
+    },
+    inOutVariables: '',
+    outputVariables: {
+      variable: outputVariable.filter((variable) => variable !== undefined),
+    },
+  }
+}
+
+const inVariableToXML = (variable: VariableNode, offsetY: number = 0): InVariableLadderXML => {
+  return {
+    '@localId': variable.data.numericId,
+    '@executionOrderId': variable.data.executionOrder,
+    '@width': variable.width as number,
+    '@height': variable.height as number,
+    '@negated': false,
+    position: {
+      '@x': variable.position.x,
+      '@y': (variable.position.y ?? 0) + offsetY,
+    },
+    connectionPointOut: '',
+    expression: variable.data.variable.name,
+  }
+}
+
+const outVariableToXML = (
+  variable: VariableNode,
+  rung: RungLadderState,
+  offsetY: number = 0,
+): OutVariableLadderXML | undefined => {
+  const connectedBlock = rung.nodes.find((node) => node.id === variable.data.block.id) as BlockNode<BlockVariant>
+
+  if (variable.data.block.handleId !== connectedBlock.data.outputConnector?.id) return undefined
+
+  return {
+    '@localId': variable.data.numericId,
+    '@executionOrderId': variable.data.executionOrder,
+    '@width': variable.width as number,
+    '@height': variable.height as number,
+    '@negated': false,
+    position: {
+      '@x': variable.position.x,
+      '@y': (variable.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      connection: [
+        {
+          '@refLocalId': connectedBlock.data.numericId,
+          '@formalParameter':
+            variable.data.block.handleId === 'OUT'
+              ? connectedBlock.data.variant.type === 'function'
+                ? connectedBlock.data.variant.name
+                : ''
+              : variable.data.block.handleId || '',
+        },
+      ],
+    },
+    expression: variable.data.variable.name,
+  }
+}
+
+/**
+ * Entry point to parse nodes to XML
+ */
+const ladderToXml = (rungs: RungLadderState[]) => {
+  const ladderXML: {
+    body: {
+      LD: LadderXML
+    }
+  } = {
+    body: {
+      LD: {
+        leftPowerRail: [],
+        block: [],
+        contact: [],
+        coil: [],
+        inVariable: [],
+        outVariable: [],
+        rightPowerRail: [],
+      },
+    },
+  }
+  let offsetY = 0
+  let leftRailId = ''
+  rungs.forEach((rung, _index) => {
+    const { nodes } = rung
+
+    nodes.forEach((node) => {
+      switch (node.type) {
+        case 'powerRail':
+          if ((node as PowerRailNode).data.variant === 'left' && ladderXML.body.LD.leftPowerRail.length === 0) {
+            ladderXML.body.LD.leftPowerRail.push(leftRailToXML(node as PowerRailNode, offsetY))
+            leftRailId = (node as PowerRailNode).data.numericId
+          } else {
+            if (ladderXML.body.LD.rightPowerRail.length === 0) {
+              ladderXML.body.LD.rightPowerRail.push(rightRailToXML(node as PowerRailNode, rung, offsetY))
+            }
+          }
+          break
+        case 'contact':
+          ladderXML.body.LD.contact.push(contactToXML(node as ContactNode, rung, offsetY, leftRailId))
+          break
+        case 'coil':
+          ladderXML.body.LD.coil.push(coilToXml(node as CoilNode, rung, offsetY, leftRailId))
+          break
+        case 'block':
+          ladderXML.body.LD.block.push(blockToXml(node as BlockNode<BlockVariant>, rung, offsetY, leftRailId))
+          break
+        case 'variable':
+          if ((node as VariableNode).data.variable.name === '') return
+          if ((node as VariableNode).data.variant === 'input')
+            ladderXML.body.LD.inVariable.push(inVariableToXML(node as VariableNode, offsetY))
+          if ((node as VariableNode).data.variant === 'output') {
+            const outVarXML = outVariableToXML(node as VariableNode, rung, offsetY)
+            if (outVarXML) ladderXML.body.LD.outVariable.push(outVarXML)
+          }
+          break
+        default:
+          break
+      }
+    })
+    offsetY += rung.reactFlowViewport[1]
+  })
+
+  return ladderXML
+}
+
+export { ladderToXml }
diff --git a/src/utils/PLC/xml-generator/codesys/language/st-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/language/st-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/language/st-xml.ts
rename to src/frontend/utils/PLC/xml-generator/codesys/language/st-xml.ts
diff --git a/src/frontend/utils/PLC/xml-generator/codesys/pou-xml.ts b/src/frontend/utils/PLC/xml-generator/codesys/pou-xml.ts
new file mode 100644
index 000000000..69c5094fb
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/codesys/pou-xml.ts
@@ -0,0 +1,186 @@
+// import { PLCVariable } from '@root/types/PLC'
+import { FBDRungState, RungLadderState } from '@root/frontend/store/slices'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
+import { PLCPou } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/codesys'
+import { InterfaceXML } from '@root/types/PLC/xml-data/codesys/pous/interface/interface-diagram'
+import { VariableXML } from '@root/types/PLC/xml-data/codesys/variable/variable-diagram'
+
+import { fbdToXml } from './language/fbd-xml'
+import { ilToXML } from './language/il-xml'
+import { ladderToXml } from './language/ladder-xml'
+import { stToXML } from './language/st-xml'
+
+export const codeSysParseInterface = (pou: PLCPou) => {
+  const variables = pou.data.variables
+  const returnType = pou.type === 'function' ? pou.data.returnType : undefined
+
+  const xml: InterfaceXML = {}
+  variables.forEach((variable) => {
+    // const variableIsDerived = variable.type.definition === 'derived' || variable.type.definition === 'user-data-type'
+
+    let vType = {}
+    if (variable.type.definition === 'array') {
+      vType = {
+        array: {
+          dimension: variable.type.data.dimensions.map((dimension) => {
+            const lower = dimension.dimension.split('..')[0]
+            const upper = dimension.dimension.split('..')[1]
+            return {
+              '@lower': lower,
+              '@upper': upper,
+            }
+          }),
+          baseType: {
+            [variable.type.data.baseType.definition === 'user-data-type'
+              ? 'derived'
+              : variable.type.data.baseType.value === 'string'
+                ? variable.type.data.baseType.value
+                : variable.type.data.baseType.value.toUpperCase()]:
+              variable.type.data.baseType.definition === 'user-data-type'
+                ? { '@name': variable.type.data.baseType.value }
+                : '',
+          },
+        },
+      }
+    } else if (variable.type.definition === 'derived' || variable.type.definition === 'user-data-type') {
+      vType = {
+        derived: {
+          '@name': variable.type.value,
+        },
+      }
+    } else {
+      vType = {
+        [variable.type.value === 'string' ? variable.type.value : variable.type.value.toUpperCase()]: '',
+      }
+    }
+
+    const v: VariableXML = {
+      '@name': variable.name,
+      type: vType,
+    }
+
+    if (variable.location) v['@address'] = variable.location
+
+    if (variable.initialValue)
+      v.initialValue = {
+        simpleValue: {
+          '@value': variable.initialValue,
+        },
+      }
+
+    if (variable.documentation)
+      v.documentation = {
+        'xhtml:p': {
+          $: variable.documentation === '' ? ' ' : variable.documentation,
+        },
+      }
+
+    if (returnType) {
+      if (!xml.returnType) xml.returnType = {}
+
+      const isBaseType = baseTypes.includes(returnType as (typeof baseTypes)[number])
+      xml.returnType = isBaseType
+        ? { [returnType.trim().toUpperCase() === 'STRING' ? returnType.toLowerCase() : returnType.toUpperCase()]: '' }
+        : { ['derived']: { '@name': returnType } }
+    }
+
+    switch (variable.class) {
+      case 'input': {
+        if (!xml.inputVars) xml.inputVars = { variable: [] }
+        if (!xml.inputVars.variable) xml.inputVars.variable = []
+        xml.inputVars.variable.push(v)
+        return
+      }
+      case 'output': {
+        if (!xml.outputVars) xml.outputVars = { variable: [] }
+        if (!xml.outputVars.variable) xml.outputVars.variable = []
+        xml.outputVars.variable.push(v)
+        return
+      }
+      case 'inOut': {
+        if (!xml.inOutVars) xml.inOutVars = { variable: [] }
+        if (!xml.inOutVars.variable) xml.inOutVars.variable = []
+        xml.inOutVars.variable.push(v)
+        return
+      }
+      case 'external': {
+        if (!xml.externalVars) xml.externalVars = { variable: [] }
+        if (!xml.externalVars.variable) xml.externalVars.variable = []
+        xml.externalVars.variable.push(v)
+        return
+      }
+      case 'local': {
+        if (!xml.localVars) xml.localVars = { variable: [] }
+        if (!xml.localVars.variable) xml.localVars.variable = []
+        xml.localVars.variable.push(v)
+        return
+      }
+      case 'temp': {
+        if (!xml.tempVars) xml.tempVars = { variable: [] }
+        if (!xml.tempVars.variable) xml.tempVars.variable = []
+        xml.tempVars.variable.push(v)
+        return
+      }
+      default:
+        return
+    }
+  })
+
+  return xml
+}
+
+export const codeSysParsePousToXML = (xml: BaseXml, pous: PLCPou[]) => {
+  pous.forEach((pou) => {
+    const interfaceResult = codeSysParseInterface(pou)
+
+    switch (pou.data.body.language) {
+      case 'il': {
+        const result = ilToXML(pou.data.body.value)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+        })
+        return
+      }
+      case 'st': {
+        const result = stToXML(pou.data.body.value)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+        })
+        return
+      }
+      case 'ld': {
+        const rungs = pou.data.body.value.rungs
+        const result = ladderToXml(rungs as RungLadderState[])
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+        })
+        return
+      }
+      case 'fbd': {
+        const rung = pou.data.body.value.rung
+        const result = fbdToXml(rung as FBDRungState)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+        })
+        return
+      }
+      default:
+        return
+    }
+  })
+
+  return xml
+}
diff --git a/src/frontend/utils/PLC/xml-generator/old-editor/base-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/base-xml.ts
new file mode 100644
index 000000000..e38ad2a4a
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/old-editor/base-xml.ts
@@ -0,0 +1,94 @@
+import type { PLCProject } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/old-editor/base-diagram'
+import { create } from 'xmlbuilder2'
+
+import { formatDate } from '../../../format-date'
+import { oldEditorInstanceToXml } from './instances-xml'
+import { oldEditorParsePousToXML } from './pou-xml'
+
+const getBaseOldEditorXmlStructure = (): BaseXml => ({
+  project: {
+    '@xmlns': 'http://www.plcopen.org/xml/tc6_0201',
+    '@xmlns:xsd': 'http://www.w3.org/2001/XMLSchema-instance',
+    '@xmlns:xhtml': 'http://www.w3.org/1999/xhtml',
+    '@xmlns:ns1': 'http://www.plcopen.org/xml/tc6_0201',
+    fileHeader: {
+      '@companyName': 'Unknown',
+      '@productName': 'Unnamed',
+      '@productVersion': '1',
+      '@creationDateTime': formatDate(new Date()),
+    },
+    contentHeader: {
+      '@name': 'Unnamed',
+      '@modificationDateTime': formatDate(new Date()),
+      coordinateInfo: {
+        fbd: {
+          scaling: {
+            '@x': '16',
+            '@y': '16',
+          },
+        },
+        ld: {
+          scaling: {
+            '@x': '16',
+            '@y': '16',
+          },
+        },
+        sfc: {
+          scaling: {
+            '@x': '16',
+            '@y': '16',
+          },
+        },
+      },
+    },
+
+    types: {
+      dataTypes: {
+        dataType: [],
+      },
+      pous: {
+        pou: [],
+      },
+    },
+
+    instances: {
+      configurations: {
+        configuration: {
+          '@name': 'Config0',
+          resource: {
+            '@name': 'Res0',
+            task: [],
+          },
+        },
+      },
+    },
+  },
+})
+
+/**
+ * This is not being used anymore.
+ * @deprecated
+ */
+export const parseProjectToXML = (project: PLCProject): string => {
+  let xmlResult: BaseXml = getBaseOldEditorXmlStructure()
+
+  /**
+   * Parse POUs
+   */
+  const pous = project.data.pous
+  xmlResult = oldEditorParsePousToXML(xmlResult, pous)
+
+  /**
+   * Parse instances
+   */
+  const configuration = project.data.configuration
+  xmlResult = oldEditorInstanceToXml(xmlResult, configuration)
+
+  const doc = create(xmlResult)
+  doc.dec({ version: '1.0', encoding: 'utf-8' })
+  const xml = doc.end({ prettyPrint: true })
+  return xml
+}
+
+export { getBaseOldEditorXmlStructure }
diff --git a/src/utils/PLC/xml-generator/old-editor/data-type-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/data-type-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/data-type-xml.ts
rename to src/frontend/utils/PLC/xml-generator/old-editor/data-type-xml.ts
diff --git a/src/utils/PLC/xml-generator/old-editor/index.ts b/src/frontend/utils/PLC/xml-generator/old-editor/index.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/index.ts
rename to src/frontend/utils/PLC/xml-generator/old-editor/index.ts
diff --git a/src/utils/PLC/xml-generator/old-editor/instances-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/instances-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/instances-xml.ts
rename to src/frontend/utils/PLC/xml-generator/old-editor/instances-xml.ts
diff --git a/src/frontend/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts
new file mode 100644
index 000000000..c62a71552
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts
@@ -0,0 +1,340 @@
+import { CustomFbdNodeTypes } from '@root/frontend/components/_atoms/graphical-editor/fbd'
+import { BlockNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/block'
+import { CommentNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/comment'
+import { ConnectionNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/connection'
+import { BasicNodeData } from '@root/frontend/components/_atoms/graphical-editor/fbd/utils'
+import { VariableNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/variable'
+import { BlockVariant } from '@root/frontend/components/_atoms/graphical-editor/types/block'
+import { FBDRungState } from '@root/frontend/store/slices'
+import {
+  BlockFbdXML,
+  CommentFbdXML,
+  ConnectorFbdXML,
+  ContinuationFbdXML,
+  FbdXML,
+  InVariableFbdXML,
+  OutVariableFbdXML,
+} from '@root/types/PLC/xml-data/old-editor/pous/languages/fbd-diagram'
+import { Edge as FlowEdge, Node as FlowNode } from '@xyflow/react'
+
+const getEdgePaths = (edge: FlowEdge, nodes: FlowNode[]) => {
+  const sourceNodeHandle = (nodes.find((node) => node.id === edge.source)?.data as BasicNodeData).outputHandles?.find(
+    (handle) => handle.id === edge.sourceHandle,
+  )
+  const targetNodeHandle = (nodes.find((node) => node.id === edge.target)?.data as BasicNodeData).inputHandles?.find(
+    (handle) => handle.id === edge.targetHandle,
+  )
+
+  if (!sourceNodeHandle || !targetNodeHandle) {
+    return
+  }
+
+  const xyPath: { x: number; y: number }[] = []
+
+  // First add the source handle position
+  xyPath.push({
+    x: sourceNodeHandle.glbPosition.x,
+    y: sourceNodeHandle.glbPosition.y,
+  })
+  // Then add the path between the source and target handles
+  if (sourceNodeHandle.glbPosition.y !== targetNodeHandle.glbPosition.y) {
+    // First add the horizontal path to the middle path
+    const middleX = (sourceNodeHandle.glbPosition.x + targetNodeHandle.glbPosition.x) / 2
+    xyPath.push({
+      x: middleX,
+      y: sourceNodeHandle.glbPosition.y,
+    })
+    xyPath.push({
+      x: middleX,
+      y: targetNodeHandle.glbPosition.y,
+    })
+  }
+  // Finally add the target handle position
+  xyPath.push({
+    x: targetNodeHandle.glbPosition.x,
+    y: targetNodeHandle.glbPosition.y,
+  })
+
+  return xyPath
+}
+
+/**
+ * Translate react flow nodes to XML
+ */
+
+const blockToXml = (node: BlockNode<BlockVariant>, rung: FBDRungState): BlockFbdXML => {
+  const inputVariables: BlockFbdXML['inputVariables']['variable'] = node.data.inputHandles
+    .flatMap((handle) => {
+      const edges = rung.edges.filter((edge) => edge.target === node.id && edge.targetHandle === handle.id)
+      if (!edges) return undefined
+
+      return edges.map((edge) => {
+        const sourceNode = rung.nodes.find((node) => node.id === edge.source)
+        if (!sourceNode) return undefined
+
+        const path = getEdgePaths(edge, rung.nodes)
+        if (!path) return undefined
+
+        return {
+          '@formalParameter': handle.id || '',
+          connectionPointIn: {
+            relPosition: {
+              '@x': handle.relPosition.x || 0,
+              '@y': handle.relPosition.y || 0,
+            },
+            connection: [
+              {
+                '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+                '@formalParameter': sourceNode.type === 'block' ? (edge.sourceHandle as string) : undefined,
+                position: path.reverse().map((point) => ({
+                  '@x': point.x,
+                  '@y': point.y,
+                })),
+              },
+            ],
+          },
+        }
+      })
+    })
+    .filter((variable) => variable !== undefined)
+
+  const outputVariable: BlockFbdXML['outputVariables']['variable'] = node.data.outputHandles
+    .map((handle) => {
+      return {
+        '@formalParameter': handle.id || '',
+        connectionPointOut: {
+          relPosition: {
+            '@x': handle.relPosition.x || 0,
+            '@y': handle.relPosition.y || 0,
+          },
+        },
+      }
+    })
+    .filter((variable) => variable !== undefined)
+
+  const blockXML: BlockFbdXML = {
+    '@localId': node.data.numericId,
+    '@typeName': node.data.variant.name,
+    '@instanceName': node.data.variant.type === 'function-block' ? node.data.variable.name : undefined,
+    '@executionOrderId': node.data.executionOrder,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    inputVariables: {
+      variable: inputVariables,
+    },
+    inOutVariables: '',
+    outputVariables: {
+      variable: outputVariable,
+    },
+  }
+
+  return blockXML
+}
+
+const inputVariableToXml = (node: VariableNode): InVariableFbdXML => {
+  const inputVariableXML: InVariableFbdXML = {
+    '@localId': node.data.numericId,
+    '@executionOrderId': node.data.executionOrder,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    '@negated': node.data.negated,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointOut: {
+      relPosition: {
+        '@x': node.data.outputConnector?.relPosition.x || 0,
+        '@y': node.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+    expression: node.data.variable.name,
+  }
+
+  return inputVariableXML
+}
+
+const outputVariableToXml = (node: VariableNode, rung: FBDRungState): OutVariableFbdXML => {
+  const inputEdges = rung.edges.filter((edge) => edge.target === node.id)
+
+  const inputConnection: OutVariableFbdXML['connectionPointIn'] = {
+    relPosition: {
+      '@x': node.data.inputConnector?.relPosition.x || 0,
+      '@y': node.data.inputConnector?.relPosition.y || 0,
+    },
+    connection: inputEdges
+      .map((edge) => {
+        const sourceNode = rung.nodes.find((node) => node.id === edge.source)
+        if (!sourceNode) return undefined
+
+        const path = getEdgePaths(edge, rung.nodes)
+        if (!path) return undefined
+
+        return {
+          '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+          '@formalParameter': sourceNode.type === 'block' ? (edge.sourceHandle as string) : undefined,
+          position: path.reverse().map((point) => ({
+            '@x': point.x,
+            '@y': point.y,
+          })),
+        }
+      })
+      .filter((connection) => connection !== undefined),
+  }
+
+  const outputVariableXML: OutVariableFbdXML = {
+    '@localId': node.data.numericId,
+    '@executionOrderId': node.data.executionOrder,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    '@negated': node.data.negated,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointIn: inputConnection,
+    expression: node.data.variable.name,
+  }
+
+  return outputVariableXML
+}
+
+const connectorToXml = (node: ConnectionNode, rung: FBDRungState): ConnectorFbdXML => {
+  const inputEdges = rung.edges.filter((edge) => edge.target === node.id)
+
+  const inputConnection: ConnectorFbdXML['connectionPointIn'] = {
+    relPosition: {
+      '@x': node.data.inputConnector?.relPosition.x || 0,
+      '@y': node.data.inputConnector?.relPosition.y || 0,
+    },
+    connection: inputEdges
+      .map((edge) => {
+        const sourceNode = rung.nodes.find((node) => node.id === edge.source)
+        if (!sourceNode) return undefined
+
+        const path = getEdgePaths(edge, rung.nodes)
+        if (!path) return undefined
+
+        return {
+          '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+          '@formalParameter': sourceNode.type === 'block' ? (edge.sourceHandle as string) : undefined,
+          position: path.reverse().map((point) => ({
+            '@x': point.x,
+            '@y': point.y,
+          })),
+        }
+      })
+      .filter((connection) => connection !== undefined),
+  }
+
+  const connectorXML: ConnectorFbdXML = {
+    '@name': node.data.variable.name,
+    '@localId': node.data.numericId,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointIn: inputConnection,
+  }
+
+  return connectorXML
+}
+
+const continuationToXml = (node: ConnectionNode): ContinuationFbdXML => {
+  const continuationXML: ContinuationFbdXML = {
+    '@name': node.data.variable.name,
+    '@localId': node.data.numericId,
+    '@height': node.height as number,
+    '@width': node.width as number,
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    connectionPointOut: {
+      relPosition: {
+        '@x': node.data.outputConnector?.relPosition.x || 0,
+        '@y': node.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+  }
+
+  return continuationXML
+}
+
+const commentToXml = (node: CommentNode): CommentFbdXML => {
+  const commentXML: CommentFbdXML = {
+    '@localId': node.data.numericId,
+    '@height': node.height ?? (node.measured?.height as number),
+    '@width': node.width ?? (node.measured?.width as number),
+    position: {
+      '@x': node.position.x,
+      '@y': node.position.y,
+    },
+    content: {
+      'xhtml:p': {
+        $: node.data.content.length > 0 ? node.data.content : 'No comment provided',
+      },
+    },
+  }
+
+  return commentXML
+}
+
+/**
+ * Entry point to parse nodes to XML
+ */
+const fbdToXml = (rung: FBDRungState) => {
+  const fbdXML: {
+    body: {
+      FBD: FbdXML
+    }
+  } = {
+    body: {
+      FBD: {
+        block: [],
+        inVariable: [],
+        inOutVariable: [],
+        outVariable: [],
+        connector: [],
+        continuation: [],
+        comment: [],
+      },
+    },
+  }
+
+  const { nodes, edges: _edges } = rung
+  nodes.forEach((node) => {
+    switch (node.type as CustomFbdNodeTypes) {
+      case 'block':
+        fbdXML.body.FBD.block.push(blockToXml(node as BlockNode<BlockVariant>, rung))
+        break
+      case 'input-variable':
+        fbdXML.body.FBD.inVariable.push(inputVariableToXml(node as VariableNode))
+        break
+      case 'output-variable':
+        fbdXML.body.FBD.outVariable.push(outputVariableToXml(node as VariableNode, rung))
+        break
+      case 'connector':
+        fbdXML.body.FBD.connector.push(connectorToXml(node as ConnectionNode, rung))
+        break
+      case 'continuation':
+        fbdXML.body.FBD.continuation.push(continuationToXml(node as ConnectionNode))
+        break
+      case 'comment':
+        fbdXML.body.FBD.comment.push(commentToXml(node as CommentNode))
+        break
+      default:
+        break
+    }
+  })
+
+  return fbdXML
+}
+
+export { fbdToXml }
diff --git a/src/utils/PLC/xml-generator/old-editor/language/il-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/language/il-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/language/il-xml.ts
rename to src/frontend/utils/PLC/xml-generator/old-editor/language/il-xml.ts
diff --git a/src/frontend/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts
new file mode 100644
index 000000000..9cd75faea
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts
@@ -0,0 +1,591 @@
+import type {
+  BasicNodeData,
+  BlockNode,
+  BlockVariant,
+  CoilNode,
+  ContactNode,
+  ParallelNode,
+  PowerRailNode,
+  VariableNode,
+} from '@root/frontend/components/_atoms/graphical-editor/ladder/utils/types'
+import { RungLadderState } from '@root/frontend/store/slices'
+import {
+  BlockLadderXML,
+  CoilLadderXML,
+  ContactLadderXML,
+  InVariableLadderXML,
+  LadderXML,
+  LeftPowerRailLadderXML,
+  OutVariableLadderXML,
+  RightPowerRailLadderXML,
+} from '@root/types/PLC/xml-data/old-editor/pous/languages/ladder-diagram'
+import { Node } from '@xyflow/react'
+
+/**
+ * Find the connections of a node in a rung.
+ */
+const findNodeBasedOnParallelOpen = (
+  parallelNode: ParallelNode,
+  rung: RungLadderState,
+  path: {
+    nodes: Node<BasicNodeData>[]
+    parallels: ParallelNode[]
+  } = { nodes: [], parallels: [] },
+) => {
+  const { nodes: rungNodes, edges: rungEdges } = rung
+
+  const edgeToParallelNode = rungEdges.find((edge) => edge.target === parallelNode.id)?.source
+  const sourceNodeOfParallelNode = rungNodes.find((node) => node.id === edgeToParallelNode) as Node<BasicNodeData>
+  path.parallels.push(parallelNode)
+
+  if (sourceNodeOfParallelNode.type !== 'parallel') {
+    path.nodes.push(sourceNodeOfParallelNode)
+    return path
+  } else if ((sourceNodeOfParallelNode as ParallelNode).data.type === 'close') {
+    return findNodesBasedOnParallelClose(sourceNodeOfParallelNode as ParallelNode, rung, path)
+  } else {
+    return findNodeBasedOnParallelOpen(sourceNodeOfParallelNode as ParallelNode, rung, path)
+  }
+}
+
+const findNodesBasedOnParallelClose = (
+  parallelNode: ParallelNode,
+  rung: RungLadderState,
+  path: {
+    nodes: Node<BasicNodeData>[]
+    parallels: ParallelNode[]
+  } = { nodes: [], parallels: [] },
+) => {
+  const { nodes: rungNodes, edges: rungEdges } = rung
+
+  const edgesToParallelNode = rungEdges.filter((edge) => edge.target === parallelNode.id)
+  const serialNode = rungNodes.find((node) =>
+    edgesToParallelNode.find(
+      (edge) => edge.source === node.id && edge.targetHandle === parallelNode.data.inputConnector?.id,
+    ),
+  ) as Node<BasicNodeData>
+
+  if (!path.nodes.includes(serialNode)) path.nodes.push(serialNode)
+
+  const bottomNode = rungNodes.find((node) =>
+    edgesToParallelNode.find(
+      (edge) => edge.source === node.id && edge.targetHandle === parallelNode.data.parallelInputConnector?.id,
+    ),
+  ) as Node<BasicNodeData>
+
+  path.parallels.push(parallelNode)
+
+  if (bottomNode.type !== 'parallel') {
+    path.nodes.push(bottomNode)
+    return path
+  }
+
+  return findNodesBasedOnParallelClose(bottomNode as ParallelNode, rung, path)
+}
+
+const findConnections = (node: Node<BasicNodeData>, rung: RungLadderState, offsetY: number = 0) => {
+  const { nodes: rungNodes, edges: rungEdges } = rung
+
+  const connectedEdges = rungEdges.filter((edge) => edge.target === node.id)
+  if (!connectedEdges.length) return []
+
+  const connections = connectedEdges.map((edge) => {
+    const sourceNode = rungNodes.find((node) => node.id === edge.source) as Node<BasicNodeData>
+    // If the source node is not found or it is a variable node, return undefined
+    if (!sourceNode || sourceNode.type === 'variable') return undefined
+
+    // Node is not a parallel node
+    if (sourceNode.type !== 'parallel') {
+      return {
+        '@refLocalId': sourceNode.data.numericId,
+        '@formalParameter': sourceNode.data.outputConnector?.id,
+        position: [
+          // Final edge destination
+          {
+            '@x': node.data.inputConnector?.glbPosition.x ?? 0,
+            '@y': (node.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+          },
+          // Initial edge source
+          {
+            '@x': sourceNode.data.outputConnector?.glbPosition.x ?? 0,
+            '@y': (sourceNode.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+          },
+        ],
+      }
+    }
+
+    // Node is a parallel node
+    const parallelNode = sourceNode as ParallelNode
+
+    /**
+     * TODO: This is a temporary solution to find the connections of a parallel node.
+     * This should be refactored so that the lines are placed correctly
+     */
+
+    // If the parallel node is opening the connection
+    if (parallelNode.data.type === 'open') {
+      // Find the previous node of the parallel node
+      const { nodes, parallels } = findNodeBasedOnParallelOpen(parallelNode, rung)
+      const actualNode = node
+
+      const lastParallelNode = parallels
+        .filter((parallel) => parallel.data.type === 'open')
+        .reverse()
+        .copyWithin(0, 1)[0]
+      const lastParallelSerialEdge = rungEdges.find(
+        (edge) =>
+          edge.source === lastParallelNode.id && edge.sourceHandle === lastParallelNode.data.outputConnector?.id,
+      )
+
+      // If the node is connected serially to the parallel node
+      if (lastParallelSerialEdge && lastParallelSerialEdge.target === actualNode.id) {
+        return nodes.map((node, index) => ({
+          '@refLocalId': node.data.numericId,
+          '@formalParameter': node.data.outputConnector?.id,
+          position:
+            index === 0
+              ? [
+                  // Final edge destination
+                  {
+                    '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                    '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Initial edge source
+                  {
+                    '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                    '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                ]
+              : [
+                  // Final edge destination
+                  {
+                    '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                    '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Final position of parallel
+                  {
+                    '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                    '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Initial position of parallel
+                  {
+                    '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                    '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                  // Initial edge source
+                  {
+                    '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                    '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                  },
+                ],
+        }))
+      }
+
+      return nodes.map((node) => {
+        return {
+          '@refLocalId': node.data.numericId,
+          '@formalParameter': node.data.outputConnector?.id,
+          position: [
+            // Final edge destination
+            {
+              '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+              '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+            // Final position of parallel
+            {
+              '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+              '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+            // Initial position of parallel
+            {
+              '@x': lastParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+              '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+            // Initial edge source
+            {
+              '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+              '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+            },
+          ],
+        }
+      })
+    }
+
+    // If the parallel node is closing the connection
+    const { nodes, parallels } = findNodesBasedOnParallelClose(parallelNode, rung)
+    const actualNode = node
+
+    const firstParallelNode = parallels[0]
+    const closeConnections = nodes.map((node, index) => {
+      return {
+        '@refLocalId': node.data.numericId,
+        '@formalParameter': node.data.outputConnector?.id,
+        position:
+          index === 0
+            ? [
+                // Final edge destination
+                {
+                  '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                  '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Initial edge source
+                {
+                  '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                  '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+              ]
+            : [
+                // Final edge destination
+                {
+                  '@x': actualNode.data.inputConnector?.glbPosition.x ?? 0,
+                  '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Final position of parallel
+                {
+                  '@x': firstParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                  '@y': (actualNode.data.inputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Initial position of parallel
+                {
+                  '@x': firstParallelNode.data.parallelInputConnector?.glbPosition.x ?? 0,
+                  '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+                // Initial edge source
+                {
+                  '@x': node.data.outputConnector?.glbPosition.x ?? 0,
+                  '@y': (node.data.outputConnector?.glbPosition.y ?? 0) + offsetY,
+                },
+              ],
+      }
+    })
+
+    return closeConnections
+  })
+
+  return connections.flat().filter((connection) => connection !== undefined) as {
+    '@refLocalId': string
+    '@formalParameter': string
+    position: {
+      '@x': number
+      '@y': number
+    }[]
+  }[]
+}
+
+/**
+ * Parse nodes to XML
+ */
+const leftRailToXML = (leftRail: PowerRailNode, offsetY: number = 0): LeftPowerRailLadderXML => {
+  return {
+    '@localId': leftRail.data.numericId,
+    '@width': leftRail.width as number,
+    '@height': leftRail.height as number,
+    position: {
+      '@x': leftRail.position.x,
+      '@y': (leftRail.position.y ?? 0) + offsetY,
+    },
+    connectionPointOut: {
+      '@formalParameter': '',
+      relPosition: {
+        '@x': leftRail.data.outputConnector?.relPosition.x || 0,
+        '@y': leftRail.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+  }
+}
+
+const rightRailToXML = (
+  rightRail: PowerRailNode,
+  rung: RungLadderState,
+  offsetY: number = 0,
+): RightPowerRailLadderXML => {
+  const connections = findConnections(rightRail as Node<BasicNodeData>, rung, offsetY)
+
+  return {
+    '@localId': rightRail.data.numericId,
+    '@width': rightRail.width as number,
+    '@height': rightRail.height as number,
+    position: {
+      '@x': rightRail.position.x,
+      '@y': (rightRail.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      relPosition: {
+        '@x': rightRail.data.inputConnector?.relPosition.x || 0,
+        '@y': rightRail.data.inputConnector?.relPosition.y || 0,
+      },
+      connection: connections,
+    },
+  }
+}
+
+const contactToXML = (contact: ContactNode, rung: RungLadderState, offsetY: number = 0): ContactLadderXML => {
+  const connections = findConnections(contact, rung, offsetY)
+
+  return {
+    '@localId': contact.data.numericId,
+    '@negated': contact.data.variant === 'negated',
+    '@edge':
+      contact.data.variant === 'risingEdge' ? 'rising' : contact.data.variant === 'fallingEdge' ? 'falling' : undefined,
+    '@width': contact.width as number,
+    '@height': contact.height as number,
+    position: {
+      '@x': contact.position.x,
+      '@y': (contact.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      relPosition: {
+        '@x': contact.data.inputConnector?.relPosition.x || 0,
+        '@y': contact.data.inputConnector?.relPosition.y || 0,
+      },
+      connection: connections,
+    },
+    connectionPointOut: {
+      relPosition: {
+        '@x': contact.data.outputConnector?.relPosition.x || 0,
+        '@y': contact.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+    variable: contact.data.variable && contact.data.variable.name !== '' ? contact.data.variable.name : 'A',
+  }
+}
+
+const coilToXml = (coil: CoilNode, rung: RungLadderState, offsetY: number = 0): CoilLadderXML => {
+  const connections = findConnections(coil, rung, offsetY)
+
+  return {
+    '@localId': coil.data.numericId,
+    '@negated': coil.data.variant === 'negated',
+    '@edge':
+      coil.data.variant === 'risingEdge' ? 'rising' : coil.data.variant === 'fallingEdge' ? 'falling' : undefined,
+    '@storage': coil.data.variant === 'set' ? 'set' : coil.data.variant === 'reset' ? 'reset' : undefined,
+    '@width': coil.width as number,
+    '@height': coil.height as number,
+    position: {
+      '@x': coil.position.x,
+      '@y': (coil.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      relPosition: {
+        '@x': coil.data.inputConnector?.relPosition.x || 0,
+        '@y': coil.data.inputConnector?.relPosition.y || 0,
+      },
+      connection: connections,
+    },
+    connectionPointOut: {
+      relPosition: {
+        '@x': coil.data.outputConnector?.relPosition.x || 0,
+        '@y': coil.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+    variable: coil.data.variable && coil.data.variable.name !== '' ? coil.data.variable.name : 'A',
+  }
+}
+
+const blockToXml = (block: BlockNode<BlockVariant>, rung: RungLadderState, offsetY: number = 0): BlockLadderXML => {
+  const connections = findConnections(block, rung, offsetY)
+  const inputVariables = block.data.inputHandles.map((handle) => {
+    // Only the input of the block contains connections from other blocks
+    // The other handles are connected to variables
+    if (handle.id === block.data.inputConnector?.id) {
+      return {
+        '@formalParameter': handle.id || '',
+        connectionPointIn: {
+          relPosition: {
+            '@x': handle.relPosition.x || 0,
+            '@y': handle.relPosition.y || 0,
+          },
+          connection: connections,
+        },
+      }
+    }
+
+    // Check if the handle is connected to an existing variable node
+    const variableNode = rung.nodes.find(
+      (node) =>
+        node.type === 'variable' &&
+        (node as VariableNode).data.block.id === block.id &&
+        (node as VariableNode).data.block.handleId === handle.id,
+    ) as Node<BasicNodeData>
+    if (!variableNode) return undefined
+
+    return {
+      '@formalParameter': handle.id || '',
+      connectionPointIn: {
+        relPosition: {
+          '@x': handle.relPosition.x || 0,
+          '@y': handle.relPosition.y || 0,
+        },
+        connection: [
+          {
+            '@refLocalId': variableNode.data.numericId,
+            position: [
+              // Connection at the block
+              {
+                '@x': handle.glbPosition.x || 0,
+                '@y': (handle.glbPosition.y || 0) + offsetY,
+              },
+              // Start the edge connecting the variable
+              {
+                '@x': variableNode.data.outputConnector?.glbPosition.x || 0,
+                '@y': (variableNode.data.outputConnector?.glbPosition.y || 0) + offsetY,
+              },
+            ],
+          },
+        ],
+      },
+    }
+  })
+
+  const outputVariable = block.data.outputHandles.map((handle) => {
+    return {
+      '@formalParameter': handle.id || '',
+      connectionPointOut: {
+        relPosition: {
+          '@x': handle.relPosition.x || 0,
+          '@y': handle.relPosition.y || 0,
+        },
+      },
+    }
+  })
+
+  return {
+    '@localId': block.data.numericId,
+    '@typeName': block.data.variant.name,
+    '@instanceName': block.data.variant.type === 'function-block' ? block.data.variable.name : undefined,
+    '@width': block.width as number,
+    '@height': block.height as number,
+    '@executionOrderId': block.data.executionOrder,
+    position: {
+      '@x': block.position.x,
+      '@y': (block.position.y ?? 0) + offsetY,
+    },
+    inputVariables: {
+      variable: inputVariables.filter((variable) => variable !== undefined),
+    },
+    inOutVariables: '',
+    outputVariables: {
+      variable: outputVariable.filter((variable) => variable !== undefined),
+    },
+  }
+}
+
+const inVariableToXML = (variable: VariableNode, offsetY: number = 0): InVariableLadderXML => {
+  return {
+    '@localId': variable.data.numericId,
+    '@width': variable.width as number,
+    '@height': variable.height as number,
+    '@negated': false,
+    position: {
+      '@x': variable.position.x,
+      '@y': (variable.position.y ?? 0) + offsetY,
+    },
+    connectionPointOut: {
+      relPosition: {
+        '@x': variable.data.outputConnector?.relPosition.x || 0,
+        '@y': variable.data.outputConnector?.relPosition.y || 0,
+      },
+    },
+    expression: variable.data.variable.name,
+  }
+}
+
+const outVariableToXML = (variable: VariableNode, rung: RungLadderState, offsetY: number = 0): OutVariableLadderXML => {
+  const connectedBlock = rung.nodes.find((node) => node.id === variable.data.block.id) as BlockNode<BlockVariant>
+
+  return {
+    '@localId': variable.data.numericId,
+    '@width': variable.width as number,
+    '@height': variable.height as number,
+    '@negated': false,
+    position: {
+      '@x': variable.position.x,
+      '@y': (variable.position.y ?? 0) + offsetY,
+    },
+    connectionPointIn: {
+      relPosition: {
+        '@x': variable.data.inputConnector?.relPosition.x || 0,
+        '@y': variable.data.inputConnector?.relPosition.y || 0,
+      },
+      connection: [
+        {
+          '@refLocalId': connectedBlock.data.numericId,
+          '@formalParameter': variable.data.block.handleId,
+          position: [
+            // Final edge destination
+            {
+              '@x': variable.data.inputConnector?.glbPosition.x || 0,
+              '@y': (variable.data.inputConnector?.glbPosition.y || 0) + offsetY,
+            },
+            // Initial edge source
+            {
+              '@x': connectedBlock.data.outputConnector?.glbPosition.x || 0,
+              '@y': (connectedBlock.data.outputConnector?.glbPosition.y || 0) + offsetY,
+            },
+          ],
+        },
+      ],
+    },
+    expression: variable.data.variable.name,
+  }
+}
+
+/**
+ * Entry point to parse nodes to XML
+ */
+const ladderToXml = (rungs: RungLadderState[]) => {
+  const ladderXML: {
+    body: {
+      LD: LadderXML
+    }
+  } = {
+    body: {
+      LD: {
+        leftPowerRail: [],
+        rightPowerRail: [],
+        block: [],
+        contact: [],
+        coil: [],
+        inVariable: [],
+        inOutVariable: [],
+        outVariable: [],
+      },
+    },
+  }
+  let offsetY = 0
+  rungs.forEach((rung, _index) => {
+    const { nodes } = rung
+    nodes.forEach((node) => {
+      switch (node.type) {
+        case 'powerRail':
+          if ((node as PowerRailNode).data.variant === 'left')
+            ladderXML.body.LD.leftPowerRail.push(leftRailToXML(node as PowerRailNode, offsetY))
+          else ladderXML.body.LD.rightPowerRail.push(rightRailToXML(node as PowerRailNode, rung, offsetY))
+          break
+        case 'contact':
+          ladderXML.body.LD.contact.push(contactToXML(node as ContactNode, rung, offsetY))
+          break
+        case 'coil':
+          ladderXML.body.LD.coil.push(coilToXml(node as CoilNode, rung, offsetY))
+          break
+        case 'block':
+          ladderXML.body.LD.block.push(blockToXml(node as BlockNode<BlockVariant>, rung, offsetY))
+          break
+        case 'variable':
+          if ((node as VariableNode).data.variable.name === '') return
+          if ((node as VariableNode).data.variant === 'input')
+            ladderXML.body.LD.inVariable.push(inVariableToXML(node as VariableNode, offsetY))
+          if ((node as VariableNode).data.variant === 'output')
+            ladderXML.body.LD.outVariable.push(outVariableToXML(node as VariableNode, rung, offsetY))
+          break
+        default:
+          break
+      }
+    })
+    offsetY += rung.reactFlowViewport[1]
+  })
+
+  return ladderXML
+}
+
+export { ladderToXml }
diff --git a/src/utils/PLC/xml-generator/old-editor/language/st-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/language/st-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/language/st-xml.ts
rename to src/frontend/utils/PLC/xml-generator/old-editor/language/st-xml.ts
diff --git a/src/frontend/utils/PLC/xml-generator/old-editor/pou-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/pou-xml.ts
new file mode 100644
index 000000000..b00cdf63c
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/old-editor/pou-xml.ts
@@ -0,0 +1,184 @@
+import { FBDRungState, RungLadderState } from '@root/frontend/store/slices'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
+import { PLCPou } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/old-editor'
+import { InterfaceXML } from '@root/types/PLC/xml-data/old-editor/pous/interface/interface-diagram'
+import { VariableXML } from '@root/types/PLC/xml-data/old-editor/variable/variable-diagram'
+
+import { fbdToXml } from './language/fbd-xml'
+import { ilToXML } from './language/il-xml'
+import { ladderToXml } from './language/ladder-xml'
+import { stToXML } from './language/st-xml'
+import { convertTypeToXml } from './type-xml'
+
+export const oldEditorParseInterface = (pou: PLCPou) => {
+  const variables = pou.data.variables
+  const returnType = pou.type === 'function' ? pou.data.returnType : undefined
+
+  const xml: InterfaceXML = {}
+  variables.forEach((variable) => {
+    const v: VariableXML = {
+      '@name': variable.name,
+      type: convertTypeToXml(variable.type),
+    }
+
+    if (variable.location) v['@address'] = variable.location
+
+    if (variable.initialValue)
+      v.initialValue = {
+        simpleValue: {
+          '@value': variable.initialValue,
+        },
+      }
+
+    if (variable.documentation)
+      v.documentation = {
+        'xhtml:p': {
+          $: variable.documentation === '' ? ' ' : variable.documentation,
+        },
+      }
+
+    if (returnType) {
+      if (!xml.returnType) xml.returnType = {}
+
+      const isBaseType = baseTypes.includes(returnType as (typeof baseTypes)[number])
+      xml.returnType = isBaseType
+        ? { [returnType.trim().toUpperCase() === 'STRING' ? returnType.toLowerCase() : returnType.toUpperCase()]: '' }
+        : { derived: { '@name': returnType } }
+    }
+
+    switch (variable.class) {
+      case 'input': {
+        if (!xml.inputVars) xml.inputVars = { variable: [] }
+        if (!xml.inputVars.variable) xml.inputVars.variable = []
+        xml.inputVars.variable.push(v)
+        return
+      }
+      case 'output': {
+        if (!xml.outputVars) xml.outputVars = { variable: [] }
+        if (!xml.outputVars.variable) xml.outputVars.variable = []
+        xml.outputVars.variable.push(v)
+        return
+      }
+      case 'inOut': {
+        if (!xml.inOutVars) xml.inOutVars = { variable: [] }
+        if (!xml.inOutVars.variable) xml.inOutVars.variable = []
+        xml.inOutVars.variable.push(v)
+        return
+      }
+      case 'external': {
+        if (!xml.externalVars) xml.externalVars = { variable: [] }
+        if (!xml.externalVars.variable) xml.externalVars.variable = []
+        xml.externalVars.variable.push(v)
+        return
+      }
+      case 'local': {
+        if (!xml.localVars) xml.localVars = { variable: [] }
+        if (!xml.localVars.variable) xml.localVars.variable = []
+        xml.localVars.variable.push(v)
+        return
+      }
+      case 'temp': {
+        if (!xml.tempVars) xml.tempVars = { variable: [] }
+        if (!xml.tempVars.variable) xml.tempVars.variable = []
+        xml.tempVars.variable.push(v)
+        return
+      }
+      default:
+        return
+    }
+  })
+
+  return xml
+}
+
+export const oldEditorParsePousToXML = (xml: BaseXml, pous: PLCPou[]) => {
+  pous.forEach((pou) => {
+    const interfaceResult = oldEditorParseInterface(pou)
+
+    switch (pou.data.body.language) {
+      case 'il': {
+        const result = ilToXML(pou.data.body.value)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+          documentation: {
+            'xhtml:p': {
+              $: pou.data.documentation === '' ? ' ' : pou.data.documentation,
+            },
+          },
+        })
+        return
+      }
+      case 'st': {
+        const result = stToXML(pou.data.body.value)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+          documentation: {
+            'xhtml:p': {
+              $: pou.data.documentation === '' ? ' ' : pou.data.documentation,
+            },
+          },
+        })
+        return
+      }
+      case 'ld': {
+        const rungs = pou.data.body.value.rungs
+        const result = ladderToXml(rungs as RungLadderState[])
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+          documentation: {
+            'xhtml:p': {
+              $: pou.data.documentation === '' ? ' ' : pou.data.documentation,
+            },
+          },
+        })
+        return
+      }
+      case 'fbd': {
+        const rung = pou.data.body.value.rung
+        const result = fbdToXml(rung as FBDRungState)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+          documentation: {
+            'xhtml:p': {
+              $: pou.data.documentation === '' ? ' ' : pou.data.documentation,
+            },
+          },
+        })
+        return
+      }
+      case 'python':
+      case 'cpp': {
+        const result = stToXML(pou.data.body.value)
+        xml.project.types.pous.pou.push({
+          '@name': pou.data.name,
+          '@pouType': pou.type === 'function-block' ? 'functionBlock' : pou.type,
+          interface: interfaceResult,
+          body: result.body,
+          documentation: {
+            'xhtml:p': {
+              $: pou.data.documentation === '' ? ' ' : pou.data.documentation,
+            },
+          },
+        })
+        return
+      }
+      default:
+        return
+    }
+  })
+
+  return xml
+}
diff --git a/src/utils/PLC/xml-generator/old-editor/type-xml.ts b/src/frontend/utils/PLC/xml-generator/old-editor/type-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/type-xml.ts
rename to src/frontend/utils/PLC/xml-generator/old-editor/type-xml.ts
diff --git a/src2/frontend/utils/__tests__/app-constants.test.ts b/src/frontend/utils/__tests__/app-constants.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/app-constants.test.ts
rename to src/frontend/utils/__tests__/app-constants.test.ts
diff --git a/src2/frontend/utils/__tests__/cn.test.ts b/src/frontend/utils/__tests__/cn.test.ts
similarity index 84%
rename from src2/frontend/utils/__tests__/cn.test.ts
rename to src/frontend/utils/__tests__/cn.test.ts
index bd40cc71d..087bbc300 100644
--- a/src2/frontend/utils/__tests__/cn.test.ts
+++ b/src/frontend/utils/__tests__/cn.test.ts
@@ -6,7 +6,8 @@ describe('cn', () => {
   })
 
   it('handles conditional classes', () => {
-    expect(cn('foo', false && 'bar', 'baz')).toBe('foo baz')
+    const condition = false as boolean
+    expect(cn('foo', condition && 'bar', 'baz')).toBe('foo baz')
   })
 
   it('merges tailwind classes with last-wins', () => {
diff --git a/src2/frontend/utils/__tests__/device.test.ts b/src/frontend/utils/__tests__/device.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/device.test.ts
rename to src/frontend/utils/__tests__/device.test.ts
index 5c4c4a837..034607941 100644
--- a/src2/frontend/utils/__tests__/device.test.ts
+++ b/src/frontend/utils/__tests__/device.test.ts
@@ -1,9 +1,9 @@
 import {
+  getExpectedRuntimeVersion,
   isArduinoTarget,
   isOpenPLCRuntimeTarget,
-  isSimulatorTarget,
-  getExpectedRuntimeVersion,
   isOpenPLCRuntimeV4Target,
+  isSimulatorTarget,
   validateRuntimeVersion,
 } from '../device'
 
diff --git a/src2/frontend/utils/__tests__/format-date.test.ts b/src/frontend/utils/__tests__/format-date.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/format-date.test.ts
rename to src/frontend/utils/__tests__/format-date.test.ts
diff --git a/src2/frontend/utils/__tests__/format-timestamp.test.ts b/src/frontend/utils/__tests__/format-timestamp.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/format-timestamp.test.ts
rename to src/frontend/utils/__tests__/format-timestamp.test.ts
index be55fcab7..b61596c61 100644
--- a/src2/frontend/utils/__tests__/format-timestamp.test.ts
+++ b/src/frontend/utils/__tests__/format-timestamp.test.ts
@@ -1,5 +1,5 @@
-import formatTimestamp from '../format-timestamp'
 import type { TimestampFormat } from '../format-timestamp'
+import formatTimestamp from '../format-timestamp'
 
 describe('formatTimestamp', () => {
   it('returns "DD-MM-YY HH:MM:SS" when format is "full"', () => {
diff --git a/src2/frontend/utils/__tests__/formatters-pou.test.ts b/src/frontend/utils/__tests__/formatters-pou.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/formatters-pou.test.ts
rename to src/frontend/utils/__tests__/formatters-pou.test.ts
diff --git a/src2/frontend/utils/__tests__/new-graphical-editor-node-id.test.ts b/src/frontend/utils/__tests__/new-graphical-editor-node-id.test.ts
similarity index 95%
rename from src2/frontend/utils/__tests__/new-graphical-editor-node-id.test.ts
rename to src/frontend/utils/__tests__/new-graphical-editor-node-id.test.ts
index d288e3e18..82f393cc2 100644
--- a/src2/frontend/utils/__tests__/new-graphical-editor-node-id.test.ts
+++ b/src/frontend/utils/__tests__/new-graphical-editor-node-id.test.ts
@@ -29,7 +29,7 @@ describe('newGraphicalEditorNodeID', () => {
   })
 
   it('falls back to uuidv4 when crypto.randomUUID is unavailable', () => {
-    const originalRandomUUID = crypto.randomUUID
+    const originalRandomUUID = crypto.randomUUID.bind(crypto)
     Object.defineProperty(crypto, 'randomUUID', { value: undefined, configurable: true })
 
     try {
diff --git a/src2/frontend/utils/__tests__/plc-constants.test.ts b/src/frontend/utils/__tests__/plc-constants.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/plc-constants.test.ts
rename to src/frontend/utils/__tests__/plc-constants.test.ts
diff --git a/src2/frontend/utils/__tests__/unsaved-label.test.ts b/src/frontend/utils/__tests__/unsaved-label.test.ts
similarity index 100%
rename from src2/frontend/utils/__tests__/unsaved-label.test.ts
rename to src/frontend/utils/__tests__/unsaved-label.test.ts
diff --git a/src2/frontend/utils/app-constants.ts b/src/frontend/utils/app-constants.ts
similarity index 100%
rename from src2/frontend/utils/app-constants.ts
rename to src/frontend/utils/app-constants.ts
diff --git a/src/utils/cn.ts b/src/frontend/utils/cn.ts
similarity index 100%
rename from src/utils/cn.ts
rename to src/frontend/utils/cn.ts
diff --git a/src/frontend/utils/cpp/addCppLocalVariables.ts b/src/frontend/utils/cpp/addCppLocalVariables.ts
new file mode 100644
index 000000000..ddf48437d
--- /dev/null
+++ b/src/frontend/utils/cpp/addCppLocalVariables.ts
@@ -0,0 +1,37 @@
+import type { PLCPou, PLCProjectData, PLCVariable } from '../../../middleware/shared/ports/types'
+
+const createHasBeenInitializedVariable = (): PLCVariable => {
+  return {
+    name: 'hasBeenInitialized',
+    class: 'local',
+    type: {
+      definition: 'base-type',
+      value: 'BOOL',
+    },
+    location: '',
+    documentation: '',
+    debug: false,
+    initialValue: '0',
+  }
+}
+
+const addCppLocalVariables = (projectData: PLCProjectData): PLCProjectData => {
+  const processedData = structuredClone(projectData)
+
+  processedData.pous = processedData.pous.map((pou: PLCPou) => {
+    if (pou.body.language === 'cpp') {
+      const hasBeenInitializedVar = createHasBeenInitializedVariable()
+      const variables = pou.interface?.variables ?? []
+      pou.interface = {
+        ...pou.interface,
+        variables: [...variables, hasBeenInitializedVar],
+      }
+    }
+
+    return pou
+  })
+
+  return processedData
+}
+
+export { addCppLocalVariables }
diff --git a/src/frontend/utils/cpp/generateCBlocksCode.ts b/src/frontend/utils/cpp/generateCBlocksCode.ts
new file mode 100644
index 000000000..493622ceb
--- /dev/null
+++ b/src/frontend/utils/cpp/generateCBlocksCode.ts
@@ -0,0 +1,91 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { generateStructMember, isArrayVariable } from '../PLC/array-codegen-helpers'
+
+type CppPouData = {
+  name: string
+  code: string
+  variables: PLCVariable[]
+}
+
+const generateDefine = (variable: PLCVariable): string => {
+  const name = variable.name
+  const upperName = name.toUpperCase()
+
+  if (isArrayVariable(variable)) {
+    return `#define ${name} (vars->${upperName})\n`
+  }
+  return `#define ${name} (*(vars->${upperName}))\n`
+}
+
+const generateUndef = (variable: PLCVariable): string => {
+  return `#undef ${variable.name}\n`
+}
+
+const processUserCode = (pou: CppPouData): string => {
+  const structName = `${pou.name.toUpperCase()}_VARS`
+  const setupFunctionName = `${pou.name.toLowerCase()}_setup`
+  const loopFunctionName = `${pou.name.toLowerCase()}_loop`
+
+  const inputVariables = pou.variables.filter((v) => v.class === 'input')
+  const outputVariables = pou.variables.filter((v) => v.class === 'output')
+
+  let processedCode = `//definition of external blocks - ${pou.name.toUpperCase()}\n`
+  processedCode += `typedef struct {\n`
+
+  inputVariables.forEach((variable) => {
+    processedCode += generateStructMember(variable)
+  })
+
+  outputVariables.forEach((variable) => {
+    processedCode += generateStructMember(variable)
+  })
+
+  processedCode += `} ${structName};\n\n`
+
+  processedCode += `extern "C" void ${setupFunctionName}(${structName} *vars);\n`
+  processedCode += `extern "C" void ${loopFunctionName}(${structName} *vars);\n\n`
+
+  inputVariables.forEach((variable) => {
+    processedCode += generateDefine(variable)
+  })
+
+  outputVariables.forEach((variable) => {
+    processedCode += generateDefine(variable)
+  })
+
+  processedCode += '\n'
+
+  let modifiedUserCode = pou.code
+
+  modifiedUserCode = modifiedUserCode.replace(
+    /void\s+setup\s*\(\s*\)/g,
+    `void ${setupFunctionName}(${structName} *vars)`,
+  )
+
+  modifiedUserCode = modifiedUserCode.replace(/void\s+loop\s*\(\s*\)/g, `void ${loopFunctionName}(${structName} *vars)`)
+
+  processedCode += modifiedUserCode
+  processedCode += '\n'
+
+  inputVariables.forEach((variable) => {
+    processedCode += generateUndef(variable)
+  })
+  outputVariables.forEach((variable) => {
+    processedCode += generateUndef(variable)
+  })
+  processedCode += '\n'
+
+  return processedCode
+}
+
+const generateCBlocksCode = (cppPous: CppPouData[]): string => {
+  let codeContent = ''
+
+  cppPous.forEach((pou) => {
+    codeContent += processUserCode(pou)
+  })
+
+  return codeContent
+}
+
+export { type CppPouData, generateCBlocksCode }
diff --git a/src/frontend/utils/cpp/generateCBlocksHeader.ts b/src/frontend/utils/cpp/generateCBlocksHeader.ts
new file mode 100644
index 000000000..5e27f7b8d
--- /dev/null
+++ b/src/frontend/utils/cpp/generateCBlocksHeader.ts
@@ -0,0 +1,44 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { generateStructMember } from '../PLC/array-codegen-helpers'
+
+type CppPouData = {
+  name: string
+  variables: PLCVariable[]
+}
+
+const generateCBlocksHeader = (cppPous: CppPouData[]): string => {
+  let headerContent = `#ifndef C_BLOCKS_H
+#define C_BLOCKS_H
+
+`
+
+  cppPous.forEach((pou) => {
+    const structName = `${pou.name.toUpperCase()}_VARS`
+    const setupFunctionName = `${pou.name.toLowerCase()}_setup`
+    const loopFunctionName = `${pou.name.toLowerCase()}_loop`
+
+    const inputVariables = pou.variables.filter((v) => v.class === 'input')
+    const outputVariables = pou.variables.filter((v) => v.class === 'output')
+
+    headerContent += `//definition of external blocks - ${pou.name.toUpperCase()}\n`
+    headerContent += `typedef struct {\n`
+
+    inputVariables.forEach((variable) => {
+      headerContent += generateStructMember(variable)
+    })
+
+    outputVariables.forEach((variable) => {
+      headerContent += generateStructMember(variable)
+    })
+
+    headerContent += `} ${structName};\n`
+    headerContent += `void ${setupFunctionName}(${structName} *vars);\n`
+    headerContent += `void ${loopFunctionName}(${structName} *vars);\n\n`
+  })
+
+  headerContent += `#endif // C_BLOCKS_H\n`
+
+  return headerContent
+}
+
+export { type CppPouData, generateCBlocksHeader }
diff --git a/src/frontend/utils/cpp/generateSTCode.ts b/src/frontend/utils/cpp/generateSTCode.ts
new file mode 100644
index 000000000..109513bc5
--- /dev/null
+++ b/src/frontend/utils/cpp/generateSTCode.ts
@@ -0,0 +1,118 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import {
+  getArrayStartIndex,
+  getArrayTotalElements,
+  getVariableIECType,
+  isArrayVariable,
+} from '../PLC/array-codegen-helpers'
+
+type STCodeGenerationParams = {
+  pouName: string
+  allVariables: PLCVariable[]
+}
+
+/**
+ * Generate flat temporary array declarations for array variables.
+ * iec2c wraps each element in __IEC_TYPE_t (value + flags), so we need
+ * flat IEC_TYPE arrays for C code that expects contiguous typed elements.
+ */
+const generateFlatArrayDeclarations = (arrayVariables: PLCVariable[]): string => {
+  let code = ''
+  arrayVariables.forEach((variable) => {
+    const name = variable.name.toUpperCase()
+    const iecType = getVariableIECType(variable)
+    const totalElements = getArrayTotalElements(variable)
+    code += `${iecType} __flat_${name}[${totalElements}];\n`
+  })
+  return code
+}
+
+/**
+ * Generate code to copy .value from each wrapped table element into the flat array.
+ */
+const generateFlatArrayCopiesIn = (arrayVariables: PLCVariable[]): string => {
+  let code = ''
+  arrayVariables.forEach((variable) => {
+    const name = variable.name.toUpperCase()
+    const totalElements = getArrayTotalElements(variable)
+    code += `for (int __i = 0; __i < ${totalElements}; __i++) __flat_${name}[__i] = data__->${name}.value.table[__i].value;\n`
+  })
+  return code
+}
+
+/**
+ * Generate pointer assignment for a variable into the vars struct.
+ * For arrays, points to the flat temporary array with start index offset.
+ * For scalars, points to the wrapped value directly.
+ */
+const generateVariableAssignment = (variable: PLCVariable): string => {
+  const name = variable.name.toUpperCase()
+  if (isArrayVariable(variable)) {
+    const startIndex = getArrayStartIndex(variable)
+    return `vars.${name} = __flat_${name} - ${startIndex};\n`
+  }
+  return `vars.${name} = &data__->${name}.value;\n`
+}
+
+/**
+ * Generate code to copy output array values back from flat arrays to wrapped table elements.
+ */
+const generateOutputArrayCopyBack = (outputVariables: PLCVariable[]): string => {
+  let code = ''
+  outputVariables.forEach((variable) => {
+    if (isArrayVariable(variable)) {
+      const name = variable.name.toUpperCase()
+      const totalElements = getArrayTotalElements(variable)
+      code += `for (int __i = 0; __i < ${totalElements}; __i++) data__->${name}.value.table[__i].value = __flat_${name}[__i];\n`
+    }
+  })
+  return code
+}
+
+const generateSTCode = (params: STCodeGenerationParams): string => {
+  const { pouName, allVariables } = params
+
+  const inputVariables = allVariables.filter((v) => v.class === 'input')
+  const outputVariables = allVariables.filter((v) => v.class === 'output')
+
+  const structName = `${pouName.toUpperCase()}_VARS`
+  const setupFunctionName = `${pouName.toLowerCase()}_setup`
+  const loopFunctionName = `${pouName.toLowerCase()}_loop`
+
+  const allArrayVariables = [...inputVariables, ...outputVariables].filter(isArrayVariable)
+
+  const flatArrayDecl = generateFlatArrayDeclarations(allArrayVariables)
+  const flatArrayCopiesIn = generateFlatArrayCopiesIn(allArrayVariables)
+
+  let variableAssignments = ''
+  inputVariables.forEach((variable) => {
+    variableAssignments += generateVariableAssignment(variable)
+  })
+  outputVariables.forEach((variable) => {
+    variableAssignments += generateVariableAssignment(variable)
+  })
+
+  const outputCopyBack = generateOutputArrayCopyBack(outputVariables)
+
+  let stCode = `{{
+${structName} vars;
+${flatArrayDecl}${flatArrayCopiesIn}${variableAssignments}}}
+if hasBeenInitialized = False then
+{{
+${setupFunctionName}(&vars);
+}}
+hasBeenInitialized := True;
+end_if;
+{{
+${loopFunctionName}(&vars);
+}}`
+
+  if (outputCopyBack) {
+    stCode += `\n{{
+${outputCopyBack}}}`
+  }
+
+  return stCode
+}
+
+export { generateSTCode, type STCodeGenerationParams }
diff --git a/src/utils/cpp/validateCppCode.ts b/src/frontend/utils/cpp/validateCppCode.ts
similarity index 100%
rename from src/utils/cpp/validateCppCode.ts
rename to src/frontend/utils/cpp/validateCppCode.ts
diff --git a/src/utils/debug-parser.ts b/src/frontend/utils/debug-parser.ts
similarity index 100%
rename from src/utils/debug-parser.ts
rename to src/frontend/utils/debug-parser.ts
diff --git a/src/frontend/utils/debug-polling-filter.ts b/src/frontend/utils/debug-polling-filter.ts
new file mode 100644
index 000000000..0815ec6af
--- /dev/null
+++ b/src/frontend/utils/debug-polling-filter.ts
@@ -0,0 +1,410 @@
+/**
+ * Debug Polling Filter
+ *
+ * Builds the set of debug indexes that should be polled each tick,
+ * filtering to only variables that are actively needed:
+ *
+ * 1. Watched variables (debug === true in POU declaration)
+ * 2. Forced variables (currently forced, must stay polled)
+ * 3. Graph-listed variables (being plotted in real-time charts)
+ * 4. Diagram-visible variables (LD/FBD contacts, coils, variable nodes, block outputs)
+ * 5. Source-visible variables (ST/IL — regex-matched against source text)
+ * 6. Expanded nested children (only when parent hierarchy is expanded)
+ *
+ * Diagram/source scan results are cached per {pouName, language, fbContext}
+ * since the editor is read-only during debug — no recomputation needed
+ * unless the user switches tabs or FB instance selection.
+ */
+
+import type { FbInstanceInfo, PLCPou } from '../../middleware/shared/ports/types'
+import type { RootState } from '../store'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type VisibleVarsCache = {
+  pouName: string
+  language: string
+  fbContextKey: string
+  keys: Set<string>
+} | null
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a sorted array of debug indexes to poll this tick.
+ *
+ * @param state        - Current Zustand store snapshot
+ * @param allLeaves    - Full index→{compositeKey,type} map (all debug tree leaves)
+ * @param cachedResult - Previous diagram/source scan cache (or null)
+ * @returns activeIndexes (sorted) and updated cache
+ */
+export function buildActiveIndexSet(
+  state: RootState,
+  allLeaves: Map<number, { compositeKey: string; type: string }>,
+  cachedResult: VisibleVarsCache,
+): { activeIndexes: number[]; cacheResult: VisibleVarsCache } {
+  const activeKeys = new Set<string>()
+
+  const { pous } = state.project.data
+  const {
+    debugVariableIndexes,
+    debugForcedVariables,
+    debugExpandedNodes,
+    debugGraphList,
+    fbSelectedInstance,
+    fbDebugInstances,
+  } = state.workspace
+  const { editor } = state
+
+  // -----------------------------------------------------------------------
+  // 1. Watched variables (debug === true)
+  // -----------------------------------------------------------------------
+  for (const pou of pous) {
+    const variables = pou.interface?.variables ?? []
+    const watched = variables.filter((v) => v.debug === true)
+    if (watched.length === 0) continue
+
+    if (pou.pouType === 'function-block') {
+      const resolved = resolveFbInstance(pou.name, fbSelectedInstance, fbDebugInstances)
+      if (!resolved) continue
+      for (const v of watched) {
+        activeKeys.add(`${resolved.programName}:${resolved.fbVariableName}.${v.name}`)
+      }
+    } else {
+      for (const v of watched) {
+        activeKeys.add(`${pou.name}:${v.name}`)
+      }
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // 2. Forced variables
+  // -----------------------------------------------------------------------
+  for (const compositeKey of debugForcedVariables.keys()) {
+    activeKeys.add(compositeKey)
+  }
+
+  // -----------------------------------------------------------------------
+  // 3. Graph-listed variables
+  // -----------------------------------------------------------------------
+  for (const compositeKey of debugGraphList) {
+    activeKeys.add(compositeKey)
+  }
+
+  // -----------------------------------------------------------------------
+  // 4. Expanded nested children
+  //    Walk all leaves whose compositeKey contains '.' (nested) and include
+  //    them if they have a watched/forced/graphed ancestor AND every node
+  //    in the hierarchy from that ancestor down is expanded.
+  // -----------------------------------------------------------------------
+  for (const [, meta] of allLeaves) {
+    const key = meta.compositeKey
+    const colonIdx = key.indexOf(':')
+    if (colonIdx === -1) continue
+    const pouName = key.slice(0, colonIdx)
+    const varName = key.slice(colonIdx + 1)
+    if (!varName.includes('.')) continue
+
+    if (shouldPollNestedVariable(varName, pouName, activeKeys, debugExpandedNodes, debugGraphList)) {
+      activeKeys.add(key)
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // 5 & 6. Diagram-visible / Source-visible variables (cached)
+  // -----------------------------------------------------------------------
+  const editorName = editor.meta.name
+  const editorLanguage = 'language' in editor.meta ? (editor.meta.language as string) : ''
+  const currentPou = pous.find((p) => p.name === editorName)
+
+  if (currentPou) {
+    const fbCtxKey =
+      currentPou.pouType === 'function-block' ? fbSelectedInstance.get(currentPou.name.toUpperCase()) ?? '' : ''
+
+    // Check if cache is still valid
+    if (
+      cachedResult &&
+      cachedResult.pouName === editorName &&
+      cachedResult.language === editorLanguage &&
+      cachedResult.fbContextKey === fbCtxKey
+    ) {
+      for (const k of cachedResult.keys) activeKeys.add(k)
+    } else {
+      const visibleKeys = computeVisibleVariableKeys(state, currentPou, allLeaves)
+      cachedResult = { pouName: editorName, language: editorLanguage, fbContextKey: fbCtxKey, keys: visibleKeys }
+      for (const k of visibleKeys) activeKeys.add(k)
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // Resolve composite keys → debug indexes
+  // -----------------------------------------------------------------------
+  const indexSet = new Set<number>()
+  for (const key of activeKeys) {
+    const idx = debugVariableIndexes.get(key)
+    if (idx !== undefined) {
+      indexSet.add(idx)
+    }
+  }
+
+  // Also include by scanning allLeaves (handles cases where debugVariableIndexes
+  // doesn't have the key but the tree does, e.g. deeply nested fields)
+  for (const [index, meta] of allLeaves) {
+    if (activeKeys.has(meta.compositeKey)) {
+      indexSet.add(index)
+    }
+  }
+
+  const activeIndexes = Array.from(indexSet).sort((a, b) => a - b)
+  return { activeIndexes, cacheResult: cachedResult }
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the selected FB instance for a function-block POU type.
+ */
+function resolveFbInstance(
+  pouName: string,
+  fbSelectedInstance: Map<string, string>,
+  fbDebugInstances: Map<string, FbInstanceInfo[]>,
+): FbInstanceInfo | null {
+  const fbTypeKey = pouName.toUpperCase()
+  const selectedKey = fbSelectedInstance.get(fbTypeKey)
+  if (!selectedKey) return null
+  const instances = fbDebugInstances.get(fbTypeKey) ?? []
+  return instances.find((inst) => inst.key === selectedKey) ?? null
+}
+
+/**
+ * Determine if a nested variable (contains '.') should be polled.
+ *
+ * A nested variable is polled if:
+ * - It's in the graph list (for real-time plotting), OR
+ * - It has a watched/forced/graphed ancestor AND all nodes from that
+ *   ancestor to this variable are expanded in the debugger panel
+ */
+function shouldPollNestedVariable(
+  varName: string,
+  pouName: string,
+  watchedKeys: Set<string>,
+  debugExpandedNodes: Map<string, boolean>,
+  debugGraphList: string[],
+): boolean {
+  const compositeKey = `${pouName}:${varName}`
+
+  // Graph-listed → always poll
+  if (debugGraphList.includes(compositeKey)) return true
+
+  const parts = varName.split('.')
+  if (parts.length <= 1) return true
+
+  // Find the deepest watched ancestor
+  let watchedAncestorIndex = -1
+  for (let i = parts.length - 1; i >= 1; i--) {
+    const candidatePath = parts.slice(0, i).join('.')
+    if (watchedKeys.has(`${pouName}:${candidatePath}`)) {
+      watchedAncestorIndex = i
+      break
+    }
+  }
+
+  if (watchedAncestorIndex === -1) return false
+
+  // Check that all nodes from ancestor to this variable are expanded
+  for (let i = watchedAncestorIndex; i < parts.length; i++) {
+    const parentPath = parts.slice(0, i).join('.')
+    if (!(debugExpandedNodes.get(`${pouName}:${parentPath}`) ?? false)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Compute the set of composite keys visible on the active diagram (LD/FBD)
+ * or referenced in source text (ST/IL). This result is cached.
+ */
+function computeVisibleVariableKeys(
+  state: RootState,
+  currentPou: PLCPou,
+  allLeaves: Map<number, { compositeKey: string; type: string }>,
+): Set<string> {
+  const keys = new Set<string>()
+  const language = currentPou.body.language
+  const {
+    workspace: { fbSelectedInstance, fbDebugInstances },
+  } = state
+
+  // Helper to make composite key respecting FB instance context
+  const makeKey = (variableName: string): string | null => {
+    if (currentPou.pouType === 'function-block') {
+      const resolved = resolveFbInstance(currentPou.name, fbSelectedInstance, fbDebugInstances)
+      if (!resolved) return null
+      return `${resolved.programName}:${resolved.fbVariableName}.${variableName}`
+    }
+    return `${currentPou.name}:${variableName}`
+  }
+
+  // Helper to find all leaf keys matching a prefix in the debug tree
+  const addLeavesWithPrefix = (prefix: string) => {
+    for (const [, meta] of allLeaves) {
+      if (meta.compositeKey.startsWith(prefix)) {
+        keys.add(meta.compositeKey)
+      }
+    }
+  }
+
+  if (language === 'ld') {
+    collectLdVisibleKeys(state, makeKey, addLeavesWithPrefix, keys)
+  } else if (language === 'fbd') {
+    collectFbdVisibleKeys(state, makeKey, addLeavesWithPrefix, keys)
+  } else if (language === 'st' || language === 'il') {
+    collectStIlVisibleKeys(currentPou, makeKey, addLeavesWithPrefix, keys)
+  }
+
+  return keys
+}
+
+/**
+ * Collect composite keys for variables visible on a Ladder Diagram.
+ */
+function collectLdVisibleKeys(
+  state: RootState,
+  makeKey: (name: string) => string | null,
+  addLeavesWithPrefix: (prefix: string) => void,
+  keys: Set<string>,
+): void {
+  const editorName = state.editor.meta.name
+  const currentFlow = state.ladderFlows.find((f) => f.name === editorName)
+  if (!currentFlow) return
+
+  for (const rung of currentFlow.rungs) {
+    for (const node of rung.nodes) {
+      if (node.type === 'contact' || node.type === 'coil') {
+        const nodeData = node.data as { variable?: { name?: string } }
+        const varName = nodeData.variable?.name
+        if (varName) {
+          const key = makeKey(varName)
+          if (key) keys.add(key)
+        }
+      } else if (node.type === 'variable') {
+        const nodeData = node.data as { variable?: { name?: string } }
+        const varName = nodeData.variable?.name
+        if (varName) {
+          const key = makeKey(varName)
+          if (key) keys.add(key)
+        }
+      } else if (node.type === 'block') {
+        collectBlockOutputKeys(node, makeKey, addLeavesWithPrefix)
+      }
+    }
+  }
+}
+
+/**
+ * Collect composite keys for variables visible on a Function Block Diagram.
+ */
+function collectFbdVisibleKeys(
+  state: RootState,
+  makeKey: (name: string) => string | null,
+  addLeavesWithPrefix: (prefix: string) => void,
+  keys: Set<string>,
+): void {
+  const editorName = state.editor.meta.name
+  const currentFlow = state.fbdFlows.find((f) => f.name === editorName)
+  if (!currentFlow) return
+
+  for (const node of currentFlow.rung.nodes) {
+    if (node.type === 'input-variable' || node.type === 'output-variable' || node.type === 'inout-variable') {
+      const nodeData = node.data as { variable?: { name?: string } }
+      const varName = nodeData.variable?.name
+      if (varName) {
+        const key = makeKey(varName)
+        if (key) keys.add(key)
+      }
+    } else if (node.type === 'block') {
+      collectBlockOutputKeys(node, makeKey, addLeavesWithPrefix)
+    }
+  }
+}
+
+/**
+ * Collect composite keys for block output variables (shared by LD and FBD).
+ *
+ * For function-block instances: polls all sub-variables (e.g., TON0.ET, TON0.Q)
+ * For function calls: polls compiler-generated _TMP_ output variables
+ */
+function collectBlockOutputKeys(
+  node: { data: unknown },
+  makeKey: (name: string) => string | null,
+  addLeavesWithPrefix: (prefix: string) => void,
+): void {
+  const blockData = node.data as {
+    variant?: { name: string; type: string; variables?: { name: string; class: string }[] }
+    variable?: { name?: string }
+    numericId?: string
+  }
+
+  if (!blockData.variant) return
+
+  const instanceName = blockData.variable?.name
+  const blockType = blockData.variant.type
+
+  if (blockType === 'function-block' && instanceName) {
+    // Poll all sub-variables of this FB instance (e.g., TON0.ET, TON0.Q)
+    const prefix = makeKey(`${instanceName}.`)
+    if (prefix) addLeavesWithPrefix(prefix)
+  } else if (blockType === 'function' && blockData.numericId) {
+    // Poll compiler-generated _TMP_ variables for function outputs
+    // Pattern: _TMP_FUNCNAME<numericId>_OUTNAME
+    const funcName = blockData.variant.name
+    const tmpPrefix = makeKey(`_TMP_${funcName}${blockData.numericId}_`)
+    if (tmpPrefix) addLeavesWithPrefix(tmpPrefix)
+  }
+}
+
+/**
+ * Collect composite keys for variables referenced in ST/IL source text.
+ *
+ * Regex-matches each declared variable name against the source body.
+ * Also includes FB instance sub-variables when the instance name appears
+ * in the source text.
+ */
+function collectStIlVisibleKeys(
+  currentPou: PLCPou,
+  makeKey: (name: string) => string | null,
+  addLeavesWithPrefix: (prefix: string) => void,
+  keys: Set<string>,
+): void {
+  const sourceText = typeof currentPou.body.value === 'string' ? currentPou.body.value : ''
+  if (!sourceText) return
+
+  const variables = currentPou.interface?.variables ?? []
+
+  for (const v of variables) {
+    // Escape regex special characters in variable name
+    const escaped = v.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const pattern = new RegExp(`\\b${escaped}\\b`, 'i')
+
+    if (pattern.test(sourceText)) {
+      const key = makeKey(v.name)
+      if (key) {
+        keys.add(key)
+
+        // For derived-type variables (FB instances), also poll sub-variables
+        if (v.type.definition === 'derived') {
+          const prefix = makeKey(`${v.name}.`)
+          if (prefix) addLeavesWithPrefix(prefix)
+        }
+      }
+    }
+  }
+}
diff --git a/src2/frontend/utils/debug-tree-builder.ts b/src/frontend/utils/debug-tree-builder.ts
similarity index 96%
rename from src2/frontend/utils/debug-tree-builder.ts
rename to src/frontend/utils/debug-tree-builder.ts
index 0514b9192..e5e6a1d2d 100644
--- a/src2/frontend/utils/debug-tree-builder.ts
+++ b/src/frontend/utils/debug-tree-builder.ts
@@ -5,8 +5,7 @@
  * to build DebugTreeNode structures for displaying variables in the debugger.
  */
 
-import type { DebugTreeNode, PLCVariable } from '../../middleware/shared/ports/types'
-import type { PouDTO } from '../store/slices/project/types'
+import type { DebugTreeNode, PLCPou, PLCVariable } from '../../middleware/shared/ports/types'
 import type { DebugVariableEntry } from './debug-parser'
 import type { DebugNodeVisitor, TraversalContext } from './debug-tree-traversal'
 import { traverseVariable } from './debug-tree-traversal'
@@ -14,11 +13,11 @@ import { buildDebugPath, buildGlobalDebugPath } from './debug-variable-finder'
 
 /**
  * Project data shape expected by the debug tree builder.
- * Uses the store's POU format (PouDTO discriminated union).
+ * Accepts either the middleware PLCPou type or the store's PLCProjectData.pous.
  */
 interface DebugProjectData {
   dataTypes: TraversalContext['dataTypes']
-  pous: PouDTO[]
+  pous: PLCPou[]
 }
 
 const DEBUG_TREE_LOGGING = false
diff --git a/src2/frontend/utils/debug-tree-traversal.ts b/src/frontend/utils/debug-tree-traversal.ts
similarity index 97%
rename from src2/frontend/utils/debug-tree-traversal.ts
rename to src/frontend/utils/debug-tree-traversal.ts
index 0aedfee04..325281cea 100644
--- a/src2/frontend/utils/debug-tree-traversal.ts
+++ b/src/frontend/utils/debug-tree-traversal.ts
@@ -6,10 +6,8 @@
  * can use these utilities to traverse variable hierarchies consistently.
  */
 
+import type { PLCDataType, PLCPou, PLCVariable } from '../../middleware/shared/ports/types'
 import { StandardFunctionBlocks } from '../data/library/standard-function-blocks'
-import type { PLCDataType, PLCVariable } from '../../middleware/shared/ports/types'
-import type { PouDTO } from '../store/slices/project/types'
-
 import type { DebugVariableEntry } from './debug-parser'
 import {
   buildDebugPath,
@@ -26,7 +24,7 @@ export interface TraversalContext {
   /** Parsed debug variables from debug.c */
   debugVariables: DebugVariableEntry[]
   /** Project POUs for FB lookup */
-  projectPous: PouDTO[]
+  projectPous: PLCPou[]
   /** Project data types for struct lookup */
   dataTypes: PLCDataType[]
   /** Instance name from Resources configuration */
@@ -74,7 +72,7 @@ interface ArrayTypeData {
 /**
  * Check if a type is a function block (standard library or custom).
  */
-function isFunctionBlock(typeName: string, projectPous: PouDTO[]): boolean {
+function isFunctionBlock(typeName: string, projectPous: PLCPou[]): boolean {
   const typeNameUpper = typeName.toUpperCase()
 
   // Check standard library
@@ -85,7 +83,7 @@ function isFunctionBlock(typeName: string, projectPous: PouDTO[]): boolean {
 
   // Check custom FBs
   return projectPous.some(
-    (pou) => normalizeTypeString(pou.type) === 'functionblock' && pou.data.name.toUpperCase() === typeNameUpper,
+    (pou) => normalizeTypeString(pou.pouType) === 'functionblock' && pou.name.toUpperCase() === typeNameUpper,
   )
 }
 
diff --git a/src/utils/debug-variable-finder.ts b/src/frontend/utils/debug-variable-finder.ts
similarity index 100%
rename from src/utils/debug-variable-finder.ts
rename to src/frontend/utils/debug-variable-finder.ts
diff --git a/src/frontend/utils/debugger-session.ts b/src/frontend/utils/debugger-session.ts
new file mode 100644
index 000000000..4b7d4c6fb
--- /dev/null
+++ b/src/frontend/utils/debugger-session.ts
@@ -0,0 +1,281 @@
+/**
+ * Shared debugger session helpers.
+ *
+ * Builds the debug variable index map, debug tree, and FB instance map
+ * from parsed debug.c data and project structure. These artifacts are
+ * stored in the workspace Zustand store for the debugger UI.
+ *
+ * Works with the port-format types (PLCPou flat format) used by both
+ * the editor and web platforms.
+ */
+
+import type {
+  DebugTreeNode,
+  FbInstanceInfo,
+  PLCDataType,
+  PLCInstance,
+  PLCPou,
+  PLCVariable,
+} from '../../middleware/shared/ports/types'
+import type { DebugVariableEntry, ParsedDebugData } from './debug-parser'
+import { buildDebugTree } from './debug-tree-builder'
+import {
+  buildDebugPathPrefix,
+  buildGlobalDebugPath,
+  findDebugVariable,
+  findGlobalVariableIndex,
+  findInstanceName,
+  findVariableIndex,
+  findVariableIndexWithFallback,
+  type PLCInstanceMapping,
+} from './debug-variable-finder'
+
+// ---------------------------------------------------------------------------
+// 0. logCompilerEvent — shared log helper for compile/debug progress
+// ---------------------------------------------------------------------------
+
+/** Forward compile/debug progress lines to the console log. */
+export function logCompilerEvent(
+  event: { message?: string; level?: string },
+  log: (entry: { id: string; level: 'error' | 'debug' | 'info' | 'warning'; message: string }) => void,
+): void {
+  if (!event.message) return
+  event.message
+    .trim()
+    .split('\n')
+    .forEach((line) => {
+      if (line) {
+        log({
+          id: crypto.randomUUID(),
+          level: (event.level as 'error' | 'debug' | 'info' | 'warning') ?? 'info',
+          message: line,
+        })
+      }
+    })
+}
+
+// ---------------------------------------------------------------------------
+// 1. buildVariableIndexMap
+// ---------------------------------------------------------------------------
+
+export interface VariableIndexMapResult {
+  indexMap: Map<string, number>
+  warnings: string[]
+}
+
+/**
+ * Build a composite-key -> debug-index map from parsed debug variables.
+ * Pure function — caller is responsible for logging warnings.
+ */
+export function buildVariableIndexMap(
+  pous: PLCPou[],
+  instances: PLCInstance[],
+  parsed: ParsedDebugData,
+): VariableIndexMapResult {
+  const indexMap = new Map<string, number>()
+  const warnings: string[] = []
+
+  const instanceMappings: PLCInstanceMapping[] = instances.map((inst) => ({
+    name: inst.name,
+    program: inst.program,
+  }))
+
+  pous.forEach((pou) => {
+    if (pou.pouType !== 'program') return
+
+    const instanceName = findInstanceName(pou.name, instanceMappings)
+    if (!instanceName) {
+      warnings.push(`No instance found for program '${pou.name}', skipping debug variable parsing.`)
+      return
+    }
+
+    const variables = pou.interface?.variables ?? []
+    variables.forEach((v: PLCVariable) => {
+      if (v.type.definition === 'array' && v.type.data) {
+        const dimensions = v.type.data.dimensions
+        if (dimensions.length > 0) {
+          const dimMatch = dimensions[0].dimension.match(/^(-?\d+)\.\.(-?\d+)$/)
+          if (dimMatch) {
+            const startIdx = parseInt(dimMatch[1], 10)
+            const endIdx = parseInt(dimMatch[2], 10)
+            for (let i = 0; i <= endIdx - startIdx; i++) {
+              let elementIndex: number | null
+              if (v.class === 'external') {
+                const globalPath = `${buildGlobalDebugPath(v.name)}.value.table[${i}]`
+                const match = findDebugVariable(parsed.variables, globalPath)
+                elementIndex = match ? match.index : null
+              } else {
+                elementIndex = findVariableIndex(instanceName, v.name, parsed.variables, {
+                  isArrayElement: true,
+                  arrayIndex: i,
+                })
+              }
+              if (elementIndex !== null) {
+                const compositeKey = `${pou.name}:${v.name}[${startIdx + i}]`
+                indexMap.set(compositeKey, elementIndex)
+              }
+            }
+          }
+        }
+      } else {
+        const index =
+          v.class === 'external'
+            ? findGlobalVariableIndex(v.name, parsed.variables)
+            : findVariableIndexWithFallback(instanceName, v.name, parsed.variables)
+        if (index !== null) {
+          const compositeKey = `${pou.name}:${v.name}`
+          indexMap.set(compositeKey, index)
+        }
+      }
+    })
+  })
+
+  // Append any unmatched parsed variables as fallback entries
+  parsed.variables.forEach((debugVar) => {
+    if (!indexMap.has(debugVar.name)) {
+      indexMap.set(debugVar.name, debugVar.index)
+    }
+  })
+
+  return { indexMap, warnings }
+}
+
+// ---------------------------------------------------------------------------
+// 2. buildDebugVariableTreeMap
+// ---------------------------------------------------------------------------
+
+export interface DebugVariableTreeMapResult {
+  treeMap: Map<string, DebugTreeNode>
+  trees: DebugTreeNode[]
+  complexCount: number
+}
+
+/**
+ * Build a flat compositeKey -> DebugTreeNode map by traversing all program
+ * POU variables. Pure function — swallows per-variable errors to match
+ * existing behaviour.
+ */
+export function buildDebugVariableTreeMap(
+  pous: PLCPou[],
+  instances: PLCInstance[],
+  debugVariables: DebugVariableEntry[],
+  projectData: { dataTypes: PLCDataType[]; pous: PLCPou[] },
+): DebugVariableTreeMapResult {
+  const trees: DebugTreeNode[] = []
+  const treeMap = new Map<string, DebugTreeNode>()
+  let complexCount = 0
+
+  const instanceMappings: PLCInstanceMapping[] = instances.map((inst) => ({
+    name: inst.name,
+    program: inst.program,
+  }))
+
+  const addNodeAndChildrenToMap = (node: DebugTreeNode) => {
+    treeMap.set(node.compositeKey, node)
+    if (node.children) {
+      for (const child of node.children) {
+        addNodeAndChildrenToMap(child)
+      }
+    }
+  }
+
+  pous.forEach((pou) => {
+    if (pou.pouType !== 'program') return
+
+    const instanceName = findInstanceName(pou.name, instanceMappings)
+    if (!instanceName) return
+
+    const variables = pou.interface?.variables ?? []
+    variables.forEach((v: PLCVariable) => {
+      try {
+        const node = buildDebugTree(v, pou.name, instanceName, debugVariables, projectData)
+        trees.push(node)
+        addNodeAndChildrenToMap(node)
+        if (node.isComplex) {
+          complexCount++
+        }
+      } catch {
+        // Tree building failed for this variable — swallow to match existing behaviour
+      }
+    })
+
+    // Add compiler-generated _TMP_ variables for painting block output edges
+    const instancePrefix = buildDebugPathPrefix(instanceName) + '.'
+    for (const dv of debugVariables) {
+      if (!dv.name.startsWith(instancePrefix)) continue
+      const localName = dv.name.slice(instancePrefix.length)
+      if (!localName.startsWith('_TMP_')) continue
+
+      let typeName = dv.type
+      if (typeName.endsWith('_O_ENUM') || typeName.endsWith('_P_ENUM')) {
+        typeName = typeName.replace(/_(O|P)_ENUM$/, '')
+      } else if (typeName.endsWith('_ENUM')) {
+        typeName = typeName.replace(/_ENUM$/, '')
+      }
+
+      const node: DebugTreeNode = {
+        name: localName,
+        fullPath: dv.name,
+        compositeKey: `${pou.name}:${localName}`,
+        type: typeName,
+        isComplex: false,
+        debugIndex: dv.index,
+      }
+      trees.push(node)
+      addNodeAndChildrenToMap(node)
+    }
+  })
+
+  return { treeMap, trees, complexCount }
+}
+
+// ---------------------------------------------------------------------------
+// 3. buildFbInstanceMap
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a map of FB type name (uppercased) -> FbInstanceInfo[] for all
+ * derived-type variables that are function blocks.
+ */
+export function buildFbInstanceMap(pous: PLCPou[], instances: PLCInstance[]): Map<string, FbInstanceInfo[]> {
+  const fbDebugInstancesMap = new Map<string, FbInstanceInfo[]>()
+
+  const instanceMappings: PLCInstanceMapping[] = instances.map((inst) => ({
+    name: inst.name,
+    program: inst.program,
+  }))
+
+  pous.forEach((pou) => {
+    if (pou.pouType !== 'program') return
+
+    const instanceName = findInstanceName(pou.name, instanceMappings)
+    if (!instanceName) return
+
+    const variables = pou.interface?.variables ?? []
+    variables.forEach((v: PLCVariable) => {
+      if (v.type.definition !== 'derived') return
+
+      const fbTypeNameRaw = v.type.value
+      const fbTypeKey = fbTypeNameRaw.toUpperCase()
+
+      const isCustomFB = pous.some((p) => p.pouType === 'function-block' && p.name.toUpperCase() === fbTypeKey)
+
+      // Accept derived types as FB instances if they are custom FBs or match any POU
+      if (isCustomFB) {
+        const instanceInfo: FbInstanceInfo = {
+          fbTypeName: fbTypeNameRaw,
+          programName: pou.name,
+          programInstanceName: instanceName,
+          fbVariableName: v.name,
+          key: `${pou.name}:${v.name}`,
+        }
+
+        const existingInstances = fbDebugInstancesMap.get(fbTypeKey) || []
+        existingInstances.push(instanceInfo)
+        fbDebugInstancesMap.set(fbTypeKey, existingInstances)
+      }
+    })
+  })
+
+  return fbDebugInstancesMap
+}
diff --git a/src/utils/default-zod-schema-values.ts b/src/frontend/utils/default-zod-schema-values.ts
similarity index 100%
rename from src/utils/default-zod-schema-values.ts
rename to src/frontend/utils/default-zod-schema-values.ts
diff --git a/src2/frontend/utils/device.ts b/src/frontend/utils/device.ts
similarity index 100%
rename from src2/frontend/utils/device.ts
rename to src/frontend/utils/device.ts
diff --git a/src2/frontend/utils/format-date.ts b/src/frontend/utils/format-date.ts
similarity index 100%
rename from src2/frontend/utils/format-date.ts
rename to src/frontend/utils/format-date.ts
diff --git a/src2/frontend/utils/format-timestamp.ts b/src/frontend/utils/format-timestamp.ts
similarity index 100%
rename from src2/frontend/utils/format-timestamp.ts
rename to src/frontend/utils/format-timestamp.ts
diff --git a/src2/frontend/utils/formatters/POU.ts b/src/frontend/utils/formatters/POU.ts
similarity index 100%
rename from src2/frontend/utils/formatters/POU.ts
rename to src/frontend/utils/formatters/POU.ts
diff --git a/src2/frontend/utils/generate-iec-string-to-variables.ts b/src/frontend/utils/generate-iec-string-to-variables.ts
similarity index 97%
rename from src2/frontend/utils/generate-iec-string-to-variables.ts
rename to src/frontend/utils/generate-iec-string-to-variables.ts
index caeec4550..898350f45 100644
--- a/src2/frontend/utils/generate-iec-string-to-variables.ts
+++ b/src/frontend/utils/generate-iec-string-to-variables.ts
@@ -1,4 +1,4 @@
-import { LibraryState } from '../store/slices/library/types'
+import type { LibraryState } from '../../middleware/shared/ports/library-types'
 import { baseTypeSchema } from '../../middleware/shared/ports/plc-schemas'
 import type { PLCDataType, PLCPou, PLCVariable } from '../../middleware/shared/ports/types'
 
@@ -154,7 +154,7 @@ export const parseIecStringToVariables = (
     const baseCheck = baseTypeSchema.safeParse(parsedType.toLowerCase())
 
     const isUserFunctionBlock = pous?.some(
-      (pou) => pou.type === 'function-block' && pou.data.name.toLowerCase() === parsedType.toLowerCase(),
+      (pou) => pou.pouType === 'function-block' && pou.name.toLowerCase() === parsedType.toLowerCase(),
     )
 
     const isSystemFunctionBlock = libraries?.system.some((lib) => {
diff --git a/src2/frontend/utils/generate-iec-variables-to-string.ts b/src/frontend/utils/generate-iec-variables-to-string.ts
similarity index 100%
rename from src2/frontend/utils/generate-iec-variables-to-string.ts
rename to src/frontend/utils/generate-iec-variables-to-string.ts
diff --git a/src2/frontend/utils/generate-uuid.ts b/src/frontend/utils/generate-uuid.ts
similarity index 100%
rename from src2/frontend/utils/generate-uuid.ts
rename to src/frontend/utils/generate-uuid.ts
diff --git a/src/frontend/utils/get-env.ts b/src/frontend/utils/get-env.ts
new file mode 100644
index 000000000..31a7540e1
--- /dev/null
+++ b/src/frontend/utils/get-env.ts
@@ -0,0 +1,49 @@
+// TODO: This file should NOT live in src/frontend/ — it belongs in src/middleware/adapters/web/.
+// All current consumers are web-only middleware adapters, except for
+// ai-inline-completion-provider.ts which should be migrated to use AIPort instead of calling
+// the Edge API directly (the editor version already uses AIPort). Once that migration is done,
+// move this file to src/middleware/adapters/web/utils/get-env.ts and update all import paths.
+
+/**
+ * Platform-agnostic environment variable access.
+ *
+ * Wraps `import.meta.env` so that consumer files avoid TS1343 when the
+ * project tsconfig uses `module: "commonjs"` (Electron / webpack).
+ * Vite (web) and webpack DefinePlugin (editor) replace `import.meta.env`
+ * at build time, so this indirection has zero runtime cost after bundling.
+ */
+
+// @ts-expect-error TS1343 — import.meta is resolved at build time by Vite / webpack
+// NOTE: Must use `import.meta.env` (not `import.meta?.env`) so Vite's
+// module transform recognises the expression and injects env values.
+const metaEnv: Record<string, string | boolean | undefined> = import.meta.env ?? {}
+
+/**
+ * Read an environment variable by key.
+ * Returns `undefined` when the key is absent or when `import.meta` is unavailable.
+ */
+export function getEnv(key: string): string | undefined {
+  const val = metaEnv[key]
+  return typeof val === 'string' ? val : undefined
+}
+
+/**
+ * Returns `true` when running in a development build (Vite DEV / webpack development mode).
+ */
+export function isDev(): boolean {
+  return metaEnv.DEV === true || metaEnv.MODE === 'development'
+}
+
+/**
+ * Returns the base URL for Edge API requests.
+ *
+ * In development, returns `/edge-api` so that all requests are routed through
+ * the Vite dev proxy (which can inject an accessToken cookie when
+ * VITE_DEV_ACCESS_TOKEN is set).
+ *
+ * In production, returns the value of VITE_EDGE_API_URL (or localhost fallback).
+ */
+export function getEdgeApiBaseUrl(): string {
+  if (isDev()) return '/edge-api'
+  return getEnv('VITE_EDGE_API_URL') || 'http://localhost:3333'
+}
diff --git a/src/frontend/utils/get-error-message.ts b/src/frontend/utils/get-error-message.ts
new file mode 100644
index 000000000..67d2fcd59
--- /dev/null
+++ b/src/frontend/utils/get-error-message.ts
@@ -0,0 +1,5 @@
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message
+  if (typeof error === 'string') return error
+  return String(error)
+}
diff --git a/src2/frontend/utils/graphical/__tests__/drag-detection.test.ts b/src/frontend/utils/graphical/__tests__/drag-detection.test.ts
similarity index 100%
rename from src2/frontend/utils/graphical/__tests__/drag-detection.test.ts
rename to src/frontend/utils/graphical/__tests__/drag-detection.test.ts
index 82f3197bc..9f52efc65 100644
--- a/src2/frontend/utils/graphical/__tests__/drag-detection.test.ts
+++ b/src/frontend/utils/graphical/__tests__/drag-detection.test.ts
@@ -1,12 +1,12 @@
 import {
-  MIME_TYPES,
-  VALID_FBD_BLOCK_TYPES,
-  VALID_LADDER_BLOCK_TYPES,
   getFbdBlockType,
   getLadderBlockType,
   getLibraryPath,
   isFbdBlockDrag,
   isLadderBlockDrag,
+  MIME_TYPES,
+  VALID_FBD_BLOCK_TYPES,
+  VALID_LADDER_BLOCK_TYPES,
 } from '../drag-detection'
 
 function createMockDataTransfer(
diff --git a/src2/frontend/utils/graphical/__tests__/get-function-block-variables-to-cleanup.test.ts b/src/frontend/utils/graphical/__tests__/get-function-block-variables-to-cleanup.test.ts
similarity index 93%
rename from src2/frontend/utils/graphical/__tests__/get-function-block-variables-to-cleanup.test.ts
rename to src/frontend/utils/graphical/__tests__/get-function-block-variables-to-cleanup.test.ts
index 0554c2301..d3d441059 100644
--- a/src2/frontend/utils/graphical/__tests__/get-function-block-variables-to-cleanup.test.ts
+++ b/src/frontend/utils/graphical/__tests__/get-function-block-variables-to-cleanup.test.ts
@@ -1,16 +1,12 @@
-import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import type { Node } from '@xyflow/react'
 
+import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import {
   getFunctionBlockVariablesToCleanup,
   isFunctionBlockVariableInUse,
 } from '../get-function-block-variables-to-cleanup'
 
-const makeBlockNode = (
-  id: string,
-  variableName: string,
-  variantType: string,
-): Node => ({
+const makeBlockNode = (id: string, variableName: string, variantType: string): Node => ({
   id,
   type: 'block',
   position: { x: 0, y: 0 },
@@ -64,10 +60,7 @@ describe('isFunctionBlockVariableInUse', () => {
   })
 
   it('checks across multiple rungs', () => {
-    const rungs = [
-      { nodes: [makeNonBlockNode('n1')] },
-      { nodes: [makeBlockNode('n2', 'myFB', 'function-block')] },
-    ]
+    const rungs = [{ nodes: [makeNonBlockNode('n1')] }, { nodes: [makeBlockNode('n2', 'myFB', 'function-block')] }]
     expect(isFunctionBlockVariableInUse('myFB', rungs)).toBe(true)
   })
 
@@ -105,10 +98,7 @@ describe('getFunctionBlockVariablesToCleanup', () => {
   })
 
   it('skips non-block and non-function-block nodes', () => {
-    const removedNodes = [
-      makeNonBlockNode('n1'),
-      makeBlockNode('n2', 'regularFn', 'function'),
-    ]
+    const removedNodes = [makeNonBlockNode('n1'), makeBlockNode('n2', 'regularFn', 'function')]
     const allRungs: Array<{ nodes: Node[] }> = [{ nodes: [] }]
     const allVariables = [makeVariable('regularFn', 'derived')]
 
diff --git a/src2/frontend/utils/graphical/__tests__/sync-nodes-with-variables.test.ts b/src/frontend/utils/graphical/__tests__/sync-nodes-with-variables.test.ts
similarity index 87%
rename from src2/frontend/utils/graphical/__tests__/sync-nodes-with-variables.test.ts
rename to src/frontend/utils/graphical/__tests__/sync-nodes-with-variables.test.ts
index ec82dbc66..fef14ce99 100644
--- a/src2/frontend/utils/graphical/__tests__/sync-nodes-with-variables.test.ts
+++ b/src/frontend/utils/graphical/__tests__/sync-nodes-with-variables.test.ts
@@ -1,6 +1,6 @@
-import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import type { Node } from '@xyflow/react'
 
+import type { PLCVariable } from '../../../../middleware/shared/ports/types'
 import { syncNodesWithVariables, syncNodesWithVariablesFBD } from '../sync-nodes-with-variables'
 
 const makeVariable = (name: string, typeValue = 'BOOL', definition = 'base-type', id = '1'): PLCVariable =>
@@ -29,7 +29,11 @@ describe('syncNodesWithVariables', () => {
   it('updates a contact node when the variable type no longer matches BOOL', () => {
     const updateNode = vi.fn()
     const variable = makeVariable('myVar', 'INT')
-    const node = makeNode('n1', 'contact', { name: 'myVar', id: '1', type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'] })
+    const node = makeNode('n1', 'contact', {
+      name: 'myVar',
+      id: '1',
+      type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
+    })
 
     const ladderFlows = [
       {
@@ -58,7 +62,11 @@ describe('syncNodesWithVariables', () => {
   it('refreshes a contact node when variable id changes', () => {
     const updateNode = vi.fn()
     const variable = makeVariable('myVar', 'BOOL', 'base-type', '2')
-    const node = makeNode('n1', 'contact', { name: 'myVar', id: '1', type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'] })
+    const node = makeNode('n1', 'contact', {
+      name: 'myVar',
+      id: '1',
+      type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
+    })
 
     const ladderFlows = [
       {
@@ -112,7 +120,11 @@ describe('syncNodesWithVariables', () => {
   it('filters flows by editorName when provided', () => {
     const updateNode = vi.fn()
     const variable = makeVariable('myVar', 'INT')
-    const node = makeNode('n1', 'contact', { name: 'myVar', id: '1', type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'] })
+    const node = makeNode('n1', 'contact', {
+      name: 'myVar',
+      id: '1',
+      type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
+    })
 
     const ladderFlows = [
       { name: 'editor1', rungs: [{ id: 'r1', nodes: [node], edges: [] }] },
@@ -217,11 +229,16 @@ describe('syncNodesWithVariables', () => {
   it('marks a block node with matching variant as wrongVariable when type mismatches', () => {
     const updateNode = vi.fn()
     const variable = makeVariable('myVar', 'INT')
-    const node = makeNode('n1', 'block', {
-      name: 'myVar',
-      id: '1',
-      type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
-    }, { variant: { name: 'ADD' } })
+    const node = makeNode(
+      'n1',
+      'block',
+      {
+        name: 'myVar',
+        id: '1',
+        type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
+      },
+      { variant: { name: 'ADD' } },
+    )
 
     const ladderFlows = [
       {
@@ -276,9 +293,9 @@ describe('syncNodesWithVariablesFBD', () => {
   it('does not update when node has no variable', () => {
     const updateNode = vi.fn()
     const node = makeNode('n1', 'block')
-    const fbdFlows = [
-      { name: 'fbd1', rung: { nodes: [node], edges: [] } },
-    ] as unknown as Parameters<typeof syncNodesWithVariablesFBD>[1]
+    const fbdFlows = [{ name: 'fbd1', rung: { nodes: [node], edges: [] } }] as unknown as Parameters<
+      typeof syncNodesWithVariablesFBD
+    >[1]
 
     syncNodesWithVariablesFBD([makeVariable('x')], fbdFlows, updateNode)
     expect(updateNode).not.toHaveBeenCalled()
@@ -287,9 +304,9 @@ describe('syncNodesWithVariablesFBD', () => {
   it('does not update when variable not found', () => {
     const updateNode = vi.fn()
     const node = makeNode('n1', 'input-variable', { name: 'missing' } as Partial<PLCVariable>)
-    const fbdFlows = [
-      { name: 'fbd1', rung: { nodes: [node], edges: [] } },
-    ] as unknown as Parameters<typeof syncNodesWithVariablesFBD>[1]
+    const fbdFlows = [{ name: 'fbd1', rung: { nodes: [node], edges: [] } }] as unknown as Parameters<
+      typeof syncNodesWithVariablesFBD
+    >[1]
 
     syncNodesWithVariablesFBD([makeVariable('other')], fbdFlows, updateNode)
     expect(updateNode).not.toHaveBeenCalled()
@@ -298,15 +315,20 @@ describe('syncNodesWithVariablesFBD', () => {
   it('marks a block node as wrongVariable when type mismatches', () => {
     const updateNode = vi.fn()
     const variable = makeVariable('myVar', 'INT')
-    const node = makeNode('n1', 'block', {
-      name: 'myVar',
-      id: '1',
-      type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
-    }, { variant: { name: 'ADD' } })
+    const node = makeNode(
+      'n1',
+      'block',
+      {
+        name: 'myVar',
+        id: '1',
+        type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
+      },
+      { variant: { name: 'ADD' } },
+    )
 
-    const fbdFlows = [
-      { name: 'fbd1', rung: { nodes: [node], edges: [] } },
-    ] as unknown as Parameters<typeof syncNodesWithVariablesFBD>[1]
+    const fbdFlows = [{ name: 'fbd1', rung: { nodes: [node], edges: [] } }] as unknown as Parameters<
+      typeof syncNodesWithVariablesFBD
+    >[1]
 
     syncNodesWithVariablesFBD([variable], fbdFlows, updateNode)
     expect(updateNode).toHaveBeenCalledWith(
@@ -324,9 +346,9 @@ describe('syncNodesWithVariablesFBD', () => {
     const newVariable = makeVariable('myVar', 'BOOL', 'base-type', '2')
     const node = makeNode('n1', 'block', oldVariable, { variant: { name: 'BOOL' } })
 
-    const fbdFlows = [
-      { name: 'fbd1', rung: { nodes: [node], edges: [] } },
-    ] as unknown as Parameters<typeof syncNodesWithVariablesFBD>[1]
+    const fbdFlows = [{ name: 'fbd1', rung: { nodes: [node], edges: [] } }] as unknown as Parameters<
+      typeof syncNodesWithVariablesFBD
+    >[1]
 
     syncNodesWithVariablesFBD([newVariable], fbdFlows, updateNode)
     expect(updateNode).toHaveBeenCalledWith(
@@ -369,9 +391,9 @@ describe('syncNodesWithVariablesFBD', () => {
       type: { definition: 'base-type', value: 'BOOL' } as PLCVariable['type'],
     })
 
-    const fbdFlows = [
-      { name: 'fbd1', rung: { nodes: [node], edges: [] } },
-    ] as unknown as Parameters<typeof syncNodesWithVariablesFBD>[1]
+    const fbdFlows = [{ name: 'fbd1', rung: { nodes: [node], edges: [] } }] as unknown as Parameters<
+      typeof syncNodesWithVariablesFBD
+    >[1]
 
     syncNodesWithVariablesFBD([variable], fbdFlows, updateNode)
     expect(updateNode).not.toHaveBeenCalled()
@@ -390,9 +412,9 @@ describe('syncNodesWithVariablesFBD', () => {
       },
     }
 
-    const fbdFlows = [
-      { name: 'fbd1', rung: { nodes: [node], edges: [] } },
-    ] as unknown as Parameters<typeof syncNodesWithVariablesFBD>[1]
+    const fbdFlows = [{ name: 'fbd1', rung: { nodes: [node], edges: [] } }] as unknown as Parameters<
+      typeof syncNodesWithVariablesFBD
+    >[1]
 
     syncNodesWithVariablesFBD([variable], fbdFlows, updateNode)
     expect(updateNode).not.toHaveBeenCalled()
diff --git a/src/frontend/utils/graphical/constants.ts b/src/frontend/utils/graphical/constants.ts
new file mode 100644
index 000000000..0e51c5e60
--- /dev/null
+++ b/src/frontend/utils/graphical/constants.ts
@@ -0,0 +1 @@
+export const FBD_VARIABLE_NODE_TYPES = ['input-variable', 'output-variable', 'inout-variable'] as const
diff --git a/src2/frontend/utils/graphical/drag-detection.ts b/src/frontend/utils/graphical/drag-detection.ts
similarity index 100%
rename from src2/frontend/utils/graphical/drag-detection.ts
rename to src/frontend/utils/graphical/drag-detection.ts
diff --git a/src2/frontend/utils/graphical/get-function-block-variables-to-cleanup.ts b/src/frontend/utils/graphical/get-function-block-variables-to-cleanup.ts
similarity index 96%
rename from src2/frontend/utils/graphical/get-function-block-variables-to-cleanup.ts
rename to src/frontend/utils/graphical/get-function-block-variables-to-cleanup.ts
index 57188df77..0822ec15d 100644
--- a/src2/frontend/utils/graphical/get-function-block-variables-to-cleanup.ts
+++ b/src/frontend/utils/graphical/get-function-block-variables-to-cleanup.ts
@@ -1,7 +1,8 @@
-import type { PLCVariable } from '../../../middleware/shared/ports/types'
-import type { BlockVariant } from '../../components/_atoms/graphical-editor/types/block'
 import type { Node } from '@xyflow/react'
 
+import type { BlockVariant } from '../../../middleware/shared/ports/block-types'
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+
 type BlockNode = Node<{ variable?: { name: string }; variant: BlockVariant }>
 
 /**
diff --git a/src2/frontend/utils/graphical/sync-nodes-with-variables.ts b/src/frontend/utils/graphical/sync-nodes-with-variables.ts
similarity index 54%
rename from src2/frontend/utils/graphical/sync-nodes-with-variables.ts
rename to src/frontend/utils/graphical/sync-nodes-with-variables.ts
index 3ac1ffbf1..b6333b4b3 100644
--- a/src2/frontend/utils/graphical/sync-nodes-with-variables.ts
+++ b/src/frontend/utils/graphical/sync-nodes-with-variables.ts
@@ -1,9 +1,20 @@
-import type { PLCVariable } from '../../../middleware/shared/ports/types'
-import type { FBDFlowActions, FBDFlowState } from '../../store/slices/fbd/types'
-import type { LadderFlowActions, LadderFlowState } from '../../store/slices/ladder/types'
-import { FBD_VARIABLE_NODE_TYPES } from '../../components/_atoms/graphical-editor/fbd/utils/constants'
 import { Node } from '@xyflow/react'
 
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+
+type UpdateLadderNodeFn = (params: {
+  editorName: string
+  rungId: string
+  nodeId: string
+  node: import('@xyflow/react').Node
+}) => void
+
+type UpdateFBDNodeFn = (params: { editorName: string; nodeId: string; node: import('@xyflow/react').Node }) => void
+
+type LadderRung = { id: string; nodes: import('@xyflow/react').Node[] }
+type LadderFlow = { name: string; rungs: LadderRung[] }
+type FBDFlow = { name: string; rung: { nodes: import('@xyflow/react').Node[] } }
+
 const getBlockExpectedType = (node: Node): string => {
   const variant = (node.data as { variant?: { name?: string } }).variant
 
@@ -23,8 +34,8 @@ const sameType = (firstType: string, secondType: string) =>
 
 export const syncNodesWithVariables = (
   newVars: PLCVariable[],
-  ladderFlows: LadderFlowState['ladderFlows'],
-  updateNode: LadderFlowActions['updateNode'],
+  ladderFlows: LadderFlow[],
+  updateNode: UpdateLadderNodeFn,
   editorName?: string,
 ) => {
   const flowsToSync = editorName ? ladderFlows.filter((flow) => flow.name === editorName) : ladderFlows
@@ -38,34 +49,7 @@ export const syncNodesWithVariables = (
 
         const target = newVars.find((v) => v.name.toLowerCase() === nodeVar.name.toLowerCase())
 
-        if (!target) {
-          return
-        }
-
-        const isVariableNode = node.type === 'variable'
-
-        if (isVariableNode) {
-          const needsUpdate =
-            nodeVar.name.toLowerCase() !== target.name.toLowerCase() ||
-            (node.data as { wrongVariable?: boolean }).wrongVariable
-
-          if (needsUpdate) {
-            updateNode({
-              editorName: flow.name,
-              rungId: rung.id,
-              nodeId: node.id,
-              node: {
-                ...node,
-                data: {
-                  ...node.data,
-                  variable: target,
-                  wrongVariable: false,
-                },
-              },
-            })
-          }
-          return
-        }
+        if (!target) return
 
         const expectedType = getBlockExpectedType(node)
 
@@ -80,7 +64,7 @@ export const syncNodesWithVariables = (
               ...node,
               data: {
                 ...node.data,
-                variable: target,
+                variable: { ...target, id: `broken-${node.id}` },
                 wrongVariable: true,
               },
             },
@@ -89,13 +73,7 @@ export const syncNodesWithVariables = (
           return
         }
 
-        const needsRefresh =
-          nodeVar.id !== target.id ||
-          nodeVar.name.toLowerCase() !== target.name.toLowerCase() ||
-          nodeVar.type.value.toLowerCase() !== target.type.value.toLowerCase() ||
-          (node.data as { wrongVariable?: boolean }).wrongVariable
-
-        if (needsRefresh) {
+        if ((node.data as { wrongVariable?: PLCVariable }).wrongVariable) {
           updateNode({
             editorName: flow.name,
             rungId: rung.id,
@@ -117,8 +95,8 @@ export const syncNodesWithVariables = (
 
 export const syncNodesWithVariablesFBD = (
   newVars: PLCVariable[],
-  fbdFlows: FBDFlowState['fbdFlows'],
-  updateNode: FBDFlowActions['updateNode'],
+  fbdFlows: FBDFlow[],
+  updateNode: UpdateFBDNodeFn,
   editorName?: string,
 ) => {
   const flowsToSync = editorName ? fbdFlows.filter((flow) => flow.name === editorName) : fbdFlows
@@ -131,36 +109,7 @@ export const syncNodesWithVariablesFBD = (
 
       const target = newVars.find((v) => v.name.toLowerCase() === nodeVar.name.toLowerCase())
 
-      if (!target) {
-        return
-      }
-
-      const isVariableNode = FBD_VARIABLE_NODE_TYPES.includes(node.type as (typeof FBD_VARIABLE_NODE_TYPES)[number])
-
-      if (isVariableNode) {
-        const needsUpdate =
-          nodeVar.id !== target.id ||
-          nodeVar.name.toLowerCase() !== target.name.toLowerCase() ||
-          nodeVar.type.value.toLowerCase() !== target.type.value.toLowerCase() ||
-          nodeVar.type.definition !== target.type.definition ||
-          (node.data as { wrongVariable?: boolean }).wrongVariable
-
-        if (needsUpdate) {
-          updateNode({
-            editorName: flow.name,
-            nodeId: node.id,
-            node: {
-              ...node,
-              data: {
-                ...node.data,
-                variable: target,
-                wrongVariable: false,
-              },
-            },
-          })
-        }
-        return
-      }
+      if (!target) return
 
       const expectedType = getBlockExpectedType(node)
 
@@ -174,7 +123,7 @@ export const syncNodesWithVariablesFBD = (
             ...node,
             data: {
               ...node.data,
-              variable: target,
+              variable: { ...target, id: `broken-${node.id}` },
               wrongVariable: true,
             },
           },
@@ -183,9 +132,7 @@ export const syncNodesWithVariablesFBD = (
         return
       }
 
-      const needsRefresh = nodeVar !== target || (node.data as { wrongVariable?: boolean }).wrongVariable
-
-      if (needsRefresh) {
+      if ((node.data as { wrongVariable?: PLCVariable }).wrongVariable) {
         updateNode({
           editorName: flow.name,
           nodeId: node.id,
diff --git a/src2/frontend/utils/hex.ts b/src/frontend/utils/hex.ts
similarity index 62%
rename from src2/frontend/utils/hex.ts
rename to src/frontend/utils/hex.ts
index cb81a958a..516e1b985 100644
--- a/src2/frontend/utils/hex.ts
+++ b/src/frontend/utils/hex.ts
@@ -18,10 +18,20 @@ export function hexToBytes(hex: string): Uint8Array {
 }
 
 /**
- * Convert a Uint8Array to a hex string (e.g. "0a1bff").
+ * Convert a Uint8Array to a compact hex string (e.g. "0a1bff").
  */
 export function bytesToHex(bytes: Uint8Array): string {
   return Array.from(bytes)
     .map((b) => b.toString(16).padStart(2, '0'))
     .join('')
 }
+
+/**
+ * Convert a Uint8Array to a space-separated uppercase hex string (e.g. "0A 1B FF").
+ * Matches the format used by the OpenPLC runtime debug protocol.
+ */
+export function bytesToHexSpaced(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).toUpperCase().padStart(2, '0'))
+    .join(' ')
+}
diff --git a/src/utils/keywords.ts b/src/frontend/utils/keywords.ts
similarity index 100%
rename from src/utils/keywords.ts
rename to src/frontend/utils/keywords.ts
diff --git a/src/frontend/utils/migrate-project-to-name-type-system.ts b/src/frontend/utils/migrate-project-to-name-type-system.ts
new file mode 100644
index 000000000..f31aa9b8b
--- /dev/null
+++ b/src/frontend/utils/migrate-project-to-name-type-system.ts
@@ -0,0 +1,156 @@
+import { PLCProjectData, PLCVariable } from '@root/types/PLC/open-plc'
+
+import { getErrorMessage } from './get-error-message'
+
+/**
+ * Migration report detailing the changes made during migration
+ */
+export type MigrationReport = {
+  success: boolean
+  variablesMigrated: number
+  referencesUpdated: number
+  unresolvedReferences: Array<{
+    pouName: string
+    variableName: string
+    reason: string
+  }>
+  errors: string[]
+}
+
+/**
+ * Removes all ID fields from variables in a project
+ * This is a deep operation that modifies the project data structure
+ */
+function removeVariableIds(variable: PLCVariable): PLCVariable {
+  const { id, ...variableWithoutId } = variable as PLCVariable & { id?: string }
+  return variableWithoutId as PLCVariable
+}
+
+/**
+ * Migrates a project from ID-based variable linking to name+type-based linking
+ *
+ * This function:
+ * 1. Removes all `id` fields from variables (local and global)
+ * 2. Removes all `id` fields from structure variables in data types
+ * 3. Removes all `id` fields from task and instance configurations
+ * 4. Validates that all variable references can be resolved by name+type
+ *
+ * @param projectData - The project data to migrate
+ * @returns Migration report with statistics and any unresolved references
+ */
+export function migrateProjectToNameTypeSystem(projectData: PLCProjectData): {
+  migratedProject: PLCProjectData
+  report: MigrationReport
+} {
+  const report: MigrationReport = {
+    success: true,
+    variablesMigrated: 0,
+    referencesUpdated: 0,
+    unresolvedReferences: [],
+    errors: [],
+  }
+
+  try {
+    const migratedProject = structuredClone(projectData)
+
+    migratedProject.pous = migratedProject.pous.map((pou) => {
+      const originalVariableCount = pou.data.variables.length
+      pou.data.variables = pou.data.variables.map(removeVariableIds)
+      report.variablesMigrated += originalVariableCount
+      return pou
+    })
+
+    const globalVariableCount = migratedProject.configuration.resource.globalVariables.length
+    migratedProject.configuration.resource.globalVariables =
+      migratedProject.configuration.resource.globalVariables.map(removeVariableIds)
+    report.variablesMigrated += globalVariableCount
+
+    migratedProject.dataTypes = migratedProject.dataTypes.map((dataType) => {
+      if (dataType.derivation === 'structure' && dataType.variable) {
+        const structureVariableCount = dataType.variable.length
+        dataType.variable = dataType.variable.map((structVar) => {
+          const { id, ...structVarWithoutId } = structVar as typeof structVar & { id?: string }
+          return structVarWithoutId as typeof structVar
+        })
+        report.variablesMigrated += structureVariableCount
+      }
+      return dataType
+    })
+
+    migratedProject.configuration.resource.tasks = migratedProject.configuration.resource.tasks.map((task) => {
+      const { id, ...taskWithoutId } = task as typeof task & { id?: string }
+      return taskWithoutId as typeof task
+    })
+
+    migratedProject.configuration.resource.instances = migratedProject.configuration.resource.instances.map(
+      (instance) => {
+        const { id, ...instanceWithoutId } = instance as typeof instance & { id?: string }
+        return instanceWithoutId as typeof instance
+      },
+    )
+
+    migratedProject.pous.forEach((pou) => {
+      const variableNames = new Set<string>()
+      pou.data.variables.forEach((variable) => {
+        const normalizedName = variable.name.toLowerCase()
+        if (variableNames.has(normalizedName)) {
+          report.unresolvedReferences.push({
+            pouName: pou.data.name,
+            variableName: variable.name,
+            reason: 'Duplicate variable name (case-insensitive)',
+          })
+          report.success = false
+        }
+        variableNames.add(normalizedName)
+      })
+    })
+
+    const globalVariableNames = new Set<string>()
+    migratedProject.configuration.resource.globalVariables.forEach((variable) => {
+      const normalizedName = variable.name.toLowerCase()
+      if (globalVariableNames.has(normalizedName)) {
+        report.unresolvedReferences.push({
+          pouName: 'Global',
+          variableName: variable.name,
+          reason: 'Duplicate global variable name (case-insensitive)',
+        })
+        report.success = false
+      }
+      globalVariableNames.add(normalizedName)
+    })
+
+    return { migratedProject, report }
+  } catch (error) {
+    report.success = false
+    report.errors.push(getErrorMessage(error))
+    return { migratedProject: projectData, report }
+  }
+}
+
+/**
+ * Checks if a project needs migration (has any ID fields)
+ */
+export function needsMigration(projectData: PLCProjectData): boolean {
+  const hasLocalVariableIds = projectData.pous.some((pou) =>
+    pou.data.variables.some((variable) => 'id' in variable && variable.id !== undefined),
+  )
+
+  if (hasLocalVariableIds) return true
+
+  const hasGlobalVariableIds = projectData.configuration.resource.globalVariables.some(
+    (variable) => 'id' in variable && variable.id !== undefined,
+  )
+
+  if (hasGlobalVariableIds) return true
+
+  const hasStructureVariableIds = projectData.dataTypes.some(
+    (dataType) =>
+      dataType.derivation === 'structure' &&
+      dataType.variable &&
+      dataType.variable.some((structVar) => 'id' in structVar && structVar.id !== undefined),
+  )
+
+  if (hasStructureVariableIds) return true
+
+  return false
+}
diff --git a/src2/frontend/utils/modbus/generate-modbus-master-config.ts b/src/frontend/utils/modbus/generate-modbus-master-config.ts
similarity index 99%
rename from src2/frontend/utils/modbus/generate-modbus-master-config.ts
rename to src/frontend/utils/modbus/generate-modbus-master-config.ts
index ed2eaa317..75836b359 100644
--- a/src2/frontend/utils/modbus/generate-modbus-master-config.ts
+++ b/src/frontend/utils/modbus/generate-modbus-master-config.ts
@@ -66,7 +66,7 @@ const formatOffsetAsHex = (offset: string): string => {
  * Uses the first IO point's IEC location as the starting address for the group.
  */
 const convertIOGroupToIOPoint = (ioGroup: ModbusIOGroup): ModbusMasterIOPoint => {
-  const firstIOPoint = ioGroup.ioPoints[0]
+  const firstIOPoint = ioGroup.ioPoints?.[0]
   const iecLocation = firstIOPoint?.iecLocation || '%MW0'
 
   return {
diff --git a/src2/frontend/utils/modbus/generate-modbus-slave-config.ts b/src/frontend/utils/modbus/generate-modbus-slave-config.ts
similarity index 75%
rename from src2/frontend/utils/modbus/generate-modbus-slave-config.ts
rename to src/frontend/utils/modbus/generate-modbus-slave-config.ts
index b058fbcf8..c7cf50b51 100644
--- a/src2/frontend/utils/modbus/generate-modbus-slave-config.ts
+++ b/src/frontend/utils/modbus/generate-modbus-slave-config.ts
@@ -75,20 +75,20 @@ export const generateModbusSlaveConfig = (servers: PLCServer[] | undefined): str
     },
     buffer_mapping: {
       holding_registers: {
-        qw_count: bufferMapping.holdingRegisters.qwCount,
-        mw_count: bufferMapping.holdingRegisters.mwCount,
-        md_count: bufferMapping.holdingRegisters.mdCount,
-        ml_count: bufferMapping.holdingRegisters.mlCount,
+        qw_count: bufferMapping.holdingRegisters?.qwCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.qwCount,
+        mw_count: bufferMapping.holdingRegisters?.mwCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.mwCount,
+        md_count: bufferMapping.holdingRegisters?.mdCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.mdCount,
+        ml_count: bufferMapping.holdingRegisters?.mlCount ?? DEFAULT_BUFFER_MAPPING.holdingRegisters.mlCount,
       },
       coils: {
-        qx_bits: bufferMapping.coils.qxBits,
-        mx_bits: bufferMapping.coils.mxBits,
+        qx_bits: bufferMapping.coils?.qxBits ?? DEFAULT_BUFFER_MAPPING.coils.qxBits,
+        mx_bits: bufferMapping.coils?.mxBits ?? DEFAULT_BUFFER_MAPPING.coils.mxBits,
       },
       discrete_inputs: {
-        ix_bits: bufferMapping.discreteInputs.ixBits,
+        ix_bits: bufferMapping.discreteInputs?.ixBits ?? DEFAULT_BUFFER_MAPPING.discreteInputs.ixBits,
       },
       input_registers: {
-        iw_count: bufferMapping.inputRegisters.iwCount,
+        iw_count: bufferMapping.inputRegisters?.iwCount ?? DEFAULT_BUFFER_MAPPING.inputRegisters.iwCount,
       },
     },
   }
diff --git a/src/utils/new-graphical-editor-node-id.ts b/src/frontend/utils/new-graphical-editor-node-id.ts
similarity index 100%
rename from src/utils/new-graphical-editor-node-id.ts
rename to src/frontend/utils/new-graphical-editor-node-id.ts
diff --git a/src/utils/opcua/__tests__/generate-opcua-config.test.ts b/src/frontend/utils/opcua/__tests__/generate-opcua-config.test.ts
similarity index 100%
rename from src/utils/opcua/__tests__/generate-opcua-config.test.ts
rename to src/frontend/utils/opcua/__tests__/generate-opcua-config.test.ts
diff --git a/src/frontend/utils/opcua/generate-opcua-config.ts b/src/frontend/utils/opcua/generate-opcua-config.ts
new file mode 100644
index 000000000..251d3dc97
--- /dev/null
+++ b/src/frontend/utils/opcua/generate-opcua-config.ts
@@ -0,0 +1,524 @@
+import type {
+  OpcUaNodeConfig,
+  OpcUaPermissions,
+  OpcUaSecurityProfile,
+  OpcUaServerConfig,
+  OpcUaTrustedCertificate,
+  OpcUaUser,
+  PLCServer,
+} from '@root/types/PLC/open-plc'
+
+import { getErrorMessage } from '../get-error-message'
+import { OpcUaConfigError, resolveArrayIndex, resolveStructureIndices, resolveVariableIndex } from './resolve-indices'
+import type { DebugVariable, PLCInstanceInfo } from './types'
+
+/**
+ * Runtime configuration interfaces
+ * These define the JSON structure expected by the OpenPLC Runtime OPC-UA plugin.
+ * The runtime uses snake_case naming convention.
+ */
+
+interface RuntimeSecurityProfile {
+  name: string
+  enabled: boolean
+  security_policy: string
+  security_mode: string
+  auth_methods: string[]
+}
+
+interface RuntimeServerConfig {
+  name: string
+  application_uri: string
+  product_uri: string
+  endpoint_url: string
+  security_profiles: RuntimeSecurityProfile[]
+}
+
+interface RuntimeTrustedCertificate {
+  id: string
+  pem: string
+}
+
+interface RuntimeSecurityConfig {
+  server_certificate_strategy: string
+  server_certificate_custom: string | null
+  server_private_key_custom: string | null
+  trusted_client_certificates: RuntimeTrustedCertificate[]
+}
+
+interface RuntimeUser {
+  type: string
+  username: string | null
+  password_hash: string | null
+  certificate_id: string | null
+  role: string
+}
+
+interface RuntimeVariablePermissions {
+  viewer: string
+  operator: string
+  engineer: string
+}
+
+interface RuntimeVariable {
+  node_id: string
+  browse_name: string
+  display_name: string
+  datatype: string
+  initial_value: boolean | number | string
+  description: string
+  index: number
+  permissions: RuntimeVariablePermissions
+}
+
+interface RuntimeStructureField {
+  name: string
+  datatype: string
+  initial_value: boolean | number | string
+  index: number | null // null for complex types that have nested fields
+  permissions: RuntimeVariablePermissions
+  fields?: RuntimeStructureField[] // Nested fields for complex types (FBs, structs)
+}
+
+interface RuntimeStructure {
+  node_id: string
+  browse_name: string
+  display_name: string
+  description: string
+  fields: RuntimeStructureField[]
+}
+
+interface RuntimeArray {
+  node_id: string
+  browse_name: string
+  display_name: string
+  datatype: string
+  length: number
+  initial_value: boolean | number | string
+  index: number
+  permissions: RuntimeVariablePermissions
+}
+
+interface RuntimeAddressSpace {
+  namespace_uri: string
+  variables: RuntimeVariable[]
+  structures: RuntimeStructure[]
+  arrays: RuntimeArray[]
+}
+
+interface RuntimePluginConfig {
+  server: RuntimeServerConfig
+  security: RuntimeSecurityConfig
+  users: RuntimeUser[]
+  cycle_time_ms: number
+  address_space: RuntimeAddressSpace
+}
+
+interface RuntimeConfig {
+  name: string
+  protocol: 'OPC-UA'
+  config: RuntimePluginConfig
+}
+
+/**
+ * Build the runtime server configuration from editor config
+ */
+const buildServerConfig = (config: OpcUaServerConfig): RuntimeServerConfig => {
+  const { server, securityProfiles } = config
+
+  // Build endpoint URL from components
+  const endpointUrl = `opc.tcp://${server.bindAddress}:${server.port}${server.endpointPath}`
+
+  return {
+    name: server.name,
+    application_uri: server.applicationUri,
+    product_uri: server.productUri,
+    endpoint_url: endpointUrl,
+    security_profiles: securityProfiles
+      .filter((sp: OpcUaSecurityProfile) => sp.enabled)
+      .map((sp: OpcUaSecurityProfile) => ({
+        name: sp.name,
+        enabled: sp.enabled,
+        security_policy: sp.securityPolicy,
+        security_mode: sp.securityMode,
+        auth_methods: sp.authMethods,
+      })),
+  }
+}
+
+/**
+ * Build the runtime security configuration from editor config
+ */
+const buildSecurityConfig = (config: OpcUaServerConfig): RuntimeSecurityConfig => {
+  const { security } = config
+
+  return {
+    server_certificate_strategy: security.serverCertificateStrategy,
+    server_certificate_custom: security.serverCertificateCustom,
+    server_private_key_custom: security.serverPrivateKeyCustom,
+    trusted_client_certificates: security.trustedClientCertificates.map((cert: OpcUaTrustedCertificate) => ({
+      id: cert.id,
+      pem: cert.pem,
+    })),
+  }
+}
+
+/**
+ * Build the runtime users configuration from editor config
+ */
+const buildUsersConfig = (config: OpcUaServerConfig): RuntimeUser[] => {
+  return config.users.map((user: OpcUaUser) => ({
+    type: user.type,
+    username: user.username,
+    password_hash: user.passwordHash,
+    certificate_id: user.certificateId,
+    role: user.role,
+  }))
+}
+
+/**
+ * Convert editor permissions to runtime format
+ */
+const convertPermissions = (permissions: OpcUaPermissions): RuntimeVariablePermissions => ({
+  viewer: permissions.viewer,
+  operator: permissions.operator,
+  engineer: permissions.engineer,
+})
+
+/**
+ * Resolve a simple variable and build runtime format
+ */
+const resolveVariable = (
+  node: OpcUaNodeConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): RuntimeVariable => {
+  const index = resolveVariableIndex(node, debugVariables, instances)
+
+  return {
+    node_id: node.nodeId,
+    browse_name: node.browseName,
+    display_name: node.displayName,
+    datatype: node.variableType,
+    initial_value: node.initialValue,
+    description: node.description,
+    index,
+    permissions: convertPermissions(node.permissions),
+  }
+}
+
+/**
+ * Convert a resolved field (with possible nested fields) to runtime format recursively.
+ */
+const convertResolvedFieldToRuntime = (field: {
+  name: string
+  datatype: string
+  initialValue: boolean | number | string
+  index: number | null
+  permissions: { viewer: 'r' | 'w' | 'rw'; operator: 'r' | 'w' | 'rw'; engineer: 'r' | 'w' | 'rw' }
+  fields?: (typeof field)[]
+}): RuntimeStructureField => {
+  const runtimeField: RuntimeStructureField = {
+    name: field.name,
+    datatype: field.datatype,
+    initial_value: field.initialValue,
+    index: field.index,
+    permissions: convertPermissions(field.permissions),
+  }
+
+  // Add nested fields if present (for complex types like FB instances)
+  if (field.fields && field.fields.length > 0) {
+    runtimeField.fields = field.fields.map(convertResolvedFieldToRuntime)
+  }
+
+  return runtimeField
+}
+
+/**
+ * Resolve a structure and build runtime format with field indices.
+ * Supports nested fields for complex types (FBs within FBs, structs within structs).
+ */
+const resolveStructure = (
+  node: OpcUaNodeConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): RuntimeStructure => {
+  const resolvedFields = resolveStructureIndices(node, debugVariables, instances)
+
+  return {
+    node_id: node.nodeId,
+    browse_name: node.browseName,
+    display_name: node.displayName,
+    description: node.description,
+    fields: resolvedFields.map(convertResolvedFieldToRuntime),
+  }
+}
+
+/**
+ * Extract the element type from an array type string like "ARRAY[1..10] OF INT"
+ * Returns the element type (e.g., "INT") or the original string if parsing fails.
+ */
+const extractArrayElementType = (arrayTypeStr: string): string => {
+  const match = arrayTypeStr.match(/\bOF\s+([A-Za-z0-9_:.]+)\s*$/i)
+  return match ? match[1].toUpperCase() : arrayTypeStr
+}
+
+/**
+ * Resolve an array and build runtime format
+ */
+const resolveArray = (
+  node: OpcUaNodeConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): RuntimeArray => {
+  const index = resolveArrayIndex(node, debugVariables, instances)
+
+  // Get the element type - prefer explicit elementType, otherwise extract from variableType
+  let datatype = node.elementType
+  if (!datatype && node.variableType) {
+    datatype = extractArrayElementType(node.variableType)
+  }
+  datatype = datatype || 'UNKNOWN'
+
+  return {
+    node_id: node.nodeId,
+    browse_name: node.browseName,
+    display_name: node.displayName,
+    datatype,
+    length: node.arrayLength || 1,
+    initial_value: node.initialValue,
+    index,
+    permissions: convertPermissions(node.permissions),
+  }
+}
+
+/**
+ * Build the complete address space configuration
+ */
+const buildAddressSpace = (
+  config: OpcUaServerConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): RuntimeAddressSpace => {
+  const variables: RuntimeVariable[] = []
+  const structures: RuntimeStructure[] = []
+  const arrays: RuntimeArray[] = []
+  const errors: OpcUaConfigError[] = []
+
+  for (const node of config.addressSpace.nodes) {
+    try {
+      switch (node.nodeType) {
+        case 'variable':
+          variables.push(resolveVariable(node, debugVariables, instances))
+          break
+        case 'structure':
+          // Structures and FBs are handled the same way - resolve all leaf fields
+          structures.push(resolveStructure(node, debugVariables, instances))
+          break
+        case 'array':
+          // Arrays with fields (complex element types) are treated like structures
+          // because each leaf variable needs individual index resolution
+          if (node.fields && node.fields.length > 0) {
+            structures.push(resolveStructure(node, debugVariables, instances))
+          } else {
+            // Simple arrays of base types
+            arrays.push(resolveArray(node, debugVariables, instances))
+          }
+          break
+      }
+    } catch (error) {
+      if (error instanceof OpcUaConfigError) {
+        errors.push(error)
+      } else {
+        throw error
+      }
+    }
+  }
+
+  // If there are resolution errors, throw them all together
+  if (errors.length > 0) {
+    const errorMessages = errors.map((e) => e.message).join('\n\n')
+    throw new OpcUaConfigError(
+      'multiple',
+      'multiple',
+      `Failed to resolve ${errors.length} OPC-UA variable(s):\n\n${errorMessages}`,
+    )
+  }
+
+  return {
+    namespace_uri: config.addressSpace.namespaceUri,
+    variables,
+    structures,
+    arrays,
+  }
+}
+
+/**
+ * Parse the debug.c file content to extract debug variables
+ */
+export const parseDebugFile = (content: string): DebugVariable[] => {
+  const variables: DebugVariable[] = []
+
+  // Find the debug_vars[] array
+  const debugVarsMatch = content.match(/debug_vars\[\]\s*=\s*\{([\s\S]*?)\};/)
+
+  if (!debugVarsMatch) {
+    console.warn('Could not find debug_vars[] array in debug.c')
+    return []
+  }
+
+  const arrayContent = debugVarsMatch[1]
+
+  // Parse each entry: { &(VARIABLE_PATH), TYPE }
+  const entryRegex = /\{\s*&\(([^)]+)\)\s*,\s*(\w+)\s*\}/g
+
+  let match
+  let index = 0
+
+  while ((match = entryRegex.exec(arrayContent)) !== null) {
+    const fullPath = match[1].trim()
+    const type = match[2].trim()
+
+    variables.push({
+      name: fullPath,
+      type,
+      index,
+    })
+
+    index++
+  }
+
+  return variables
+}
+
+/**
+ * Generates the OPC-UA configuration JSON for the runtime plugin.
+ * Converts camelCase properties to snake_case expected by the C plugin.
+ * Resolves variable indices from the debug.c file.
+ *
+ * @param servers - Array of configured PLC servers
+ * @param debugFileContent - Content of the generated debug.c file
+ * @param instances - Array of PLC instances from Resources configuration
+ * @returns JSON string for opcua.json or null if no enabled OPC-UA server
+ */
+export const generateOpcUaConfig = (
+  servers: PLCServer[] | undefined,
+  debugFileContent: string,
+  instances: PLCInstanceInfo[],
+): string | null => {
+  // 1. Find OPC-UA server configuration
+  if (!servers || servers.length === 0) {
+    return null
+  }
+
+  const opcuaServer = servers.find((s) => s.protocol === 'opcua' && s.opcuaServerConfig?.server.enabled)
+
+  if (!opcuaServer?.opcuaServerConfig) {
+    return null
+  }
+
+  const config = opcuaServer.opcuaServerConfig
+
+  // 2. Parse debug.c to get variable indices
+  const debugVariables = parseDebugFile(debugFileContent)
+
+  if (debugVariables.length === 0 && config.addressSpace.nodes.length > 0) {
+    throw new OpcUaConfigError(
+      'debug.c',
+      'debug_vars[]',
+      'Cannot resolve OPC-UA variable indices: debug.c appears to be empty or invalid.\n' +
+        'This may happen if the PLC program compilation failed.',
+    )
+  }
+
+  // 3. Build runtime configuration
+  const runtimeConfig: RuntimeConfig = {
+    name: 'opcua_server',
+    protocol: 'OPC-UA',
+    config: {
+      server: buildServerConfig(config),
+      security: buildSecurityConfig(config),
+      users: buildUsersConfig(config),
+      cycle_time_ms: config.cycleTimeMs,
+      address_space: buildAddressSpace(config, debugVariables, instances),
+    },
+  }
+
+  // 4. Return as JSON string (wrapped in array as expected by runtime)
+  return JSON.stringify([runtimeConfig], null, 2)
+}
+
+/**
+ * Validates the OPC-UA configuration before generation.
+ * Returns validation errors without throwing.
+ */
+export const validateOpcUaConfig = (
+  config: OpcUaServerConfig,
+  debugFileContent: string,
+  instances: PLCInstanceInfo[],
+): { valid: boolean; errors: string[] } => {
+  const errors: string[] = []
+
+  // Check for enabled security profiles
+  const enabledProfiles = config.securityProfiles.filter((sp) => sp.enabled)
+  if (enabledProfiles.length === 0) {
+    errors.push('At least one security profile must be enabled')
+  }
+
+  // Check for username auth without users
+  const hasUsernameAuth = enabledProfiles.some((sp) => sp.authMethods.includes('Username'))
+  if (hasUsernameAuth && config.users.length === 0) {
+    errors.push('Username authentication is enabled but no users are configured')
+  }
+
+  // Try to resolve all variables
+  const debugVariables = parseDebugFile(debugFileContent)
+
+  for (const node of config.addressSpace.nodes) {
+    try {
+      switch (node.nodeType) {
+        case 'variable':
+          resolveVariableIndex(node, debugVariables, instances)
+          break
+        case 'structure':
+          resolveStructureIndices(node, debugVariables, instances)
+          break
+        case 'array':
+          // Arrays with fields (complex element types) are validated like structures
+          if (node.fields && node.fields.length > 0) {
+            resolveStructureIndices(node, debugVariables, instances)
+          } else {
+            resolveArrayIndex(node, debugVariables, instances)
+          }
+          break
+      }
+    } catch (error) {
+      if (error instanceof OpcUaConfigError) {
+        errors.push(error.message)
+      } else {
+        errors.push(getErrorMessage(error))
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}
+
+export type {
+  RuntimeAddressSpace,
+  RuntimeArray,
+  RuntimeConfig,
+  RuntimePluginConfig,
+  RuntimeSecurityConfig,
+  RuntimeSecurityProfile,
+  RuntimeServerConfig,
+  RuntimeStructure,
+  RuntimeStructureField,
+  RuntimeTrustedCertificate,
+  RuntimeUser,
+  RuntimeVariable,
+  RuntimeVariablePermissions,
+}
diff --git a/src/utils/opcua/index.ts b/src/frontend/utils/opcua/index.ts
similarity index 100%
rename from src/utils/opcua/index.ts
rename to src/frontend/utils/opcua/index.ts
diff --git a/src/frontend/utils/opcua/resolve-indices.ts b/src/frontend/utils/opcua/resolve-indices.ts
new file mode 100644
index 000000000..ef6bf4cfd
--- /dev/null
+++ b/src/frontend/utils/opcua/resolve-indices.ts
@@ -0,0 +1,315 @@
+import {
+  buildDebugPath,
+  buildGlobalDebugPath,
+  type DebugVariableEntry,
+  findDebugVariable,
+  findDebugVariableWithFallback,
+  findInstanceName,
+  type PLCInstanceMapping,
+} from '@root/frontend/utils/debug-variable-finder'
+import type { OpcUaFieldConfig, OpcUaNodeConfig } from '@root/types/PLC/open-plc'
+
+import type { DebugVariable, PLCInstanceInfo, ResolvedField } from './types'
+
+/**
+ * Convert debug.c type enum to IEC type name.
+ * debug.c uses types like "INT_ENUM", "BOOL_ENUM", "REAL_ENUM"
+ * but the OPC-UA runtime expects "INT", "BOOL", "REAL".
+ */
+const debugTypeToIecType = (debugType: string): string => {
+  // Remove _ENUM suffix if present
+  if (debugType.endsWith('_ENUM')) {
+    return debugType.slice(0, -5)
+  }
+  // Remove _P_ENUM or _O_ENUM suffix for pointer/output types
+  if (debugType.endsWith('_P_ENUM') || debugType.endsWith('_O_ENUM')) {
+    return debugType.slice(0, -7)
+  }
+  return debugType
+}
+
+/**
+ * Custom error class for OPC-UA configuration errors
+ */
+export class OpcUaConfigError extends Error {
+  constructor(
+    public readonly variableRef: string,
+    public readonly expectedPath: string,
+    message: string,
+  ) {
+    super(message)
+    this.name = 'OpcUaConfigError'
+  }
+}
+
+/**
+ * Convert PLCInstanceInfo to PLCInstanceMapping for the shared utility
+ */
+const toInstanceMapping = (instances: PLCInstanceInfo[]): PLCInstanceMapping[] =>
+  instances.map((inst) => ({ name: inst.name, program: inst.program }))
+
+/**
+ * Convert DebugVariable to DebugVariableEntry for the shared utility
+ */
+const toDebugEntries = (debugVariables: DebugVariable[]): DebugVariableEntry[] =>
+  debugVariables.map((dv) => ({ name: dv.name, type: dv.type, index: dv.index }))
+
+/**
+ * Resolve the index for a simple variable node.
+ *
+ * @param node - The OPC-UA node configuration
+ * @param debugVariables - Parsed debug variables from debug.c
+ * @param instances - Array of PLC instances from Resources configuration
+ * @returns The resolved index
+ * @throws OpcUaConfigError if the variable cannot be resolved
+ */
+export const resolveVariableIndex = (
+  node: OpcUaNodeConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): number => {
+  const debugEntries = toDebugEntries(debugVariables)
+  const instanceMappings = toInstanceMapping(instances)
+
+  // Handle global variables
+  if (node.pouName === 'GVL' || node.pouName === 'CONFIG' || node.pouName.toUpperCase() === 'GVL') {
+    const debugPath = buildGlobalDebugPath(node.variablePath)
+    const match = findDebugVariable(debugEntries, debugPath)
+
+    if (match) {
+      return match.index
+    }
+
+    throw new OpcUaConfigError(
+      `${node.pouName}:${node.variablePath}`,
+      debugPath,
+      `Cannot resolve OPC-UA global variable index.\n` +
+        `  Variable: ${node.pouName}:${node.variablePath}\n` +
+        `  Expected debug path: ${debugPath}`,
+    )
+  }
+
+  // Look up the instance name for this program
+  const instanceName = findInstanceName(node.pouName, instanceMappings)
+
+  if (!instanceName) {
+    throw new OpcUaConfigError(
+      node.pouName,
+      'unknown',
+      `Cannot find instance for program "${node.pouName}" in Resources.\n` +
+        `  Make sure the program is instantiated in the Resources configuration.`,
+    )
+  }
+
+  // Use shared fallback function - tries FB-style first, then struct-style
+  const result = findDebugVariableWithFallback(debugEntries, instanceName, node.variablePath)
+
+  if (result.match) {
+    return result.match.index
+  }
+
+  throw new OpcUaConfigError(
+    `${node.pouName}:${node.variablePath}`,
+    result.matchedPath,
+    `Cannot resolve OPC-UA variable index.\n` +
+      `  Variable: ${node.pouName}:${node.variablePath}\n` +
+      `  Tried paths:\n` +
+      `    - FB style: ${buildDebugPath(instanceName, node.variablePath, { isStructureField: false })}\n` +
+      `    - Struct style: ${buildDebugPath(instanceName, node.variablePath, { isStructureField: true })}\n` +
+      `  This may happen if:\n` +
+      `    - The PLC program was modified after configuring OPC-UA\n` +
+      `    - The variable name is incorrect\n` +
+      `    - The variable was removed from the program\n` +
+      `  Please verify the variable exists in the program.`,
+  )
+}
+
+/**
+ * Resolve a single field, recursively handling nested fields for complex types.
+ *
+ * @param field - The field configuration
+ * @param parentPath - The full path to the parent (e.g., "IRRIGATION_MAIN_CONTROLLER0")
+ * @param pouName - The POU name (e.g., "MAIN" or "GVL")
+ * @param debugEntries - Converted debug variable entries
+ * @param instanceName - Instance name (null for global variables)
+ * @returns Resolved field with index and possibly nested fields
+ */
+const resolveFieldRecursively = (
+  field: OpcUaFieldConfig,
+  parentPath: string,
+  pouName: string,
+  debugEntries: DebugVariableEntry[],
+  instanceName: string | null,
+): ResolvedField => {
+  // Build the full path for this field.
+  // Note: This code path only processes new hierarchical configs where field.fieldPath
+  // contains just the field name (e.g., "TON0", "IN"). Legacy flat configs don't have
+  // nested `fields` arrays, so they won't reach this recursive function.
+  const fullFieldPath = `${parentPath}.${field.fieldPath}`
+
+  // If this field has nested fields, it's a complex type (FB or struct)
+  if (field.fields && field.fields.length > 0) {
+    // Recursively resolve nested fields
+    const nestedFields: ResolvedField[] = []
+    for (const nestedField of field.fields) {
+      nestedFields.push(resolveFieldRecursively(nestedField, fullFieldPath, pouName, debugEntries, instanceName))
+    }
+
+    // Complex types have null index - only leaf fields have indices
+    return {
+      name: field.fieldPath,
+      datatype: field.datatype || 'UNKNOWN',
+      initialValue: field.initialValue,
+      index: null,
+      permissions: field.permissions,
+      fields: nestedFields,
+    }
+  }
+
+  // This is a leaf field - resolve its index
+  let match: DebugVariableEntry | null = null
+  let debugPath: string = ''
+
+  if (pouName === 'GVL' || pouName === 'CONFIG') {
+    // Global structure/FB field
+    debugPath = buildGlobalDebugPath(fullFieldPath)
+    match = findDebugVariable(debugEntries, debugPath)
+  } else {
+    // Use shared fallback function - tries FB-style first, then struct-style
+    const result = findDebugVariableWithFallback(debugEntries, instanceName!, fullFieldPath)
+    match = result.match
+    debugPath = result.matchedPath
+  }
+
+  if (!match) {
+    throw new OpcUaConfigError(
+      `${pouName}:${fullFieldPath}`,
+      debugPath,
+      `Cannot resolve OPC-UA structure/FB field index.\n` +
+        `  Field path: ${fullFieldPath}\n` +
+        `  Tried paths:\n` +
+        `    - FB style: ${buildDebugPath(instanceName!, fullFieldPath, { isStructureField: false })}\n` +
+        `    - Struct style: ${buildDebugPath(instanceName!, fullFieldPath, { isStructureField: true })}`,
+    )
+  }
+
+  return {
+    name: field.fieldPath,
+    datatype: match.type ? debugTypeToIecType(match.type) : field.datatype || 'UNKNOWN',
+    initialValue: field.initialValue,
+    index: match.index,
+    permissions: field.permissions,
+  }
+}
+
+/**
+ * Resolve indices for all fields in a structure or function block instance.
+ * Supports nested fields for complex types (FBs within FBs, structs within structs).
+ *
+ * @param node - The OPC-UA node configuration for the structure/FB
+ * @param debugVariables - Parsed debug variables from debug.c
+ * @param instances - Array of PLC instances from Resources configuration
+ * @returns Array of resolved fields with indices (may be hierarchical)
+ * @throws OpcUaConfigError if any field cannot be resolved
+ */
+export const resolveStructureIndices = (
+  node: OpcUaNodeConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): ResolvedField[] => {
+  const debugEntries = toDebugEntries(debugVariables)
+  const instanceMappings = toInstanceMapping(instances)
+
+  if (!node.fields || node.fields.length === 0) {
+    // If no field configs, try to resolve the structure variable itself
+    const index = resolveVariableIndex(node, debugVariables, instances)
+    return [
+      {
+        name: node.variablePath,
+        datatype: node.variableType,
+        initialValue: node.initialValue,
+        index,
+        permissions: node.permissions,
+      },
+    ]
+  }
+
+  // Look up the instance name for this program
+  let instanceName: string | null = null
+  if (node.pouName !== 'GVL' && node.pouName !== 'CONFIG') {
+    instanceName = findInstanceName(node.pouName, instanceMappings)
+    if (!instanceName) {
+      throw new OpcUaConfigError(
+        node.pouName,
+        'unknown',
+        `Cannot find instance for program "${node.pouName}" in Resources.`,
+      )
+    }
+  }
+
+  const resolvedFields: ResolvedField[] = []
+
+  for (const field of node.fields) {
+    resolvedFields.push(resolveFieldRecursively(field, node.variablePath, node.pouName, debugEntries, instanceName))
+  }
+
+  return resolvedFields
+}
+
+/**
+ * Resolve the starting index for an array.
+ * Arrays are stored sequentially, so we only need the first element's index.
+ *
+ * @param node - The OPC-UA node configuration for the array
+ * @param debugVariables - Parsed debug variables from debug.c
+ * @param instances - Array of PLC instances from Resources configuration
+ * @returns The index of the first array element
+ * @throws OpcUaConfigError if the array cannot be resolved
+ */
+export const resolveArrayIndex = (
+  node: OpcUaNodeConfig,
+  debugVariables: DebugVariable[],
+  instances: PLCInstanceInfo[],
+): number => {
+  const debugEntries = toDebugEntries(debugVariables)
+  const instanceMappings = toInstanceMapping(instances)
+
+  let debugPath: string
+
+  if (node.pouName === 'GVL' || node.pouName === 'CONFIG') {
+    // Global array - first element: CONFIG0__VAR.value.table[0]
+    debugPath = `${buildGlobalDebugPath(node.variablePath)}.value.table[0]`
+  } else {
+    // Look up the instance name for this program
+    const instanceName = findInstanceName(node.pouName, instanceMappings)
+
+    if (!instanceName) {
+      throw new OpcUaConfigError(
+        node.pouName,
+        'unknown',
+        `Cannot find instance for program "${node.pouName}" in Resources.`,
+      )
+    }
+
+    // Instance array - first element
+    debugPath = buildDebugPath(instanceName, node.variablePath, {
+      isArrayElement: true,
+      arrayIndex: 0,
+    })
+  }
+
+  const match = findDebugVariable(debugEntries, debugPath)
+
+  if (match) {
+    return match.index
+  }
+
+  throw new OpcUaConfigError(
+    `${node.pouName}:${node.variablePath}`,
+    debugPath,
+    `Cannot resolve OPC-UA array index.\n` +
+      `  Array: ${node.pouName}:${node.variablePath}\n` +
+      `  Expected debug path: ${debugPath}\n` +
+      `  Looking for first element [0] of the array.`,
+  )
+}
diff --git a/src/utils/opcua/types.ts b/src/frontend/utils/opcua/types.ts
similarity index 100%
rename from src/utils/opcua/types.ts
rename to src/frontend/utils/opcua/types.ts
diff --git a/src2/frontend/utils/parse-resource-configuration-to-string.ts b/src/frontend/utils/parse-resource-configuration-to-string.ts
similarity index 100%
rename from src2/frontend/utils/parse-resource-configuration-to-string.ts
rename to src/frontend/utils/parse-resource-configuration-to-string.ts
diff --git a/src2/frontend/utils/parse-resource-string-to-configuration.ts b/src/frontend/utils/parse-resource-string-to-configuration.ts
similarity index 100%
rename from src2/frontend/utils/parse-resource-string-to-configuration.ts
rename to src/frontend/utils/parse-resource-string-to-configuration.ts
diff --git a/src2/frontend/utils/plc-constants.ts b/src/frontend/utils/plc-constants.ts
similarity index 100%
rename from src2/frontend/utils/plc-constants.ts
rename to src/frontend/utils/plc-constants.ts
diff --git a/src/utils/plc-status.ts b/src/frontend/utils/plc-status.ts
similarity index 100%
rename from src/utils/plc-status.ts
rename to src/frontend/utils/plc-status.ts
diff --git a/src2/frontend/utils/pou-helpers.ts b/src/frontend/utils/pou-helpers.ts
similarity index 87%
rename from src2/frontend/utils/pou-helpers.ts
rename to src/frontend/utils/pou-helpers.ts
index eb60b3840..a43f7804f 100644
--- a/src2/frontend/utils/pou-helpers.ts
+++ b/src/frontend/utils/pou-helpers.ts
@@ -3,9 +3,8 @@
  * Used by both the debugger and OPC-UA config generator.
  */
 
+import type { PLCDataType, PLCPou } from '../../middleware/shared/ports/types'
 import { StandardFunctionBlocks } from '../data/library/standard-function-blocks'
-import type { PLCDataType } from '../../middleware/shared/ports/types'
-import type { PouDTO } from '../store/slices/project/types'
 
 /**
  * Variable definition from a POU or library FB.
@@ -34,33 +33,33 @@ export const normalizeTypeString = (typeStr: string): string => {
  * Base IEC types that are directly accessible in debug.c
  */
 const BASE_TYPES = [
-  'bool',
-  'sint',
-  'int',
-  'dint',
-  'lint',
-  'usint',
-  'uint',
-  'udint',
-  'ulint',
-  'real',
-  'lreal',
-  'time',
-  'date',
-  'tod',
-  'dt',
-  'string',
-  'byte',
-  'word',
-  'dword',
-  'lword',
+  'BOOL',
+  'SINT',
+  'INT',
+  'DINT',
+  'LINT',
+  'USINT',
+  'UINT',
+  'UDINT',
+  'ULINT',
+  'REAL',
+  'LREAL',
+  'TIME',
+  'DATE',
+  'TOD',
+  'DT',
+  'STRING',
+  'BYTE',
+  'WORD',
+  'DWORD',
+  'LWORD',
 ]
 
 /**
  * Check if a type is a base IEC type.
  */
 export const isBaseType = (typeName: string): boolean => {
-  return BASE_TYPES.includes(typeName.toLowerCase())
+  return BASE_TYPES.includes(typeName.toUpperCase())
 }
 
 /**
@@ -68,7 +67,7 @@ export const isBaseType = (typeName: string): boolean => {
  * Searches BOTH the built-in library AND project POUs.
  * Returns the variables array from the FB definition, or null if not found.
  */
-export const findFunctionBlockVariables = (typeName: string, projectPous: PouDTO[]): PouVariable[] | null => {
+export const findFunctionBlockVariables = (typeName: string, projectPous: PLCPou[]): PouVariable[] | null => {
   const typeNameUpper = typeName.toUpperCase()
 
   // Check standard library FBs
@@ -81,10 +80,10 @@ export const findFunctionBlockVariables = (typeName: string, projectPous: PouDTO
 
   // Check project POUs (user-defined FBs)
   const customFB = projectPous.find(
-    (pou) => normalizeTypeString(pou.type) === 'functionblock' && pou.data.name.toUpperCase() === typeNameUpper,
+    (pou) => normalizeTypeString(pou.pouType) === 'functionblock' && pou.name.toUpperCase() === typeNameUpper,
   )
-  if (customFB && customFB.type === 'function-block') {
-    return customFB.data.variables as PouVariable[]
+  if (customFB && customFB.pouType === 'function-block') {
+    return (customFB.interface?.variables ?? []) as PouVariable[]
   }
 
   return null
@@ -93,7 +92,7 @@ export const findFunctionBlockVariables = (typeName: string, projectPous: PouDTO
 /**
  * Check if a type name is a function block (library or project).
  */
-export const isFunctionBlockType = (typeName: string, projectPous: PouDTO[]): boolean => {
+export const isFunctionBlockType = (typeName: string, projectPous: PLCPou[]): boolean => {
   return findFunctionBlockVariables(typeName, projectPous) !== null
 }
 
@@ -147,7 +146,7 @@ export interface LeafVariable {
  */
 export const findLeafVariables = (
   typeName: string,
-  projectPous: PouDTO[],
+  projectPous: PLCPou[],
   dataTypes: PLCDataType[],
   pathPrefix: string = '',
   visited: Set<string> = new Set(),
@@ -212,9 +211,9 @@ export const findLeafVariables = (
 /**
  * Get all variables from a POU (program or function block).
  */
-export const getPouVariables = (pou: PouDTO): PouVariable[] => {
-  if (pou.type === 'program' || pou.type === 'function-block') {
-    return pou.data.variables as PouVariable[]
+export const getPouVariables = (pou: PLCPou): PouVariable[] => {
+  if (pou.pouType === 'program' || pou.pouType === 'function-block') {
+    return (pou.interface?.variables ?? []) as PouVariable[]
   }
   return []
 }
diff --git a/src/frontend/utils/python/addPythonLocalVariables.ts b/src/frontend/utils/python/addPythonLocalVariables.ts
new file mode 100644
index 000000000..804d8d63c
--- /dev/null
+++ b/src/frontend/utils/python/addPythonLocalVariables.ts
@@ -0,0 +1,60 @@
+import type { PLCPou, PLCProjectData, PLCVariable } from '../../../middleware/shared/ports/types'
+
+const createRuntimeVariables = (): PLCVariable[] => {
+  return [
+    {
+      name: 'first_run',
+      class: 'local',
+      type: {
+        definition: 'base-type',
+        value: 'BOOL',
+      },
+      location: '',
+      documentation: '',
+      debug: false,
+    },
+    {
+      name: 'shm_in_ptr',
+      class: 'local',
+      type: {
+        definition: 'base-type',
+        value: 'ULINT',
+      },
+      location: '',
+      documentation: '',
+      debug: false,
+    },
+    {
+      name: 'shm_out_ptr',
+      class: 'local',
+      type: {
+        definition: 'base-type',
+        value: 'ULINT',
+      },
+      location: '',
+      documentation: '',
+      debug: false,
+    },
+  ]
+}
+
+const addPythonLocalVariables = (projectData: PLCProjectData): PLCProjectData => {
+  const processedData = structuredClone(projectData)
+
+  processedData.pous = processedData.pous.map((pou: PLCPou) => {
+    if (pou.body.language === 'python') {
+      const runtimeVariables = createRuntimeVariables()
+      const variables = pou.interface?.variables ?? []
+      pou.interface = {
+        ...pou.interface,
+        variables: [...variables, ...runtimeVariables],
+      }
+    }
+
+    return pou
+  })
+
+  return processedData
+}
+
+export { addPythonLocalVariables }
diff --git a/src/frontend/utils/python/encodeCharactersFromVariable.ts b/src/frontend/utils/python/encodeCharactersFromVariable.ts
new file mode 100644
index 000000000..fb528fe06
--- /dev/null
+++ b/src/frontend/utils/python/encodeCharactersFromVariable.ts
@@ -0,0 +1,70 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { getArrayBaseTypeValue, getArrayTotalElements, isArrayVariable } from '../PLC/array-codegen-helpers'
+
+const TYPE_ENCODING_MAP: Record<string, string> = {
+  bool: 'B',
+  sint: 'b',
+  int: 'h',
+  dint: 'i',
+  lint: 'q',
+  usint: 'B',
+  uint: 'H',
+  udint: 'I',
+  ulint: 'Q',
+  real: 'f',
+  lreal: 'd',
+  byte: 'B',
+  word: 'H',
+  dword: 'I',
+  lword: 'Q',
+  string: 'b126s',
+}
+
+/**
+ * Converts an array of PLC variables into a format string for Python's struct.pack/unpack.
+ * For scalar variables, returns the corresponding format character.
+ * For array variables, repeats the base type's format character N times (e.g., ARRAY[0..9] OF INT -> '10h').
+ * @param variables Array of PLC variables
+ * @returns String in the format '=hfb126sib126sH' for use with struct.pack/unpack
+ */
+
+const encodeCharactersFromVariable = (variables: PLCVariable[]): string => {
+  if (!variables || variables.length === 0) {
+    return '='
+  }
+
+  const encodedChars = variables
+    .map((variable) => {
+      if (isArrayVariable(variable)) {
+        const baseType = getArrayBaseTypeValue(variable).toLowerCase()
+        const encodingChar = TYPE_ENCODING_MAP[baseType]
+        if (!encodingChar) {
+          console.warn(`Warning: Unknown base type "${baseType}" for array variable "${variable.name}". Skipping.`)
+          return ''
+        }
+        const totalElements = getArrayTotalElements(variable)
+        // For multi-char encodings (e.g., 'b126s' for STRING), the repeat count
+        // only applies to the first char in Python struct format ('10b126s' != 10x'b126s').
+        // Repeat the full encoding string instead.
+        if (encodingChar.length > 1) {
+          return encodingChar.repeat(totalElements)
+        }
+        return `${totalElements}${encodingChar}`
+      }
+
+      const typeValue = variable.type.value.toLowerCase()
+      const encodingChar = TYPE_ENCODING_MAP[typeValue]
+
+      if (!encodingChar) {
+        console.warn(`Warning: Unknown type "${typeValue}" for variable "${variable.name}". Skipping.`)
+        return ''
+      }
+
+      return encodingChar
+    })
+    .filter((char) => char !== '')
+
+  return '=' + encodedChars.join('')
+}
+
+export { encodeCharactersFromVariable }
diff --git a/src/frontend/utils/python/generateSTCode.ts b/src/frontend/utils/python/generateSTCode.ts
new file mode 100644
index 000000000..e3f0999ca
--- /dev/null
+++ b/src/frontend/utils/python/generateSTCode.ts
@@ -0,0 +1,189 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { getArrayTotalElements, getVariableIECType, isArrayVariable } from '../PLC/array-codegen-helpers'
+
+type STCodeGenerationParams = {
+  pouName: string
+  allVariables: PLCVariable[]
+  processedPythonCode: string
+}
+
+const generateStructField = (variable: PLCVariable): string => {
+  const iecType = getVariableIECType(variable)
+  if (isArrayVariable(variable)) {
+    const totalElements = getArrayTotalElements(variable)
+    return `        ${iecType} ${variable.name}[${totalElements}];\n`
+  }
+  return `        ${iecType} ${variable.name};\n`
+}
+
+const generateCStructs = (inputVars: PLCVariable[], outputVars: PLCVariable[]): string => {
+  let structs = ''
+
+  // Input struct
+  structs += '    #pragma pack(push, 1)\n'
+  structs += '    typedef struct {\n'
+  if (inputVars.length > 0) {
+    inputVars.forEach((variable) => {
+      structs += generateStructField(variable)
+    })
+  } else {
+    // Padding field ensures sizeof() >= 1, preventing mmap() failure with size 0.
+    structs += '        uint8_t _padding;\n'
+  }
+  structs += '    } shm_data_in_t;\n'
+  structs += '    #pragma pack(pop)\n\n'
+
+  // Output struct
+  structs += '    #pragma pack(push, 1)\n'
+  structs += '    typedef struct {\n'
+  if (outputVars.length > 0) {
+    outputVars.forEach((variable) => {
+      structs += generateStructField(variable)
+    })
+  } else {
+    // Padding field ensures sizeof() >= 1, preventing mmap() failure with size 0.
+    structs += '        uint8_t _padding;\n'
+  }
+  structs += '    } shm_data_out_t;\n'
+  structs += '    #pragma pack(pop)\n'
+
+  return structs
+}
+
+const generateInputCopyCode = (inputVars: PLCVariable[]): string => {
+  if (inputVars.length === 0) return ''
+
+  let code = '        shm_data_in_t data_in;\n'
+
+  inputVars.forEach((variable) => {
+    const isString = variable.type?.definition === 'base-type' && variable.type?.value.toLowerCase() === 'string'
+    const upperName = variable.name.toUpperCase()
+
+    if (isArrayVariable(variable)) {
+      const totalElements = getArrayTotalElements(variable)
+      code += `        for (int __i = 0; __i < ${totalElements}; __i++) data_in.${variable.name}[__i] = data__->${upperName}.value.table[__i].value;\n`
+    } else if (isString) {
+      code += `        data_in.${variable.name}.len = data__->${upperName}.value.len;\n`
+      code += `        memcpy(data_in.${variable.name}.body, data__->${upperName}.value.body, STR_MAX_LEN);\n`
+    } else {
+      code += `        data_in.${variable.name} = data__->${upperName}.value;\n`
+    }
+  })
+
+  code += '        memcpy(shm_in_ptr, &data_in, sizeof(data_in));\n\n'
+
+  return code
+}
+
+const generateOutputCopyCode = (outputVars: PLCVariable[]): string => {
+  if (outputVars.length === 0) return ''
+
+  let code = '        shm_data_out_t data_out;\n'
+  code += '        memcpy(&data_out, shm_out_ptr, sizeof(data_out));\n'
+
+  outputVars.forEach((variable) => {
+    const isString = variable.type?.definition === 'base-type' && variable.type?.value.toLowerCase() === 'string'
+    const upperName = variable.name.toUpperCase()
+
+    if (isArrayVariable(variable)) {
+      const totalElements = getArrayTotalElements(variable)
+      code += `        for (int __i = 0; __i < ${totalElements}; __i++) data__->${upperName}.value.table[__i].value = data_out.${variable.name}[__i];\n`
+    } else if (isString) {
+      code += `        data__->${upperName}.value.len = data_out.${variable.name}.len;\n`
+      code += `        memcpy(data__->${upperName}.value.body, data_out.${variable.name}.body, STR_MAX_LEN);\n`
+    } else {
+      code += `        data__->${upperName}.value = data_out.${variable.name};\n`
+    }
+  })
+
+  return code
+}
+
+const generateSTCode = (params: STCodeGenerationParams): string => {
+  const { pouName, allVariables, processedPythonCode } = params
+
+  const inputVariables = allVariables.filter((v) => v.class === 'input')
+  const outputVariables = allVariables.filter((v) => v.class === 'output')
+
+  const cStructs = generateCStructs(inputVariables, outputVariables)
+  const inputCopyCode = generateInputCopyCode(inputVariables)
+  const outputCopyCode = generateOutputCopyCode(outputVariables)
+
+  const escapedPythonCode = processedPythonCode
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n"\n            "')
+
+  const stCode = `(* Type definitions *)
+{{
+    typedef uint8_t  IEC_BOOL;
+    typedef int8_t    IEC_SINT;
+    typedef int16_t   IEC_INT;
+    typedef int32_t   IEC_DINT;
+    typedef int64_t   IEC_LINT;
+    typedef uint8_t    IEC_USINT;
+    typedef uint16_t   IEC_UINT;
+    typedef uint32_t   IEC_UDINT;
+    typedef uint64_t   IEC_ULINT;
+    typedef uint8_t    IEC_BYTE;
+    typedef uint16_t   IEC_WORD;
+    typedef uint32_t   IEC_DWORD;
+    typedef uint64_t   IEC_LWORD;
+    typedef float    IEC_REAL;
+    typedef double   IEC_LREAL;
+    #define STR_LEN_TYPE int8_t
+    #define STR_MAX_LEN 126
+    typedef STR_LEN_TYPE __strlen_t;
+    typedef struct {
+        __strlen_t len;
+        uint8_t body[STR_MAX_LEN];
+    } IEC_STRING;
+
+${cStructs}
+}}
+
+if first_run = false then
+    {{
+        pid_t pid = getpid();
+        void *shm_in_ptr = NULL;
+        void *shm_out_ptr = NULL;
+        char shm_name[128];
+        create_shm_name(shm_name, sizeof(shm_name));
+
+        const char *script_name = "${pouName}.py";
+        const char script_template[] =
+            "${escapedPythonCode}";
+
+        if (python_block_loader(script_name, script_template, shm_name, sizeof(shm_data_in_t), sizeof(shm_data_out_t), &shm_in_ptr, &shm_out_ptr, pid) < 0)
+        {
+            printf("an error occurred!\\n");
+            return;
+        }
+
+        data__->SHM_IN_PTR.value = (uint64_t)shm_in_ptr;
+        data__->SHM_OUT_PTR.value = (uint64_t)shm_out_ptr;
+    }}
+    first_run := true;
+else
+    {{
+        void *shm_in_ptr = (void *)data__->SHM_IN_PTR.value;
+        void *shm_out_ptr = (void *)data__->SHM_OUT_PTR.value;
+
+        if (shm_in_ptr == NULL)
+        {
+            printf("shm_in_ptr is NULL!\\n");
+            return;
+        }
+        if (shm_out_ptr == NULL)
+        {
+            printf("shm_out_ptr is NULL!\\n");
+            return;
+        }
+
+${inputCopyCode}${outputCopyCode}    }}
+end_if;`
+
+  return stCode
+}
+
+export { generateSTCode, type STCodeGenerationParams }
diff --git a/src/frontend/utils/python/injectPythonCode.ts b/src/frontend/utils/python/injectPythonCode.ts
new file mode 100644
index 000000000..fe7e896a7
--- /dev/null
+++ b/src/frontend/utils/python/injectPythonCode.ts
@@ -0,0 +1,34 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { encodeCharactersFromVariable } from './encodeCharactersFromVariable'
+import { injectPythonRuntime } from './injectPythonRuntime'
+
+type PythonPouData = {
+  name: string
+  code: string
+  type: string
+  documentation?: string
+  variables: PLCVariable[]
+}
+
+const injectPythonCode = (pythonPous: PythonPouData[]): string[] => {
+  return pythonPous.map((pou) => {
+    const inputVariables = pou.variables.filter((v) => v.class === 'input')
+    const outputVariables = pou.variables.filter((v) => v.class === 'output')
+
+    const fmtIn = encodeCharactersFromVariable(inputVariables)
+    const fmtOut = encodeCharactersFromVariable(outputVariables)
+
+    const injectedCode = injectPythonRuntime({
+      fmtIn,
+      fmtOut,
+      inputVariables,
+      outputVariables,
+      originalCode: pou.code,
+      pouName: pou.name,
+    })
+
+    return injectedCode
+  })
+}
+
+export { injectPythonCode, type PythonPouData }
diff --git a/src/frontend/utils/python/injectPythonRuntime.ts b/src/frontend/utils/python/injectPythonRuntime.ts
new file mode 100644
index 000000000..4ce904545
--- /dev/null
+++ b/src/frontend/utils/python/injectPythonRuntime.ts
@@ -0,0 +1,144 @@
+import type { PLCVariable } from '../../../middleware/shared/ports/types'
+import { getArrayTotalElements, isArrayVariable } from '../PLC/array-codegen-helpers'
+
+type PythonRuntimeInjectionParams = {
+  fmtIn: string
+  fmtOut: string
+  inputVariables: PLCVariable[]
+  outputVariables: PLCVariable[]
+  originalCode: string
+  pouName: string
+}
+
+const generateOutputInitialization = (outputVariables: PLCVariable[]): string => {
+  if (outputVariables.length === 0) return '# No output variables to initialize'
+
+  return outputVariables
+    .map((variable) => {
+      if (isArrayVariable(variable)) {
+        const totalElements = getArrayTotalElements(variable)
+        return `${variable.name} = [0] * ${totalElements}`
+      }
+      const defaultValue = variable.type?.value === 'string' ? '""' : variable.initialValue || 0
+      return `${variable.name} = ${defaultValue}`
+    })
+    .join('\n')
+}
+
+/**
+ * Generate Python code that extracts variables from the flat unpacked tuple using index slicing.
+ * Handles scalars, strings (len+body pairs), and arrays (N consecutive elements -> list).
+ */
+const generateInputUnpackCode = (inputVariables: PLCVariable[]): string => {
+  if (inputVariables.length === 0) return '    # No input variables to read'
+
+  let code = '    # Read input variables\n'
+  code += '    _vals = struct.unpack(fmt_in, shm_in.buf[:data_size_in])\n'
+  code += '    _idx = 0\n'
+
+  inputVariables.forEach((variable) => {
+    if (isArrayVariable(variable)) {
+      const count = getArrayTotalElements(variable)
+      code += `    ${variable.name} = list(_vals[_idx:_idx+${count}])\n`
+      code += `    _idx += ${count}\n`
+    } else if (variable.type?.definition === 'base-type' && variable.type?.value === 'string') {
+      code += `    ${variable.name}_len = _vals[_idx]\n`
+      code += `    _idx += 1\n`
+      code += `    ${variable.name}_body = _vals[_idx]\n`
+      code += `    _idx += 1\n`
+      code += `    ${variable.name} = ${variable.name}_body[:${variable.name}_len].decode('utf-8', errors='ignore')\n`
+    } else {
+      code += `    ${variable.name} = _vals[_idx]\n`
+      code += `    _idx += 1\n`
+    }
+  })
+
+  return code
+}
+
+/**
+ * Generate Python code that packs output variables into the flat struct format.
+ * Arrays are flattened via extend(), scalars and string pairs via append().
+ */
+const generateOutputPackCode = (outputVariables: PLCVariable[]): string => {
+  if (outputVariables.length === 0) return '    # No output variables to write'
+
+  let code = '    # Write output variables\n'
+  code += '    _out = []\n'
+
+  outputVariables.forEach((variable) => {
+    if (isArrayVariable(variable)) {
+      code += `    _out.extend(${variable.name})\n`
+    } else if (variable.type?.definition === 'base-type' && variable.type?.value === 'string') {
+      code += `    _body = ${variable.name}.encode('utf-8')[:126]\n`
+      code += `    _len = len(_body)\n`
+      code += `    _body = _body.ljust(126, b'\\0')\n`
+      code += `    _out.append(_len)\n`
+      code += `    _out.append(_body)\n`
+    } else {
+      code += `    _out.append(${variable.name})\n`
+    }
+  })
+
+  code += '    packed = struct.pack(fmt_out, *_out)\n'
+  code += '    shm_out.buf[:data_size_out] = packed'
+
+  return code
+}
+
+const injectPythonRuntime = (params: PythonRuntimeInjectionParams): string => {
+  const { fmtIn, fmtOut, inputVariables, outputVariables, originalCode, pouName } = params
+
+  const outputInitialization = generateOutputInitialization(outputVariables)
+  const readInputSection = generateInputUnpackCode(inputVariables)
+  const writeOutputSection = generateOutputPackCode(outputVariables)
+
+  const injectedCode = `
+${originalCode}
+
+plc_pid = %d
+fmt_in = ('${fmtIn}')
+fmt_out = ('${fmtOut}')
+try:
+    shm_in = shared_memory.SharedMemory(name='%s_in')
+    shm_out = shared_memory.SharedMemory(name='%s_out')
+except Exception as e:
+    print(f'Error on shared memory: {e}')
+    exit(1)
+
+# Initialize output variables here - if any
+${outputInitialization}
+
+# Initialize block
+block_init()
+data_size_in = struct.calcsize(fmt_in)
+data_size_out = struct.calcsize(fmt_out)
+while True:
+    try:
+        os.kill(plc_pid, 0)
+    except Exception as e:
+        print('PLC runtime has stopped.')
+        break
+${readInputSection}
+
+    # Run block
+    block_loop()
+
+${writeOutputSection}
+
+    # Sleep for 100ms
+    time.sleep(0.1)
+print('Stopping Python block: ${pouName}')
+try:
+    shm_in.close()
+    shm_in.unlink()
+    shm_out.close()
+    shm_out.unlink()
+except Exception as e:
+    print(f'Cleanup error: {e}')
+`
+
+  return injectedCode
+}
+
+export { injectPythonRuntime, type PythonRuntimeInjectionParams }
diff --git a/src/renderer/utils/remote-device-options.ts b/src/frontend/utils/remote-device-options.ts
similarity index 100%
rename from src/renderer/utils/remote-device-options.ts
rename to src/frontend/utils/remote-device-options.ts
diff --git a/src/utils/s7comm/generate-s7comm-config.ts b/src/frontend/utils/s7comm/generate-s7comm-config.ts
similarity index 100%
rename from src/utils/s7comm/generate-s7comm-config.ts
rename to src/frontend/utils/s7comm/generate-s7comm-config.ts
diff --git a/src/utils/s7comm/index.ts b/src/frontend/utils/s7comm/index.ts
similarity index 100%
rename from src/utils/s7comm/index.ts
rename to src/frontend/utils/s7comm/index.ts
diff --git a/src/frontend/utils/save-project.ts b/src/frontend/utils/save-project.ts
new file mode 100644
index 000000000..96dea1fb6
--- /dev/null
+++ b/src/frontend/utils/save-project.ts
@@ -0,0 +1,142 @@
+/**
+ * Save project orchestration utilities.
+ *
+ * Handles pre-save preparation (POU sanitization, debug variable collection)
+ * and post-save cleanup (state reset, deleted lists, toast).
+ */
+
+import type { SaveProjectParams } from '../../middleware/shared/ports/project-port'
+import type { PLCPou } from '../../middleware/shared/ports/types'
+
+// ---------------------------------------------------------------------------
+// Structural types (avoids store layer import — architecture rule)
+// ---------------------------------------------------------------------------
+
+/** Minimal editor shape needed for POU sanitization. */
+interface EditorLike {
+  type: string
+  meta: { name: string }
+  variable?: { display: string; code?: string | null }
+}
+
+// ---------------------------------------------------------------------------
+// POU Sanitization
+// ---------------------------------------------------------------------------
+
+/**
+ * Syncs a POU's variablesText with the current code editor state.
+ *
+ * When a user edits variables in "code" display mode, the text lives in the
+ * editor model but hasn't been parsed back into structured variables yet.
+ * Before saving we must capture that text so the IPC layer writes it to disk.
+ */
+function sanitizePou(pou: PLCPou, editor: EditorLike | undefined): PLCPou {
+  if (!editor || (editor.type !== 'plc-textual' && editor.type !== 'plc-graphical') || !editor.variable) {
+    return pou
+  }
+
+  if (editor.variable.display === 'code' && editor.variable.code != null) {
+    return {
+      ...pou,
+      variablesText: editor.variable.code,
+    } as PLCPou & { variablesText?: string }
+  }
+
+  return pou
+}
+
+// ---------------------------------------------------------------------------
+// Debug Variable Collection
+// ---------------------------------------------------------------------------
+
+/**
+ * Collects debug flags from all variables (global + per-POU).
+ * Returns undefined if no variables have debug enabled.
+ */
+function collectDebugVariables(
+  globalVariables: { name: string; debug?: boolean }[],
+  pous: PLCPou[],
+): { global?: string[]; pous?: Record<string, string[]> } | undefined {
+  const debugVars: { global?: string[]; pous?: Record<string, string[]> } = {}
+
+  const globalDebug = globalVariables.filter((v) => v.debug === true).map((v) => v.name)
+  if (globalDebug.length > 0) {
+    debugVars.global = globalDebug
+  }
+
+  const pouDebug: Record<string, string[]> = {}
+  for (const pou of pous) {
+    const vars = (pou.interface?.variables ?? []).filter((v) => v.debug === true).map((v) => v.name)
+    if (vars.length > 0) {
+      pouDebug[pou.name] = vars
+    }
+  }
+  if (Object.keys(pouDebug).length > 0) {
+    debugVars.pous = pouDebug
+  }
+
+  return debugVars.global || debugVars.pous ? debugVars : undefined
+}
+
+// ---------------------------------------------------------------------------
+// Build Save Params
+// ---------------------------------------------------------------------------
+
+export interface PrepareSavePayloadArgs {
+  projectPath: string
+  projectName: string
+  projectData: {
+    dataTypes: unknown[]
+    pous: PLCPou[]
+    configurations: {
+      resource: { tasks: unknown[]; instances: unknown[]; globalVariables: { name: string; debug?: boolean }[] }
+    }
+    servers?: unknown[]
+    remoteDevices?: unknown[]
+  }
+  deviceConfiguration: SaveProjectParams['deviceConfiguration']
+  devicePinMapping: SaveProjectParams['devicePinMapping']
+  /** Current editor + editors list for POU sanitization. */
+  editors: EditorLike[]
+  activeEditor: EditorLike
+}
+
+/**
+ * Prepares the save payload by sanitizing POUs and collecting debug variables.
+ * Returns a SaveProjectParams ready to be passed to `projectPort.saveProject()`.
+ */
+export function prepareSavePayload(args: PrepareSavePayloadArgs): SaveProjectParams {
+  const { projectPath, projectName, projectData, deviceConfiguration, devicePinMapping, editors, activeEditor } = args
+
+  // Build editor lookup for POU sanitization
+  const editorsByName = new Map<string, EditorLike>()
+  for (const ed of editors) {
+    if (ed.type === 'plc-textual' || ed.type === 'plc-graphical') {
+      editorsByName.set(ed.meta.name, ed)
+    }
+  }
+  if (activeEditor.type === 'plc-textual' || activeEditor.type === 'plc-graphical') {
+    editorsByName.set(activeEditor.meta.name, activeEditor)
+  }
+
+  // Sanitize POUs (sync variablesText from code editor)
+  const sanitizedPous = projectData.pous.map((pou) => sanitizePou(pou, editorsByName.get(pou.name)))
+
+  // Collect debug variable flags
+  const debugVariables = collectDebugVariables(projectData.configurations.resource.globalVariables, projectData.pous)
+
+  // Build project data with sanitized POUs and debug variables
+  const preparedProjectData = {
+    ...projectData,
+    pous: sanitizedPous,
+    debugVariables,
+  }
+
+  return {
+    projectPath,
+    projectName,
+    projectData: preparedProjectData as SaveProjectParams['projectData'],
+    deviceConfiguration,
+    devicePinMapping,
+  }
+}
diff --git a/src2/frontend/components/_features/[app]/toast/use-toast.tsx b/src/frontend/utils/toast.ts
similarity index 52%
rename from src2/frontend/components/_features/[app]/toast/use-toast.tsx
rename to src/frontend/utils/toast.ts
index e5d1a6432..afeb6d766 100644
--- a/src2/frontend/components/_features/[app]/toast/use-toast.tsx
+++ b/src/frontend/utils/toast.ts
@@ -1,24 +1,18 @@
-/*-----------------------------------------------------------------------------
- * This implementation is provided by the Shadcn/UI collection, which is inspired
- * by the react-hot-toast library
- * Check the following link for more instructions:
- * https://ui.shadcn.com/docs/components/toast#installation
- *------------------------------------------------------------------------------*/
-import { ReactNode, useEffect, useState } from 'react'
-
-import type { ToastActionElement, ToastProps } from '.'
+import type { ReactNode } from 'react'
 
 const TOAST_LIMIT = 1
 const TOAST_REMOVE_DELAY = 1000000
 
-type ToasterToast = ToastProps & {
+type ToasterToast = {
   id: string
   title?: ReactNode
   description?: ReactNode
-  action?: ToastActionElement
+  action?: ReactNode
+  variant?: 'default' | 'fail' | 'warn'
+  open?: boolean
+  onOpenChange?: (open: boolean) => void
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const _actionTypes = {
   ADD_TOAST: 'ADD_TOAST',
   UPDATE_TOAST: 'UPDATE_TOAST',
@@ -28,11 +22,6 @@ const _actionTypes = {
 
 let count = 0
 
-/**
- * Generates a unique identifier.
- *
- * @return {string} The generated identifier.
- */
 function genId(): string {
   count = (count + 1) % Number.MAX_SAFE_INTEGER
   return count.toString()
@@ -64,11 +53,6 @@ interface State {
 
 const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
 
-/**
- * Add the toastId to the remove queue if it doesn't exist already.
- *
- * @param {string} toastId - The unique identifier of the toast.
- */
 const addToRemoveQueue = (toastId: string) => {
   if (toastTimeouts.has(toastId)) {
     return
@@ -85,14 +69,7 @@ const addToRemoveQueue = (toastId: string) => {
   toastTimeouts.set(toastId, timeout)
 }
 
-/**
- * Reducer function for managing state based on different action types related to toasts.
- *
- * @param {State} state - The current state of the application.
- * @param {Action} action - The action object that describes the type of operation to perform.
- * @return {State} The updated state after processing the action.
- */
-export const reducer = (state: State, action: Action): State => {
+const reducer = (state: State, action: Action): State => {
   switch (action.type) {
     case 'ADD_TOAST':
       return {
@@ -109,8 +86,6 @@ export const reducer = (state: State, action: Action): State => {
     case 'DISMISS_TOAST': {
       const { toastId } = action
 
-      // ! Side effects ! - This could be extracted into a dismissToast() action,
-      // but I'll keep it here for simplicity
       if (toastId) {
         addToRemoveQueue(toastId)
       } else {
@@ -149,12 +124,10 @@ const listeners: Array<(state: State) => void> = []
 
 let memoryState: State = { toasts: [] }
 
-/**
- * Dispatches an action to update the state using the reducer function and notifies all listeners of the updated state.
- *
- * @param {Action} action - The action object that describes the type of operation to perform.
- * @return {void} This function does not return anything.
- */
+function getMemoryState(): State {
+  return memoryState
+}
+
 function dispatch(action: Action): void {
   memoryState = reducer(memoryState, action)
   listeners.forEach((listener) => {
@@ -170,12 +143,6 @@ type toastReturnType = {
   update: (props: ToasterToast) => void
 }
 
-/**
- * Creates a new toast with the given props and dispatches actions to add, update, and dismiss the toast.
- *
- * @param {Toast} props - The props for the toast.
- * @return {toastReturnType} An object containing the id of the toast, a dismiss function to remove the toast, and an update function to update the toast.
- */
 function toast({ ...props }: Toast): toastReturnType {
   const id = genId()
 
@@ -205,37 +172,5 @@ function toast({ ...props }: Toast): toastReturnType {
   }
 }
 
-type useToastReturnType = {
-  toast: ({ ...props }: Toast) => object
-  dismiss: (toastId?: string) => void
-  toasts: ToasterToast[]
-}
-
-/**
- * Custom hook for managing toast notifications.
- *
- * @return {useToastReturnType} An object containing the current state of the toast notifications,
- * the toast function for creating new toast notifications, and the dismiss function
- * for dismissing toast notifications.
- */
-function useToast(): useToastReturnType {
-  const [state, setState] = useState<State>(memoryState)
-
-  useEffect(() => {
-    listeners.push(setState)
-    return () => {
-      const index = listeners.indexOf(setState)
-      if (index > -1) {
-        listeners.splice(index, 1)
-      }
-    }
-  }, [state])
-
-  return {
-    ...state,
-    toast,
-    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
-  }
-}
-
-export { toast, useToast }
+export { dispatch, getMemoryState, listeners, reducer, toast }
+export type { Action, State, Toast, ToasterToast, toastReturnType }
diff --git a/src2/frontend/utils/unsaved-label.ts b/src/frontend/utils/unsaved-label.ts
similarity index 100%
rename from src2/frontend/utils/unsaved-label.ts
rename to src/frontend/utils/unsaved-label.ts
diff --git a/src2/frontend/utils/variable-reference-types.ts b/src/frontend/utils/variable-reference-types.ts
similarity index 100%
rename from src2/frontend/utils/variable-reference-types.ts
rename to src/frontend/utils/variable-reference-types.ts
diff --git a/src2/frontend/utils/variable-references.ts b/src/frontend/utils/variable-references.ts
similarity index 92%
rename from src2/frontend/utils/variable-references.ts
rename to src/frontend/utils/variable-references.ts
index 73f815f45..b32164165 100644
--- a/src2/frontend/utils/variable-references.ts
+++ b/src/frontend/utils/variable-references.ts
@@ -1,8 +1,11 @@
-import type { FBDFlowState } from '../store/slices/fbd'
-import type { LadderFlowState } from '../store/slices/ladder'
-import type { PLCPou, PLCVariable } from '../../middleware/shared/ports/types'
 import type { Node } from '@xyflow/react'
 
+import type { PLCPou, PLCVariable } from '../../middleware/shared/ports/types'
+
+type LadderRung = { id: string; nodes: Node[] }
+type LadderFlow = { name: string; rungs: LadderRung[] }
+type FBDFlow = { name: string; rung: { nodes: Node[] } }
+
 export type VariableReferenceLocation = {
   pouName: string
   editorType: 'ladder' | 'fbd' | 'st' | 'il' | 'python' | 'cpp'
@@ -27,8 +30,8 @@ export function findAllReferencesToVariable(
   _variableType: PLCVariable['type'],
   pouName: string,
   pous: PLCPou[],
-  ladderFlows: LadderFlowState['ladderFlows'],
-  fbdFlows: FBDFlowState['fbdFlows'],
+  ladderFlows: LadderFlow[],
+  fbdFlows: FBDFlow[],
   scope?: 'local' | 'global',
 ): ReferenceImpactAnalysis {
   const normalizedName = variableName.toLowerCase()
@@ -37,7 +40,7 @@ export function findAllReferencesToVariable(
   const isGlobalScope = scope === 'global'
 
   if (!isGlobalScope) {
-    const pou = pous.find((p) => p.data.name === pouName)
+    const pou = pous.find((p) => p.name === pouName)
     if (!pou) {
       return {
         totalReferences: 0,
@@ -50,12 +53,12 @@ export function findAllReferencesToVariable(
     searchWithinPou(pou, pouName, normalizedName, variableName, ladderFlows, fbdFlows, references)
   } else {
     pous.forEach((pou) => {
-      const hasExternalVar = pou.data.variables.some(
+      const hasExternalVar = (pou.interface?.variables ?? []).some(
         (v) => v.class === 'external' && v.name.toLowerCase() === normalizedName,
       )
 
       if (hasExternalVar) {
-        searchWithinPou(pou, pou.data.name, normalizedName, variableName, ladderFlows, fbdFlows, references)
+        searchWithinPou(pou, pou.name, normalizedName, variableName, ladderFlows, fbdFlows, references)
       }
     })
   }
@@ -81,8 +84,8 @@ function searchWithinPou(
   pouName: string,
   normalizedName: string,
   variableName: string,
-  ladderFlows: LadderFlowState['ladderFlows'],
-  fbdFlows: FBDFlowState['fbdFlows'],
+  ladderFlows: LadderFlow[],
+  fbdFlows: FBDFlow[],
   references: VariableReferenceLocation[],
 ): void {
   const ladderFlow = ladderFlows.find((f) => f.name === pouName)
@@ -217,12 +220,12 @@ function searchWithinPou(
   }
 
   if (
-    pou.data.body.language === 'st' ||
-    pou.data.body.language === 'il' ||
-    pou.data.body.language === 'python' ||
-    pou.data.body.language === 'cpp'
+    pou.body.language === 'st' ||
+    pou.body.language === 'il' ||
+    pou.body.language === 'python' ||
+    pou.body.language === 'cpp'
   ) {
-    const bodyValue = pou.data.body.value
+    const bodyValue = pou.body.value as string
     const lines = bodyValue.split('\n')
     const variablePattern = new RegExp(`\\b${variableName}\\b`, 'gi')
 
@@ -231,7 +234,7 @@ function searchWithinPou(
       while ((match = variablePattern.exec(line)) !== null) {
         references.push({
           pouName,
-          editorType: pou.data.body.language as 'st' | 'il' | 'python' | 'cpp',
+          editorType: pou.body.language as 'st' | 'il' | 'python' | 'cpp',
           lineNumber: lineIndex + 1,
           columnStart: match.index,
           columnEnd: match.index + variableName.length,
@@ -255,12 +258,12 @@ export function propagateVariableTypeChange(
   },
 ): void {
   pous.forEach((pou) => {
-    pou.data.variables.forEach((variable, varIndex) => {
+    ;(pou.interface?.variables ?? []).forEach((variable, varIndex) => {
       if (variable.class === 'external' && variable.name.toLowerCase() === variableName.toLowerCase()) {
         projectActions.updateVariable({
           scope: 'local',
           rowId: varIndex,
-          associatedPou: pou.data.name,
+          associatedPou: pou.name,
           data: { type: newType },
         })
       }
@@ -272,8 +275,8 @@ export function propagateVariableRename(
   oldName: string,
   newName: string,
   references: VariableReferenceLocation[],
-  ladderFlows: LadderFlowState['ladderFlows'],
-  fbdFlows: FBDFlowState['fbdFlows'],
+  ladderFlows: LadderFlow[],
+  fbdFlows: FBDFlow[],
   pous: PLCPou[],
   ladderFlowActions: {
     updateNode: (params: { editorName: string; rungId: string; nodeId: string; node: Node }) => void
@@ -282,7 +285,7 @@ export function propagateVariableRename(
     updateNode: (params: { editorName: string; nodeId: string; node: Node }) => void
   },
   projectActions: {
-    updatePou: (params: { name: string; content: PLCPou['data']['body'] }) => void
+    updatePou: (params: { name: string; content: PLCPou['body'] }) => void
     updateVariable: (params: {
       scope: 'local' | 'global'
       rowId: number
@@ -294,12 +297,12 @@ export function propagateVariableRename(
 ): void {
   if (scope === 'global') {
     pous.forEach((pou) => {
-      pou.data.variables.forEach((variable, varIndex) => {
+      ;(pou.interface?.variables ?? []).forEach((variable, varIndex) => {
         if (variable.class === 'external' && variable.name.toLowerCase() === oldName.toLowerCase()) {
           projectActions.updateVariable({
             scope: 'local',
             rowId: varIndex,
-            associatedPou: pou.data.name,
+            associatedPou: pou.name,
             data: { name: newName },
           })
         }
@@ -321,13 +324,13 @@ export function propagateVariableRename(
   })
 
   textBasedRefsByPou.forEach((_refs, pouName) => {
-    const pou = pous.find((p) => p.data.name === pouName)
+    const pou = pous.find((p) => p.name === pouName)
     if (!pou) return
 
-    const bodyValue = pou.data.body.value
+    const bodyValue = pou.body.value
     if (typeof bodyValue !== 'string') return
 
-    const language = pou.data.body.language
+    const language = pou.body.language
     if (language !== 'st' && language !== 'il' && language !== 'python' && language !== 'cpp') return
 
     try {
diff --git a/src2/frontend/utils/variable-sizes.ts b/src/frontend/utils/variable-sizes.ts
similarity index 100%
rename from src2/frontend/utils/variable-sizes.ts
rename to src/frontend/utils/variable-sizes.ts
diff --git a/src/utils/PLC/variable-types.ts b/src/frontend/utils/variable-types.ts
similarity index 100%
rename from src/utils/PLC/variable-types.ts
rename to src/frontend/utils/variable-types.ts
diff --git a/src/globals.d.ts b/src/globals.d.ts
index 3390eaa0c..a198f820c 100644
--- a/src/globals.d.ts
+++ b/src/globals.d.ts
@@ -14,3 +14,10 @@ declare const APP_VERSION: string
  * @example "2026-01-26"
  */
 declare const BUILD_DATE: string
+
+/**
+ * Vitest-compatible `vi` global — aliased to `jest` in Jest via jest-vi-shim.ts
+ * so shared test files can use `vi.spyOn()` in both Jest and Vitest.
+ */
+
+declare const vi: typeof jest
diff --git a/src/i18next.d.ts b/src/i18next.d.ts
index 03713e2be..daf5ee68d 100644
--- a/src/i18next.d.ts
+++ b/src/i18next.d.ts
@@ -1,4 +1,4 @@
-import { defaultNS, resources } from './utils/i18n'
+import { defaultNS, resources } from './frontend/locales/i18n'
 
 declare module 'i18next' {
   interface CustomTypeOptions {
diff --git a/src2/index.ejs b/src/index.ejs
similarity index 100%
rename from src2/index.ejs
rename to src/index.ejs
diff --git a/src2/jest-vi-shim.ts b/src/jest-vi-shim.ts
similarity index 100%
rename from src2/jest-vi-shim.ts
rename to src/jest-vi-shim.ts
diff --git a/src2/main.tsx b/src/main.tsx
similarity index 100%
rename from src2/main.tsx
rename to src/main.tsx
diff --git a/src/main/main.ts b/src/main/main.ts
index a448eb19e..45550e1c9 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -14,15 +14,16 @@ import { enableMapSet } from 'immer'
 import { platform, release } from 'os'
 import { join, resolve } from 'path'
 
+import { CompilerModule } from '../backend/editor/compiler'
 // TODO: Refactor this type declaration
-import { MainIpcModuleConstructor } from './contracts/types/modules/ipc/main'
+import { MainIpcModuleConstructor } from '../backend/editor/contracts/types/modules/ipc/main'
+import { HardwareModule } from '../backend/editor/hardware'
+import { logger, PouService, ProjectService, UserService } from '../backend/editor/services'
+import { resolveHtmlPath } from '../backend/editor/utils'
+import { getErrorMessage } from '../frontend/utils/get-error-message'
 import MenuBuilder from './menu'
-import { CompilerModule } from './modules/compiler'
-import { HardwareModule } from './modules/hardware'
 import MainProcessBridge from './modules/ipc/main'
 import { store } from './modules/store'
-import { PouService, ProjectService, UserService } from './services'
-import { resolveHtmlPath } from './utils'
 
 enableMapSet()
 
@@ -97,7 +98,7 @@ const installExtensions = async () => {
       extensions.map((name) => installer[name as keyof typeof Installer]),
       forceDownload,
     )
-    .catch(console.log)
+    .catch((err: unknown) => logger.error(getErrorMessage(err)))
 }
 
 const createMainWindow = async () => {
@@ -138,8 +139,8 @@ const createMainWindow = async () => {
     : 'src/main/modules/preload/splash-screen/splash.html'
   splash
     .loadFile(splashPath)
-    .then(() => console.log('Splash screen loaded successfully'))
-    .catch((error) => console.error('Error loading splash screen:', error))
+    .then(() => logger.info('Splash screen loaded successfully'))
+    .catch((error: unknown) => logger.error('Error loading splash screen: ' + getErrorMessage(error)))
 
   splash.setIgnoreMouseEvents(false)
 
@@ -207,7 +208,7 @@ const createMainWindow = async () => {
    */
   mainWindow.on('close', saveBounds)
   mainWindow.on('close', () => {
-    console.log('mainWindow close')
+    logger.info('mainWindow close')
     mainWindow?.webContents.send('window-controls:is-closing')
   })
 
@@ -217,7 +218,7 @@ const createMainWindow = async () => {
    * and avoid using it any more.
    */
   mainWindow.on('closed', () => {
-    console.log('mainWindow closed')
+    logger.info('mainWindow closed')
     mainWindow = null
   })
 
@@ -345,7 +346,7 @@ app.on('activate', () => {
  * which is terminating the application.
  */
 app.on('before-quit', () => {
-  console.log('before-quit')
+  logger.info('before-quit')
   if (process.platform === 'darwin' && process.env.NODE_ENV === 'production') {
     mainWindow?.webContents.send('app:darwin-is-closing')
     return
@@ -359,7 +360,7 @@ app.on('before-quit', () => {
  * behavior, which is terminating the application.
  */
 app.on('will-quit', () => {
-  console.log('will-quit')
+  logger.info('will-quit')
 })
 
 /**
@@ -367,7 +368,7 @@ app.on('will-quit', () => {
  */
 // Emitted when the application is quitting.
 app.on('quit', () => {
-  console.log('quit')
+  logger.info('quit')
 })
 
 /**
@@ -378,7 +379,7 @@ app.on('quit', () => {
  */
 // --> Quit the app when all windows are closed except on macOS. There, it's common for applications and their menu bar to stay active;
 app.on('window-all-closed', () => {
-  console.log('window-all-closed')
+  logger.info('window-all-closed')
   // Respect the OSX convention of having the application in memory even
   // after all windows have been closed
   if (process.platform !== 'darwin') {
@@ -410,4 +411,4 @@ app
       if (mainWindow === null) void createMainWindow()
     })
   })
-  .catch(console.log)
+  .catch((err: unknown) => logger.error(getErrorMessage(err)))
diff --git a/src/main/menu.ts b/src/main/menu.ts
index f2bde2c96..44efa68d9 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -1,8 +1,8 @@
+import { i18n } from '@root/frontend/locales/i18n'
 import { BrowserWindow, Menu, MenuItemConstructorOptions, nativeTheme, shell } from 'electron'
 
-import { i18n } from '../utils/i18n'
+import { ProjectService } from '../backend/editor/services'
 import { store } from './modules/store'
-import { ProjectService } from './services'
 
 /**
  * Wip: Interface for mac machines menu.
diff --git a/src/main/modules/ipc/main.ts b/src/main/modules/ipc/main.ts
index ae73dde85..596951f1e 100644
--- a/src/main/modules/ipc/main.ts
+++ b/src/main/modules/ipc/main.ts
@@ -1,26 +1,26 @@
-import { getProjectPath } from '@root/main/utils'
+import { getRuntimeHttpsOptions } from '@root/backend/editor/utils/runtime-https-config'
 import { CreatePouFileProps } from '@root/types/IPC/pou-service'
 import { CreateProjectFileProps } from '@root/types/IPC/project-service'
 import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { PLCPou, PLCProject, PLCProjectData } from '@root/types/PLC/open-plc'
 import { RuntimeLogEntry } from '@root/types/PLC/runtime-logs'
-import { getRuntimeHttpsOptions } from '@root/utils/runtime-https-config'
+import { getErrorMessage } from '@root/utils/get-error-message'
 import type { IpcMainEvent, IpcMainInvokeEvent } from 'electron'
 import { app, nativeTheme, shell } from 'electron'
 import { readFile, realpathSync, stat, statSync, unwatchFile, watchFile } from 'fs'
-import type { IncomingMessage } from 'http'
+import type { IncomingHttpHeaders, IncomingMessage } from 'http'
 import https from 'https'
 import { join, resolve, sep } from 'path'
 import { platform } from 'process'
 
-import { ProjectState } from '../../../renderer/store/slices'
-import { PLCPou, PLCProject } from '../../../types/PLC/open-plc'
-import { MainIpcModule, MainIpcModuleConstructor } from '../../contracts/types/modules/ipc/main'
-import { logger } from '../../services'
-import { ModbusTcpClient } from '../modbus/modbus-client'
-import { ModbusRtuClient } from '../modbus/modbus-rtu-client'
-import { SimulatorModule } from '../simulator/simulator-module'
-import { VirtualSerialPort } from '../simulator/virtual-serial-port'
-import { WebSocketDebugClient } from '../websocket/websocket-debug-client'
+import { MainIpcModule, MainIpcModuleConstructor } from '../../../backend/editor/contracts/types/modules/ipc/main'
+import { ModbusTcpClient } from '../../../backend/editor/modbus/modbus-client'
+import { ModbusRtuClient } from '../../../backend/editor/modbus/modbus-rtu-client'
+import { logger } from '../../../backend/editor/services'
+import { getProjectPath } from '../../../backend/editor/utils'
+import { WebSocketDebugClient } from '../../../backend/editor/websocket/websocket-debug-client'
+import { SimulatorModule } from '../../../backend/shared/simulator/simulator-module'
+import { VirtualSerialPort } from '../../../backend/shared/simulator/virtual-serial-port'
 
 type IDataToWrite = {
   projectPath: string
@@ -41,6 +41,7 @@ class MainProcessBridge implements MainIpcModule {
   pouService
   compilerModule
   hardwareModule
+  private registeredHandleChannels: string[] = []
   private debuggerModbusClient: ModbusTcpClient | ModbusRtuClient | null = null
   private debuggerWebSocketClient: WebSocketDebugClient | null = null
   private debuggerTargetIp: string | null = null
@@ -83,45 +84,79 @@ class MainProcessBridge implements MainIpcModule {
   private readonly RUNTIME_API_PORT = 8443
   private readonly RUNTIME_CONNECTION_TIMEOUT_MS = 5000 // 5 seconds (important-comment)
 
-  handleRuntimeGetUsersInfo = async (_event: IpcMainInvokeEvent, ipAddress: string) => {
-    try {
-      const url = `https://${ipAddress}:${this.RUNTIME_API_PORT}/api/get-users-info`
-
-      return new Promise((resolve) => {
-        const req = https.get(
-          url,
-          {
-            ...getRuntimeHttpsOptions(),
-          },
-          (res: IncomingMessage) => {
-            let data = ''
-            res.on('data', (chunk: Buffer) => {
-              data += chunk.toString()
-            })
-            res.on('end', () => {
-              // Extract runtime version from response header
-              const runtimeVersion = res.headers['x-openplc-runtime-version'] as string | undefined
-
-              if (res.statusCode === 404) {
-                resolve({ hasUsers: false, runtimeVersion })
-              } else if (res.statusCode === 200) {
-                resolve({ hasUsers: true, runtimeVersion })
-              } else {
-                resolve({ hasUsers: false, error: data || `Unexpected status: ${res.statusCode}`, runtimeVersion })
+  /**
+   * Low-level HTTP helper that handles data accumulation, timeout, and error handling.
+   * Returns the raw status code, response body, and headers for the caller to interpret.
+   */
+  private httpRequest(options: {
+    method: 'GET' | 'POST'
+    url: string
+    body?: string
+    headers?: Record<string, string>
+  }): Promise<{ statusCode: number; data: string; headers: IncomingHttpHeaders }> {
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(options.url)
+      const reqOptions = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: options.method,
+        headers: {
+          ...options.headers,
+          ...(options.body
+            ? {
+                'Content-Type': 'application/json',
+                'Content-Length': String(Buffer.byteLength(options.body)),
               }
-            })
-          },
-        )
-        req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
-          req.destroy()
-          resolve({ hasUsers: false, error: 'Connection timeout' })
+            : {}),
+        },
+        ...getRuntimeHttpsOptions(),
+      }
+
+      const req = https.request(reqOptions as https.RequestOptions, (res: IncomingMessage) => {
+        let data = ''
+        res.on('data', (chunk: Buffer) => {
+          data += chunk.toString()
         })
-        req.on('error', (error: Error) => {
-          resolve({ hasUsers: false, error: error.message })
+        res.on('end', () => {
+          resolve({ statusCode: res.statusCode ?? 0, data, headers: res.headers })
         })
       })
+      req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
+        req.destroy()
+        reject(new Error('Connection timeout'))
+      })
+      req.on('error', (error: Error) => {
+        reject(error)
+      })
+      if (options.body) {
+        req.write(options.body)
+      }
+      req.end()
+    })
+  }
+
+  private runtimeUrl(ipAddress: string, endpoint: string): string {
+    return `https://${ipAddress}:${this.RUNTIME_API_PORT}${endpoint}`
+  }
+
+  handleRuntimeGetUsersInfo = async (_event: IpcMainInvokeEvent, ipAddress: string) => {
+    try {
+      const res = await this.httpRequest({
+        method: 'GET',
+        url: this.runtimeUrl(ipAddress, '/api/get-users-info'),
+      })
+      const runtimeVersion = res.headers['x-openplc-runtime-version'] as string | undefined
+
+      if (res.statusCode === 404) {
+        return { hasUsers: false, runtimeVersion }
+      } else if (res.statusCode === 200) {
+        return { hasUsers: true, runtimeVersion }
+      } else {
+        return { hasUsers: false, error: res.data || `Unexpected status: ${res.statusCode}`, runtimeVersion }
+      }
     } catch (error) {
-      return { hasUsers: false, error: String(error) }
+      return { hasUsers: false, error: getErrorMessage(error) }
     }
   }
 
@@ -132,47 +167,17 @@ class MainProcessBridge implements MainIpcModule {
     password: string,
   ) => {
     try {
-      const postData = JSON.stringify({ username, password, role: 'user' })
-
-      return new Promise((resolve) => {
-        const req = https.request(
-          {
-            hostname: ipAddress,
-            port: this.RUNTIME_API_PORT,
-            path: '/api/create-user',
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Content-Length': Buffer.byteLength(postData),
-            },
-            ...getRuntimeHttpsOptions(),
-          },
-          (res: IncomingMessage) => {
-            let data = ''
-            res.on('data', (chunk: Buffer) => {
-              data += chunk.toString()
-            })
-            res.on('end', () => {
-              if (res.statusCode === 201) {
-                resolve({ success: true })
-              } else {
-                resolve({ success: false, error: data })
-              }
-            })
-          },
-        )
-        req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
-          req.destroy()
-          resolve({ success: false, error: 'Connection timeout' })
-        })
-        req.on('error', (error: Error) => {
-          resolve({ success: false, error: error.message })
-        })
-        req.write(postData)
-        req.end()
+      const res = await this.httpRequest({
+        method: 'POST',
+        url: this.runtimeUrl(ipAddress, '/api/create-user'),
+        body: JSON.stringify({ username, password, role: 'user' }),
       })
+      if (res.statusCode === 201) {
+        return { success: true }
+      }
+      return { success: false, error: res.data }
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -182,52 +187,22 @@ class MainProcessBridge implements MainIpcModule {
     password: string,
   ): Promise<{ success: boolean; accessToken?: string; error?: string }> {
     try {
-      const postData = JSON.stringify({ username, password })
-
-      return new Promise((resolve) => {
-        const req = https.request(
-          {
-            hostname: ipAddress,
-            port: this.RUNTIME_API_PORT,
-            path: '/api/login',
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Content-Length': Buffer.byteLength(postData),
-            },
-            ...getRuntimeHttpsOptions(),
-          },
-          (res: IncomingMessage) => {
-            let data = ''
-            res.on('data', (chunk: Buffer) => {
-              data += chunk.toString()
-            })
-            res.on('end', () => {
-              if (res.statusCode === 200) {
-                try {
-                  const response = JSON.parse(data) as { access_token: string }
-                  resolve({ success: true, accessToken: response.access_token })
-                } catch {
-                  resolve({ success: false, error: 'Invalid response format' })
-                }
-              } else {
-                resolve({ success: false, error: data })
-              }
-            })
-          },
-        )
-        req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
-          req.destroy()
-          resolve({ success: false, error: 'Connection timeout' })
-        })
-        req.on('error', (error: Error) => {
-          resolve({ success: false, error: error.message })
-        })
-        req.write(postData)
-        req.end()
+      const res = await this.httpRequest({
+        method: 'POST',
+        url: this.runtimeUrl(ipAddress, '/api/login'),
+        body: JSON.stringify({ username, password }),
       })
+      if (res.statusCode === 200) {
+        try {
+          const response = JSON.parse(res.data) as { access_token: string }
+          return { success: true, accessToken: response.access_token }
+        } catch {
+          return { success: false, error: 'Invalid response format' }
+        }
+      }
+      return { success: false, error: res.data }
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -270,103 +245,66 @@ class MainProcessBridge implements MainIpcModule {
     )
   }
 
-  makeRuntimeApiRequest<T = void>(
+  private parseApiResponse<T>(
+    data: string,
+    responseParser?: (data: string) => T,
+  ): { success: true; data?: T } | { success: false; error: string } {
+    if (responseParser) {
+      try {
+        return { success: true, data: responseParser(data) }
+      } catch {
+        return { success: false, error: 'Invalid response format' }
+      }
+    }
+    return { success: true }
+  }
+
+  async makeRuntimeApiRequest<T = void>(
     ipAddress: string,
     jwtToken: string,
     endpoint: string,
     responseParser?: (data: string) => T,
   ): Promise<{ success: true; data?: T } | { success: false; error: string }> {
-    return new Promise((resolve) => {
-      const req = https.get(
-        `https://${ipAddress}:${this.RUNTIME_API_PORT}${endpoint}`,
-        {
-          headers: {
-            Authorization: `Bearer ${jwtToken}`,
-          },
-          ...getRuntimeHttpsOptions(),
-        },
-        (res: IncomingMessage) => {
-          let data = ''
-          res.on('data', (chunk: Buffer) => {
-            data += chunk.toString()
-          })
-          res.on('end', () => {
-            if (res.statusCode === 200) {
-              if (responseParser) {
-                try {
-                  const parsedData = responseParser(data)
-                  resolve({ success: true, data: parsedData })
-                } catch {
-                  resolve({ success: false, error: 'Invalid response format' })
-                }
-              } else {
-                resolve({ success: true })
-              }
-            } else if (this.isTokenExpiredError(res.statusCode, data)) {
-              void this.attemptTokenRefresh().then((refreshResult) => {
-                if (refreshResult.success && refreshResult.accessToken) {
-                  if (this.mainWindow && this.mainWindow.webContents) {
-                    this.mainWindow.webContents.send('runtime:token-refreshed', refreshResult.accessToken)
-                  }
-                  const retryReq = https.get(
-                    `https://${ipAddress}:${this.RUNTIME_API_PORT}${endpoint}`,
-                    {
-                      headers: {
-                        Authorization: `Bearer ${refreshResult.accessToken}`,
-                      },
-                      ...getRuntimeHttpsOptions(),
-                    },
-                    (retryRes: IncomingMessage) => {
-                      let retryData = ''
-                      retryRes.on('data', (chunk: Buffer) => {
-                        retryData += chunk.toString()
-                      })
-                      retryRes.on('end', () => {
-                        if (retryRes.statusCode === 200) {
-                          if (responseParser) {
-                            try {
-                              const parsedData = responseParser(retryData)
-                              resolve({ success: true, data: parsedData })
-                            } catch {
-                              resolve({ success: false, error: 'Invalid response format' })
-                            }
-                          } else {
-                            resolve({ success: true })
-                          }
-                        } else {
-                          resolve({ success: false, error: retryData })
-                        }
-                      })
-                    },
-                  )
-                  retryReq.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
-                    retryReq.destroy()
-                    resolve({ success: false, error: 'Connection timeout' })
-                  })
-                  retryReq.on('error', (error: Error) => {
-                    resolve({ success: false, error: error.message })
-                  })
-                } else {
-                  resolve({
-                    success: false,
-                    error: refreshResult.error ? `Token refresh failed: ${refreshResult.error}` : data,
-                  })
-                }
-              })
-            } else {
-              resolve({ success: false, error: data })
-            }
-          })
-        },
-      )
-      req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
-        req.destroy()
-        resolve({ success: false, error: 'Connection timeout' })
+    try {
+      const url = this.runtimeUrl(ipAddress, endpoint)
+      const res = await this.httpRequest({
+        method: 'GET',
+        url,
+        headers: { Authorization: `Bearer ${jwtToken}` },
       })
-      req.on('error', (error: Error) => {
-        resolve({ success: false, error: error.message })
+
+      if (res.statusCode === 200) {
+        return this.parseApiResponse(res.data, responseParser)
+      }
+
+      if (!this.isTokenExpiredError(res.statusCode, res.data)) {
+        return { success: false, error: res.data }
+      }
+
+      // Attempt token refresh and retry
+      const refreshResult = await this.attemptTokenRefresh()
+      if (!refreshResult.success || !refreshResult.accessToken) {
+        return {
+          success: false,
+          error: refreshResult.error ? `Token refresh failed: ${refreshResult.error}` : res.data,
+        }
+      }
+
+      this.mainWindow?.webContents?.send('runtime:token-refreshed', refreshResult.accessToken)
+
+      const retryRes = await this.httpRequest({
+        method: 'GET',
+        url,
+        headers: { Authorization: `Bearer ${refreshResult.accessToken}` },
       })
-    })
+
+      if (retryRes.statusCode === 200) {
+        return this.parseApiResponse(retryRes.data, responseParser)
+      }
+      return { success: false, error: retryRes.data }
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) }
+    }
   }
 
   handleRuntimeGetStatus = async (
@@ -424,7 +362,7 @@ class MainProcessBridge implements MainIpcModule {
         return { success: false, error: !result.success ? result.error : 'Unknown error' }
       }
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -432,7 +370,7 @@ class MainProcessBridge implements MainIpcModule {
     try {
       return await this.makeRuntimeApiRequest(ipAddress, jwtToken, '/api/start-plc')
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -440,7 +378,7 @@ class MainProcessBridge implements MainIpcModule {
     try {
       return await this.makeRuntimeApiRequest(ipAddress, jwtToken, '/api/stop-plc')
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -457,7 +395,7 @@ class MainProcessBridge implements MainIpcModule {
       )
       return result
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -479,7 +417,7 @@ class MainProcessBridge implements MainIpcModule {
         return { success: false, error: result.error }
       }
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -515,29 +453,51 @@ class MainProcessBridge implements MainIpcModule {
         return { success: false, error: result.success ? 'No data returned' : result.error }
       }
     } catch (error) {
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
   // ===================== IPC HANDLER REGISTRATION =====================
+
+  /**
+   * Register an invoke handler and track the channel for cleanup.
+   */
+  private registerHandle(channel: string, handler: (...args: unknown[]) => unknown) {
+    this.registeredHandleChannels.push(channel)
+    this.ipcMain.handle(channel, handler)
+  }
+
+  /**
+   * Remove all previously registered invoke handlers so they can be
+   * re-registered with fresh references on macOS window reopen.
+   */
+  private cleanupHandlers() {
+    for (const channel of this.registeredHandleChannels) {
+      this.ipcMain.removeHandler(channel)
+    }
+    this.registeredHandleChannels = []
+  }
+
   setupMainIpcListener() {
+    this.cleanupHandlers()
+
     // Project-related handlers
-    this.ipcMain.handle('project:create', this.handleProjectCreate)
-    this.ipcMain.handle('project:open', this.handleProjectOpen)
-    this.ipcMain.handle('project:path-picker', this.handleProjectPathPicker)
-    this.ipcMain.handle('project:save', this.handleProjectSave)
-    this.ipcMain.handle('project:save-file', this.handleFileSave)
-    this.ipcMain.handle('project:open-by-path', this.handleProjectOpenByPath)
+    this.registerHandle('project:create', this.handleProjectCreate)
+    this.registerHandle('project:open', this.handleProjectOpen)
+    this.registerHandle('project:path-picker', this.handleProjectPathPicker)
+    this.registerHandle('project:save', this.handleProjectSave)
+    this.registerHandle('project:save-file', this.handleFileSave)
+    this.registerHandle('project:open-by-path', this.handleProjectOpenByPath)
 
     // Pou-related handlers
-    this.ipcMain.handle('pou:create', this.handleCreatePouFile)
-    this.ipcMain.handle('pou:delete', this.handleDeletePouFile)
-    this.ipcMain.handle('pou:rename', this.handleRenamePouFile)
+    this.registerHandle('pou:create', this.handleCreatePouFile)
+    this.registerHandle('pou:delete', this.handleDeletePouFile)
+    this.registerHandle('pou:rename', this.handleRenamePouFile)
 
     // App and system handlers
-    this.ipcMain.handle('open-external-link', this.handleOpenExternalLink)
-    this.ipcMain.handle('system:get-system-info', this.handleGetSystemInfo)
-    this.ipcMain.handle('app:store-retrieve-recent', this.handleStoreRetrieveRecent)
+    this.registerHandle('open-external-link', this.handleOpenExternalLink)
+    this.registerHandle('system:get-system-info', this.handleGetSystemInfo)
+    this.registerHandle('app:store-retrieve-recent', this.handleStoreRetrieveRecent)
     this.ipcMain.on('app:quit', this.handleAppQuit)
     // this.ipcMain.on('app:reply-if-app-is-closing', (_, shouldQuit) => { ... })
 
@@ -547,7 +507,7 @@ class MainProcessBridge implements MainIpcModule {
 
     // ===================== COMPILER SERVICE =====================
     // TODO: This handle should be refactored to use MessagePortMain for better performance.
-    this.ipcMain.handle('compiler:export-project-xml', this.handleCompilerExportProjectXml)
+    this.registerHandle('compiler:export-project-xml', this.handleCompilerExportProjectXml)
     this.ipcMain.on('compiler:run-compile-program', this.handleRunCompileProgram)
     this.ipcMain.on('compiler:run-debug-compilation', this.handleRunDebugCompilation)
 
@@ -569,46 +529,46 @@ class MainProcessBridge implements MainIpcModule {
     this.ipcMain.on('window:rebuild-menu', this.handleWindowRebuildMenu)
 
     // ===================== HARDWARE =====================
-    this.ipcMain.handle('hardware:get-available-communication-ports', this.handleHardwareGetAvailableCommunicationPorts)
-    this.ipcMain.handle('hardware:get-available-boards', this.handleHardwareGetAvailableBoards)
-    this.ipcMain.handle('hardware:refresh-communication-ports', this.handleHardwareRefreshCommunicationPorts)
-    this.ipcMain.handle('hardware:refresh-available-boards', this.handleHardwareRefreshAvailableBoards)
+    this.registerHandle('hardware:get-available-communication-ports', this.handleHardwareGetAvailableCommunicationPorts)
+    this.registerHandle('hardware:get-available-boards', this.handleHardwareGetAvailableBoards)
+    this.registerHandle('hardware:refresh-communication-ports', this.handleHardwareRefreshCommunicationPorts)
+    this.registerHandle('hardware:refresh-available-boards', this.handleHardwareRefreshAvailableBoards)
 
     // ===================== UTILITIES =====================
-    this.ipcMain.handle('util:get-preview-image', this.handleUtilGetPreviewImage)
+    this.registerHandle('util:get-preview-image', this.handleUtilGetPreviewImage)
     this.ipcMain.on('util:log', this.handleUtilLog)
-    this.ipcMain.handle('util:read-debug-file', this.handleReadDebugFile)
+    this.registerHandle('util:read-debug-file', this.handleReadDebugFile)
 
     // ===================== DEBUGGER =====================
-    this.ipcMain.handle('debugger:verify-md5', this.handleDebuggerVerifyMd5)
-    this.ipcMain.handle('debugger:read-program-st-md5', this.handleReadProgramStMd5)
-    this.ipcMain.handle('debugger:get-variables-list', this.handleDebuggerGetVariablesList)
-    this.ipcMain.handle('debugger:set-variable', this.handleDebuggerSetVariable)
-    this.ipcMain.handle('debugger:connect', this.handleDebuggerConnect)
-    this.ipcMain.handle('debugger:disconnect', this.handleDebuggerDisconnect)
+    this.registerHandle('debugger:verify-md5', this.handleDebuggerVerifyMd5)
+    this.registerHandle('debugger:read-program-st-md5', this.handleReadProgramStMd5)
+    this.registerHandle('debugger:get-variables-list', this.handleDebuggerGetVariablesList)
+    this.registerHandle('debugger:set-variable', this.handleDebuggerSetVariable)
+    this.registerHandle('debugger:connect', this.handleDebuggerConnect)
+    this.registerHandle('debugger:disconnect', this.handleDebuggerDisconnect)
 
     // ===================== RUNTIME API =====================
-    this.ipcMain.handle('runtime:get-users-info', this.handleRuntimeGetUsersInfo)
-    this.ipcMain.handle('runtime:create-user', this.handleRuntimeCreateUser)
-    this.ipcMain.handle('runtime:login', this.handleRuntimeLogin)
-    this.ipcMain.handle('runtime:get-status', this.handleRuntimeGetStatus)
-    this.ipcMain.handle('runtime:start-plc', this.handleRuntimeStartPlc)
-    this.ipcMain.handle('runtime:stop-plc', this.handleRuntimeStopPlc)
-    this.ipcMain.handle('runtime:get-compilation-status', this.handleRuntimeGetCompilationStatus)
-    this.ipcMain.handle('runtime:get-logs', this.handleRuntimeGetLogs)
-    this.ipcMain.handle('runtime:clear-credentials', this.handleRuntimeClearCredentials)
-    this.ipcMain.handle('runtime:get-serial-ports', this.handleRuntimeGetSerialPorts)
+    this.registerHandle('runtime:get-users-info', this.handleRuntimeGetUsersInfo)
+    this.registerHandle('runtime:create-user', this.handleRuntimeCreateUser)
+    this.registerHandle('runtime:login', this.handleRuntimeLogin)
+    this.registerHandle('runtime:get-status', this.handleRuntimeGetStatus)
+    this.registerHandle('runtime:start-plc', this.handleRuntimeStartPlc)
+    this.registerHandle('runtime:stop-plc', this.handleRuntimeStopPlc)
+    this.registerHandle('runtime:get-compilation-status', this.handleRuntimeGetCompilationStatus)
+    this.registerHandle('runtime:get-logs', this.handleRuntimeGetLogs)
+    this.registerHandle('runtime:clear-credentials', this.handleRuntimeClearCredentials)
+    this.registerHandle('runtime:get-serial-ports', this.handleRuntimeGetSerialPorts)
 
     // ===================== SIMULATOR =====================
-    this.ipcMain.handle('simulator:load-firmware', this.handleSimulatorLoadFirmware)
-    this.ipcMain.handle('simulator:stop', this.handleSimulatorStop)
-    this.ipcMain.handle('simulator:is-running', this.handleSimulatorIsRunning)
+    this.registerHandle('simulator:load-firmware', this.handleSimulatorLoadFirmware)
+    this.registerHandle('simulator:stop', this.handleSimulatorStop)
+    this.registerHandle('simulator:is-running', this.handleSimulatorIsRunning)
 
     // ===================== FILE WATCHER =====================
-    this.ipcMain.handle('file:watch-start', this.handleFileWatchStart)
-    this.ipcMain.handle('file:watch-stop', this.handleFileWatchStop)
-    this.ipcMain.handle('file:watch-stop-all', this.handleFileWatchStopAll)
-    this.ipcMain.handle('file:read-content', this.handleFileReadContent)
+    this.registerHandle('file:watch-start', this.handleFileWatchStart)
+    this.registerHandle('file:watch-stop', this.handleFileWatchStop)
+    this.registerHandle('file:watch-stop-all', this.handleFileWatchStopAll)
+    this.registerHandle('file:read-content', this.handleFileReadContent)
   }
 
   // ===================== HANDLER METHODS =====================
@@ -633,9 +593,9 @@ class MainProcessBridge implements MainIpcModule {
         const res = await getProjectPath(windowManager)
         return res
       }
-      console.error('Window object not defined')
+      logger.error('Window object not defined')
     } catch (error) {
-      console.error('Error getting project path:', error)
+      logger.error('Error getting project path: ' + getErrorMessage(error))
     }
   }
   handleFileSave = async (_event: IpcMainInvokeEvent, filePath: string, content: unknown) => {
@@ -683,7 +643,7 @@ class MainProcessBridge implements MainIpcModule {
       const response = await this.pouService.createPouFile(props)
       return response
     } catch (error) {
-      console.error('Error creating POU file:', error)
+      logger.error('Error creating POU file: ' + getErrorMessage(error))
       return {
         success: false,
         error: {
@@ -699,7 +659,7 @@ class MainProcessBridge implements MainIpcModule {
       const response = await this.pouService.deletePouFile(filePath)
       return response
     } catch (error) {
-      console.error('Error deleting POU file:', error)
+      logger.error('Error deleting POU file: ' + getErrorMessage(error))
       return {
         success: false,
         error: {
@@ -722,7 +682,7 @@ class MainProcessBridge implements MainIpcModule {
       const response = await this.pouService.renamePouFile(data)
       return response
     } catch (error) {
-      console.error('Error renaming POU file:', error)
+      logger.error('Error renaming POU file: ' + getErrorMessage(error))
       return {
         success: false,
         error: {
@@ -740,7 +700,7 @@ class MainProcessBridge implements MainIpcModule {
       await shell.openExternal(url)
       return { success: true }
     } catch (error) {
-      console.error('Error opening external link:', error)
+      logger.error('Error opening external link: ' + getErrorMessage(error))
       return { success: false, error }
     }
   }
@@ -766,7 +726,7 @@ class MainProcessBridge implements MainIpcModule {
     try {
       return response
     } catch (error) {
-      console.error('Error reading history file:', error)
+      logger.error('Error reading history file: ' + getErrorMessage(error))
       return []
     }
   }
@@ -783,16 +743,16 @@ class MainProcessBridge implements MainIpcModule {
   handleCompilerExportProjectXml = (
     _ev: IpcMainInvokeEvent,
     pathToUserProject: string,
-    dataToCreateXml: ProjectState['data'],
+    dataToCreateXml: PLCProjectData,
     xmlFormatTarget: 'old-editor' | 'codesys',
   ) => this.compilerModule.createXmlFile(pathToUserProject, dataToCreateXml, xmlFormatTarget)
 
-  handleRunCompileProgram = (event: IpcMainEvent, args: Array<string | ProjectState['data']>) => {
+  handleRunCompileProgram = (event: IpcMainEvent, args: Array<string | PLCProjectData>) => {
     const mainProcessPort = event.ports[0]
     void this.compilerModule.compileProgram(args, mainProcessPort, this)
   }
 
-  handleRunDebugCompilation = (event: IpcMainEvent, args: Array<string | ProjectState['data']>) => {
+  handleRunDebugCompilation = (event: IpcMainEvent, args: Array<string | PLCProjectData>) => {
     const mainProcessPort = event.ports[0]
     void this.compilerModule.compileForDebugger(args, mainProcessPort)
   }
@@ -809,7 +769,7 @@ class MainProcessBridge implements MainIpcModule {
   // handleCompilerBuildXmlFile = (
   //   _ev: IpcMainInvokeEvent,
   //   pathToUserProject: string,
-  //   dataToCreateXml: ProjectState['data'],
+  //   dataToCreateXml: PLCProjectData,
   // ) => this.compilerService.buildXmlFile(pathToUserProject, dataToCreateXml)
   // handleCompilerBuildStProgram = (event: IpcMainEvent, pathToXMLFile: string) => {
   //   const replyPort = Array.isArray(event.ports) && event.ports.length > 0 ? event.ports[0] : undefined
@@ -1061,7 +1021,7 @@ class MainProcessBridge implements MainIpcModule {
         } catch (error) {
           this.debuggerWebSocketClient = null
           this.debuggerReconnecting = false
-          return { success: false, error: `Failed to reconnect: ${String(error)}`, needsReconnect: true }
+          return { success: false, error: `Failed to reconnect: ${getErrorMessage(error)}`, needsReconnect: true }
         }
       }
 
@@ -1083,7 +1043,7 @@ class MainProcessBridge implements MainIpcModule {
           this.debuggerWebSocketClient.disconnect()
           this.debuggerWebSocketClient = null
         }
-        return { success: false, error: String(error), needsReconnect: true }
+        return { success: false, error: getErrorMessage(error), needsReconnect: true }
       }
     }
 
@@ -1134,7 +1094,7 @@ class MainProcessBridge implements MainIpcModule {
       } catch (error) {
         this.debuggerModbusClient = null
         this.debuggerReconnecting = false
-        return { success: false, error: `Failed to reconnect: ${String(error)}`, needsReconnect: true }
+        return { success: false, error: `Failed to reconnect: ${getErrorMessage(error)}`, needsReconnect: true }
       }
     }
 
@@ -1156,7 +1116,7 @@ class MainProcessBridge implements MainIpcModule {
         this.debuggerModbusClient.disconnect()
         this.debuggerModbusClient = null
       }
-      return { success: false, error: String(error), needsReconnect: true }
+      return { success: false, error: getErrorMessage(error), needsReconnect: true }
     }
   }
 
@@ -1283,7 +1243,7 @@ class MainProcessBridge implements MainIpcModule {
       this.debuggerRtuBaudRate = null
       this.debuggerRtuSlaveId = null
       this.debuggerJwtToken = null
-      return { success: false, error: String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -1316,32 +1276,32 @@ class MainProcessBridge implements MainIpcModule {
 
     if (this.debuggerConnectionType === 'websocket') {
       if (!this.debuggerWebSocketClient) {
-        console.log('[IPC Handler] WebSocket client not connected')
+        logger.info('[IPC Handler] WebSocket client not connected')
         return { success: false, error: 'Not connected to debugger' }
       }
 
       try {
         const result = await this.debuggerWebSocketClient.setVariable(variableIndex, force, buffer)
-        console.log('[IPC Handler] WebSocket setVariable result:', result)
+        logger.info('[IPC Handler] WebSocket setVariable result: ' + JSON.stringify(result))
         return result
       } catch (error) {
-        console.error('[IPC Handler] WebSocket setVariable error:', error)
-        return { success: false, error: String(error) }
+        logger.error('[IPC Handler] WebSocket setVariable error: ' + getErrorMessage(error))
+        return { success: false, error: getErrorMessage(error) }
       }
     }
 
     if (!this.debuggerModbusClient) {
-      console.log('[IPC Handler] Modbus client not connected')
+      logger.info('[IPC Handler] Modbus client not connected')
       return { success: false, error: 'Not connected to debugger' }
     }
 
     try {
       const result = await this.debuggerModbusClient.setVariable(variableIndex, force, buffer)
-      console.log('[IPC Handler] Modbus setVariable result:', result)
+      logger.info('[IPC Handler] Modbus setVariable result: ' + JSON.stringify(result))
       return result
     } catch (error) {
-      console.error('[IPC Handler] Modbus setVariable error:', error)
-      return { success: false, error: String(error) }
+      logger.error('[IPC Handler] Modbus setVariable error: ' + getErrorMessage(error))
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -1380,10 +1340,12 @@ class MainProcessBridge implements MainIpcModule {
     hexPath: string,
   ): Promise<{ success: boolean; error?: string }> => {
     try {
-      await this.simulatorModule.loadAndRun(hexPath)
+      const fs = await import('fs/promises')
+      const hexContent = await fs.readFile(hexPath, 'utf-8')
+      this.simulatorModule.loadAndRun(hexContent)
       return { success: true }
     } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) }
+      return { success: false, error: getErrorMessage(error) }
     }
   }
 
@@ -1434,7 +1396,7 @@ class MainProcessBridge implements MainIpcModule {
           this.fileWatchers.set(filePath, { lastMtime: initialMtime })
           res({ success: true })
         } catch (error) {
-          res({ success: false, error: `Failed to watch file: ${String(error)}` })
+          res({ success: false, error: `Failed to watch file: ${getErrorMessage(error)}` })
         }
       })
     })
@@ -1480,7 +1442,10 @@ class MainProcessBridge implements MainIpcModule {
   // ===================== EVENT HANDLERS =====================
   mainIpcEventHandlers = {
     handleUpdateTheme: () => {
-      nativeTheme.themeSource = nativeTheme.shouldUseDarkColors ? 'light' : 'dark'
+      const newTheme = nativeTheme.shouldUseDarkColors ? 'light' : 'dark'
+      nativeTheme.themeSource = newTheme
+      const appStore = this.store as unknown as { set: (key: string, value: string) => void }
+      appStore.set('theme', newTheme)
     },
     createPou: () => this.mainWindow?.webContents.send('pou:createPou', { ok: true }),
   }
diff --git a/src/main/modules/ipc/renderer.ts b/src/main/modules/ipc/renderer.ts
index 24d3d5e0b..218f8f32a 100644
--- a/src/main/modules/ipc/renderer.ts
+++ b/src/main/modules/ipc/renderer.ts
@@ -1,14 +1,21 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return */
 import { CreatePouFileProps, PouServiceResponse } from '@root/types/IPC/pou-service'
 import { CreateProjectFileProps, IProjectServiceResponse } from '@root/types/IPC/project-service'
 import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
 import { RuntimeLogEntry } from '@root/types/PLC/runtime-logs'
 import { ipcRenderer, IpcRendererEvent } from 'electron'
 
-import { ProjectState } from '../../../renderer/store/slices'
-import { PLCPou, PLCProject } from '../../../types/PLC/open-plc'
+import { PLCPou, PLCProject, PLCProjectData } from '../../../types/PLC/open-plc'
 
-type IpcRendererCallbacks = (_event: IpcRendererEvent, ...args: any) => void
+type IpcRendererCallbacks = (_event: IpcRendererEvent, ...args: unknown[]) => void
+
+/** Data posted through the MessagePort by the compiler module. */
+type CompilerPortMessage = {
+  message?: string
+  logLevel?: string
+  simulatorFirmwarePath?: string
+  plcStatus?: string
+  closePort?: boolean
+}
 
 type IDataToWrite = {
   projectPath: string
@@ -17,8 +24,8 @@ type IDataToWrite = {
     pous: PLCPou[]
     deviceConfiguration: DeviceConfiguration
     devicePinMapping: DevicePin[]
-    servers?: ProjectState['data']['servers']
-    remoteDevices?: ProjectState['data']['remoteDevices']
+    servers?: PLCProjectData['servers']
+    remoteDevices?: PLCProjectData['remoteDevices']
   }
 }
 
@@ -132,22 +139,25 @@ const rendererProcessBridge = {
   // !! Deprecated: This method is an outdated implementation and should be substituted.
   exportProjectXml: async (
     pathToUserProject: string,
-    dataToCreateXml: ProjectState['data'],
+    dataToCreateXml: PLCProjectData,
     parseTo: 'old-editor' | 'codesys',
   ): Promise<{ success: boolean; message: string }> =>
-    ipcRenderer.invoke('compiler:export-project-xml', pathToUserProject, dataToCreateXml, parseTo),
+    ipcRenderer.invoke('compiler:export-project-xml', pathToUserProject, dataToCreateXml, parseTo) as Promise<{
+      success: boolean
+      message: string
+    }>,
   // =================== Work in Progress ===================
   // This method is a placeholder for running the compile program.
   runCompileProgram: (
-    compileProgramArgs: Array<string | boolean | null | ProjectState['data']>,
-    callback: (args: any) => void,
+    compileProgramArgs: Array<string | boolean | null | PLCProjectData>,
+    callback: (args: CompilerPortMessage) => void,
   ) => {
     // Create a MessageChannel to communicate between the renderer and main process
     const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
     // Send to the main process a message to run the compile program
     // The main process will handle the compilation and send the result back through the port
     ipcRenderer.postMessage('compiler:run-compile-program', compileProgramArgs, [mainProcessPort])
-    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.onmessage = (event) => callback(event.data as CompilerPortMessage)
     rendererProcessPort.addEventListener('close', () =>
       callback({
         closePort: true,
@@ -157,10 +167,10 @@ const rendererProcessBridge = {
     // Set up the renderer process port to listen for messages from the main process
   },
 
-  runDebugCompilation: (compileArgs: Array<string | ProjectState['data']>, callback: (args: any) => void) => {
+  runDebugCompilation: (compileArgs: Array<string | PLCProjectData>, callback: (args: CompilerPortMessage) => void) => {
     const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
     ipcRenderer.postMessage('compiler:run-debug-compilation', compileArgs, [mainProcessPort])
-    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.onmessage = (event) => callback(event.data as CompilerPortMessage)
     rendererProcessPort.addEventListener('close', () =>
       callback({
         closePort: true,
@@ -169,33 +179,39 @@ const rendererProcessBridge = {
   },
 
   // !! Deprecated: These methods are an outdated implementation and should be removed.
-  compileRequest: (xmlPath: string, callback: (args: any) => void) => {
+  compileRequest: (xmlPath: string, callback: (args: CompilerPortMessage) => void) => {
     const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
     ipcRenderer.postMessage('compiler:build-st-program', xmlPath, [mainProcessPort])
-    rendererProcessPort.onmessage = (event) => callback(event.data)
-    rendererProcessPort.addEventListener('close', () => console.log('Port closed'))
+    rendererProcessPort.onmessage = (event) => callback(event.data as CompilerPortMessage)
+    rendererProcessPort.addEventListener('close', () => {})
   },
   createBuildDirectory: async (pathToUserProject: string): Promise<{ success: boolean; message: string }> =>
-    ipcRenderer.invoke('compiler:create-build-directory', pathToUserProject),
+    ipcRenderer.invoke('compiler:create-build-directory', pathToUserProject) as Promise<{
+      success: boolean
+      message: string
+    }>,
   createXmlFileToBuild: async (
     pathToUserProject: string,
-    dataToCreateXml: ProjectState['data'],
+    dataToCreateXml: PLCProjectData,
   ): Promise<{ success: boolean; message: string }> =>
-    ipcRenderer.invoke('compiler:build-xml-file', pathToUserProject, dataToCreateXml),
+    ipcRenderer.invoke('compiler:build-xml-file', pathToUserProject, dataToCreateXml) as Promise<{
+      success: boolean
+      message: string
+    }>,
   exportProjectRequest: (callback: IpcRendererCallbacks) =>
     ipcRenderer.on('compiler:export-project-request', (_event, value) => callback(_event, value)),
-  generateCFilesRequest: (pathToStProgram: string, callback: (args: any) => void) => {
+  generateCFilesRequest: (pathToStProgram: string, callback: (args: CompilerPortMessage) => void) => {
     const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
     ipcRenderer.postMessage('compiler:generate-c-files', pathToStProgram, [mainProcessPort])
-    rendererProcessPort.onmessage = (event) => callback(event.data)
-    rendererProcessPort.addEventListener('close', () => console.log('Port closed'))
+    rendererProcessPort.onmessage = (event) => callback(event.data as CompilerPortMessage)
+    rendererProcessPort.addEventListener('close', () => {})
   },
   removeExportProjectListener: () => ipcRenderer.removeAllListeners('compiler:export-project-request'),
-  setupCompilerEnvironment: (callback: (args: any) => void) => {
+  setupCompilerEnvironment: (callback: (args: CompilerPortMessage) => void) => {
     const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
     ipcRenderer.postMessage('compiler:setup-environment', '', [mainProcessPort])
-    rendererProcessPort.onmessage = (event) => callback(event.data)
-    rendererProcessPort.addEventListener('close', () => console.log('Port closed'))
+    rendererProcessPort.onmessage = (event) => callback(event.data as CompilerPortMessage)
+    rendererProcessPort.addEventListener('close', () => {})
   },
 
   // ===================== HARDWARE METHODS =====================
diff --git a/src2/middleware/adapters/editor/__tests__/compiler-adapter.test.ts b/src/middleware/adapters/editor/__tests__/compiler-adapter.test.ts
similarity index 97%
rename from src2/middleware/adapters/editor/__tests__/compiler-adapter.test.ts
rename to src/middleware/adapters/editor/__tests__/compiler-adapter.test.ts
index 951444168..1c5f6daf2 100644
--- a/src2/middleware/adapters/editor/__tests__/compiler-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/compiler-adapter.test.ts
@@ -1,11 +1,6 @@
-import {
-  createEditorCompilerAdapter,
-  portPouToIpcPou,
-  toIpcProjectData,
-  inferStage,
-} from '../compiler-adapter'
 import type { CompilerPort } from '../../../shared/ports/compiler-port'
 import type { CompileProgressEvent, PLCProjectData } from '../../../shared/ports/types'
+import { createEditorCompilerAdapter, inferStage, portPouToIpcPou, toIpcProjectData } from '../compiler-adapter'
 
 const mockProjectData: PLCProjectData = {
   dataTypes: [],
@@ -40,7 +35,7 @@ const mockProjectData: PLCProjectData = {
   configurations: {
     resource: {
       tasks: [{ name: 'MainTask', triggering: 'Cyclic', interval: 'T#20ms', priority: 0 }],
-      instances: [{ name: 'main0', taskName: 'MainTask', pouName: 'main' }],
+      instances: [{ name: 'main0', task: 'MainTask', program: 'main' }],
       globalVariables: [],
     },
   },
@@ -73,9 +68,11 @@ beforeEach(() => {
     runCompileProgram: jest.fn().mockImplementation((_args: unknown[], cb: (data: Record<string, unknown>) => void) => {
       compileCallback = cb
     }),
-    runDebugCompilation: jest.fn().mockImplementation((_args: unknown[], cb: (data: Record<string, unknown>) => void) => {
-      debugCallback = cb
-    }),
+    runDebugCompilation: jest
+      .fn()
+      .mockImplementation((_args: unknown[], cb: (data: Record<string, unknown>) => void) => {
+        debugCallback = cb
+      }),
     exportProjectXml: jest.fn().mockResolvedValue({ success: true, message: 'Exported successfully' }),
   } as unknown as typeof window.bridge
 })
diff --git a/src2/middleware/adapters/editor/__tests__/debugger-adapter.test.ts b/src/middleware/adapters/editor/__tests__/debugger-adapter.test.ts
similarity index 80%
rename from src2/middleware/adapters/editor/__tests__/debugger-adapter.test.ts
rename to src/middleware/adapters/editor/__tests__/debugger-adapter.test.ts
index da83a6d84..2faf97a84 100644
--- a/src2/middleware/adapters/editor/__tests__/debugger-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/debugger-adapter.test.ts
@@ -1,19 +1,17 @@
-import type { EditorDebugConnectionConfig } from '../debugger-adapter'
-import { createEditorDebuggerAdapter } from '../debugger-adapter'
 import type { DebuggerPort } from '../../../shared/ports/debugger-port'
+import type { DebugConnectionConfig } from '../../../shared/ports/types'
+import { createEditorDebuggerAdapter } from '../debugger-adapter'
 
 let adapter: DebuggerPort
-let mockConnectionConfig: EditorDebugConnectionConfig | null
+const tcpConfig: DebugConnectionConfig = {
+  connectionType: 'tcp',
+  connectionParams: {
+    ipAddress: '192.168.1.100',
+    port: '502',
+  },
+}
 
 beforeEach(() => {
-  mockConnectionConfig = {
-    connectionType: 'tcp',
-    connectionParams: {
-      ipAddress: '192.168.1.100',
-      port: '502',
-    },
-  }
-
   window.bridge = {
     debuggerConnect: jest.fn().mockResolvedValue({ success: true }),
     debuggerDisconnect: jest.fn().mockResolvedValue({ success: true }),
@@ -39,7 +37,7 @@ beforeEach(() => {
     }),
   } as unknown as typeof window.bridge
 
-  adapter = createEditorDebuggerAdapter(() => mockConnectionConfig)
+  adapter = createEditorDebuggerAdapter()
 })
 
 // ---------------------------------------------------------------------------
@@ -48,7 +46,7 @@ beforeEach(() => {
 
 describe('connect', () => {
   it('delegates to bridge with connection type and params', async () => {
-    const result = await adapter.connect()
+    const result = await adapter.connect(tcpConfig)
 
     expect(window.bridge.debuggerConnect).toHaveBeenCalledWith('tcp', {
       ipAddress: '192.168.1.100',
@@ -59,7 +57,7 @@ describe('connect', () => {
 
   it('sets connected state on success', async () => {
     expect(adapter.isConnected()).toBe(false)
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     expect(adapter.isConnected()).toBe(true)
   })
 
@@ -68,45 +66,32 @@ describe('connect', () => {
       success: false,
       error: 'Connection refused',
     })
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     expect(adapter.isConnected()).toBe(false)
   })
 
-  it('returns error when no connection config', async () => {
-    mockConnectionConfig = null
-    const result = await adapter.connect()
-
-    expect(result).toEqual({ success: false, error: 'No debug connection configured' })
-    expect(window.bridge.debuggerConnect).not.toHaveBeenCalled()
-  })
-
   it('catches bridge errors', async () => {
     ;(window.bridge.debuggerConnect as jest.Mock).mockRejectedValue(new Error('IPC failed'))
-    const result = await adapter.connect()
+    const result = await adapter.connect(tcpConfig)
 
     expect(result).toEqual({ success: false, error: 'IPC failed' })
   })
 
   it('supports simulator connection type', async () => {
-    mockConnectionConfig = {
-      connectionType: 'simulator',
-      connectionParams: {},
-    }
-    await adapter.connect()
+    await adapter.connect({ connectionType: 'simulator', connectionParams: {} })
 
     expect(window.bridge.debuggerConnect).toHaveBeenCalledWith('simulator', {})
   })
 
   it('supports websocket connection type with JWT', async () => {
-    mockConnectionConfig = {
+    await adapter.connect({
       connectionType: 'websocket',
       connectionParams: {
         ipAddress: '10.0.0.1',
         port: '8443',
         jwtToken: 'my-jwt',
       },
-    }
-    await adapter.connect()
+    })
 
     expect(window.bridge.debuggerConnect).toHaveBeenCalledWith('websocket', {
       ipAddress: '10.0.0.1',
@@ -116,15 +101,14 @@ describe('connect', () => {
   })
 
   it('supports RTU connection type with serial params', async () => {
-    mockConnectionConfig = {
+    await adapter.connect({
       connectionType: 'rtu',
       connectionParams: {
         port: '/dev/ttyUSB0',
         baudRate: 115200,
         slaveId: 1,
       },
-    }
-    await adapter.connect()
+    })
 
     expect(window.bridge.debuggerConnect).toHaveBeenCalledWith('rtu', {
       port: '/dev/ttyUSB0',
@@ -140,7 +124,7 @@ describe('connect', () => {
 
 describe('disconnect', () => {
   it('delegates to bridge', async () => {
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     const result = await adapter.disconnect()
 
     expect(window.bridge.debuggerDisconnect).toHaveBeenCalled()
@@ -148,7 +132,7 @@ describe('disconnect', () => {
   })
 
   it('clears connected state', async () => {
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     expect(adapter.isConnected()).toBe(true)
 
     await adapter.disconnect()
@@ -161,7 +145,7 @@ describe('disconnect', () => {
     adapter.onDisconnected(cb1)
     adapter.onDisconnected(cb2)
 
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     await adapter.disconnect()
 
     expect(cb1).toHaveBeenCalledTimes(1)
@@ -173,7 +157,7 @@ describe('disconnect', () => {
     const cb = jest.fn()
     adapter.onDisconnected(cb)
 
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     const result = await adapter.disconnect()
 
     expect(adapter.isConnected()).toBe(false)
@@ -254,7 +238,7 @@ describe('setVariable', () => {
 
 describe('verifyMd5', () => {
   it('delegates to bridge with connection config and expected MD5', async () => {
-    const result = await adapter.verifyMd5('abc123def456abc123def456abc123de')
+    const result = await adapter.verifyMd5('abc123def456abc123def456abc123de', tcpConfig)
 
     expect(window.bridge.debuggerVerifyMd5).toHaveBeenCalledWith(
       'tcp',
@@ -268,33 +252,22 @@ describe('verifyMd5', () => {
     })
   })
 
-  it('returns error when no connection config', async () => {
-    mockConnectionConfig = null
-    const result = await adapter.verifyMd5('abc123')
-
-    expect(result).toEqual({ success: false, error: 'No debug connection configured' })
-    expect(window.bridge.debuggerVerifyMd5).not.toHaveBeenCalled()
-  })
-
-  it('reads config dynamically per call', async () => {
-    await adapter.verifyMd5('md5-1')
+  it('uses different configs per call', async () => {
+    await adapter.verifyMd5('md5-1', tcpConfig)
     expect(window.bridge.debuggerVerifyMd5).toHaveBeenCalledWith(
       'tcp',
       { ipAddress: '192.168.1.100', port: '502' },
       'md5-1',
     )
 
-    mockConnectionConfig = {
-      connectionType: 'simulator',
-      connectionParams: {},
-    }
-    await adapter.verifyMd5('md5-2')
+    const simConfig: DebugConnectionConfig = { connectionType: 'simulator', connectionParams: {} }
+    await adapter.verifyMd5('md5-2', simConfig)
     expect(window.bridge.debuggerVerifyMd5).toHaveBeenCalledWith('simulator', {}, 'md5-2')
   })
 
   it('catches bridge errors', async () => {
     ;(window.bridge.debuggerVerifyMd5 as jest.Mock).mockRejectedValue(new Error('MD5 check failed'))
-    const result = await adapter.verifyMd5('abc123')
+    const result = await adapter.verifyMd5('abc123', tcpConfig)
 
     expect(result).toEqual({ success: false, error: 'MD5 check failed' })
   })
@@ -355,7 +328,7 @@ describe('onDisconnected', () => {
     const cb = jest.fn()
     const unsub = adapter.onDisconnected(cb)
 
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     unsub()
     await adapter.disconnect()
 
@@ -371,7 +344,7 @@ describe('onDisconnected', () => {
     adapter.onDisconnected(cb3)
 
     unsub2()
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     await adapter.disconnect()
 
     expect(cb1).toHaveBeenCalledTimes(1)
@@ -390,38 +363,13 @@ describe('isConnected', () => {
   })
 
   it('returns true after successful connect', async () => {
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     expect(adapter.isConnected()).toBe(true)
   })
 
   it('returns false after disconnect', async () => {
-    await adapter.connect()
+    await adapter.connect(tcpConfig)
     await adapter.disconnect()
     expect(adapter.isConnected()).toBe(false)
   })
 })
-
-// ---------------------------------------------------------------------------
-// Connection config getter reactivity
-// ---------------------------------------------------------------------------
-
-describe('connection config getter', () => {
-  it('reads config dynamically on each call', async () => {
-    await adapter.connect()
-    expect(window.bridge.debuggerConnect).toHaveBeenCalledWith('tcp', {
-      ipAddress: '192.168.1.100',
-      port: '502',
-    })
-
-    mockConnectionConfig = {
-      connectionType: 'rtu',
-      connectionParams: { port: '/dev/ttyS0', baudRate: 9600, slaveId: 2 },
-    }
-    await adapter.connect()
-    expect(window.bridge.debuggerConnect).toHaveBeenCalledWith('rtu', {
-      port: '/dev/ttyS0',
-      baudRate: 9600,
-      slaveId: 2,
-    })
-  })
-})
diff --git a/src2/middleware/adapters/editor/__tests__/device-adapter.test.ts b/src/middleware/adapters/editor/__tests__/device-adapter.test.ts
similarity index 100%
rename from src2/middleware/adapters/editor/__tests__/device-adapter.test.ts
rename to src/middleware/adapters/editor/__tests__/device-adapter.test.ts
index 2c525aa3d..0bab22941 100644
--- a/src2/middleware/adapters/editor/__tests__/device-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/device-adapter.test.ts
@@ -1,6 +1,6 @@
-import { createEditorDeviceAdapter } from '../device-adapter'
 import type { DevicePort } from '../../../shared/ports/device-port'
 import type { BoardInfo, CommunicationPort } from '../../../shared/ports/types'
+import { createEditorDeviceAdapter } from '../device-adapter'
 
 const mockBoards = new Map<string, BoardInfo>([
   [
diff --git a/src2/middleware/adapters/editor/__tests__/project-adapter.test.ts b/src/middleware/adapters/editor/__tests__/project-adapter.test.ts
similarity index 97%
rename from src2/middleware/adapters/editor/__tests__/project-adapter.test.ts
rename to src/middleware/adapters/editor/__tests__/project-adapter.test.ts
index cb0c7f32b..53232fd29 100644
--- a/src2/middleware/adapters/editor/__tests__/project-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/project-adapter.test.ts
@@ -1,5 +1,5 @@
-import { createEditorProjectAdapter } from '../project-adapter'
 import type { ProjectPort } from '../../../shared/ports/project-port'
+import { createEditorProjectAdapter } from '../project-adapter'
 
 const mockIpcProjectResponse = {
   success: true,
@@ -21,7 +21,9 @@ const mockIpcProjectResponse = {
           type: 'program',
           data: {
             name: 'main',
-            variables: [{ name: 'x', type: { definition: 'base-type', value: 'BOOL' }, location: '', documentation: '' }],
+            variables: [
+              { name: 'x', type: { definition: 'base-type', value: 'BOOL' }, location: '', documentation: '' },
+            ],
             body: { language: 'st', value: 'x := TRUE;' },
             documentation: 'Main program',
           },
@@ -90,7 +92,7 @@ beforeEach(() => {
     fileWatchStart: jest.fn().mockResolvedValue({ success: true }),
     fileWatchStop: jest.fn().mockResolvedValue({ success: true }),
     fileWatchStopAll: jest.fn().mockResolvedValue({ success: true }),
-    onFileExternalChange: jest.fn().mockImplementation((cb: unknown) => {
+    onFileExternalChange: jest.fn().mockImplementation((_cb: unknown) => {
       return () => {}
     }),
   } as unknown as typeof window.bridge
@@ -322,7 +324,11 @@ describe('createEditorProjectAdapter', () => {
     it('delegates to window.bridge.renamePouFile', async () => {
       const result = await adapter.renamePou({ filePath: '/path/to/old.st', newFileName: 'new_name' })
 
-      expect(window.bridge.renamePouFile).toHaveBeenCalledWith({ filePath: '/path/to/old.st', newFileName: 'new_name', fileContent: undefined })
+      expect(window.bridge.renamePouFile).toHaveBeenCalledWith({
+        filePath: '/path/to/old.st',
+        newFileName: 'new_name',
+        fileContent: undefined,
+      })
       expect(result).toEqual({ success: true, data: mockPouResponse.data })
     })
   })
diff --git a/src2/middleware/adapters/editor/__tests__/runtime-adapter.test.ts b/src/middleware/adapters/editor/__tests__/runtime-adapter.test.ts
similarity index 100%
rename from src2/middleware/adapters/editor/__tests__/runtime-adapter.test.ts
rename to src/middleware/adapters/editor/__tests__/runtime-adapter.test.ts
index 0a08794e4..a77399bdf 100644
--- a/src2/middleware/adapters/editor/__tests__/runtime-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/runtime-adapter.test.ts
@@ -1,5 +1,5 @@
-import { createEditorRuntimeAdapter } from '../runtime-adapter'
 import type { RuntimePort } from '../../../shared/ports/runtime-port'
+import { createEditorRuntimeAdapter } from '../runtime-adapter'
 
 let adapter: RuntimePort
 let mockIpAddress: string
diff --git a/src2/middleware/adapters/editor/__tests__/simulator-adapter.test.ts b/src/middleware/adapters/editor/__tests__/simulator-adapter.test.ts
similarity index 100%
rename from src2/middleware/adapters/editor/__tests__/simulator-adapter.test.ts
rename to src/middleware/adapters/editor/__tests__/simulator-adapter.test.ts
index d0af53ca2..2e0e5c207 100644
--- a/src2/middleware/adapters/editor/__tests__/simulator-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/simulator-adapter.test.ts
@@ -1,5 +1,5 @@
-import { createEditorSimulatorAdapter } from '../simulator-adapter'
 import type { SimulatorPort } from '../../../shared/ports/simulator-port'
+import { createEditorSimulatorAdapter } from '../simulator-adapter'
 
 let adapter: SimulatorPort
 let simulatorStoppedCallback: (() => void) | null
diff --git a/src2/middleware/adapters/editor/accelerator-adapter.ts b/src/middleware/adapters/editor/accelerator-adapter.ts
similarity index 91%
rename from src2/middleware/adapters/editor/accelerator-adapter.ts
rename to src/middleware/adapters/editor/accelerator-adapter.ts
index 76420f347..02afe1ad0 100644
--- a/src2/middleware/adapters/editor/accelerator-adapter.ts
+++ b/src/middleware/adapters/editor/accelerator-adapter.ts
@@ -51,10 +51,10 @@ export function createEditorAcceleratorAdapter(): AcceleratorPort {
       }
     },
 
-    onOpenRecent(callback: () => void): Unsubscribe {
+    onOpenRecent(callback: (projectData?: unknown) => void): Unsubscribe {
       let active = true
-      window.bridge.openRecentAccelerator(() => {
-        if (active) callback()
+      window.bridge.openRecentAccelerator((_event: unknown, response: unknown) => {
+        if (active) callback(response)
       })
       return () => {
         active = false
@@ -170,5 +170,15 @@ export function createEditorAcceleratorAdapter(): AcceleratorPort {
         active = false
       }
     },
+
+    onQuitApp(callback: () => void): Unsubscribe {
+      let active = true
+      window.bridge.quitAppRequest(() => {
+        if (active) callback()
+      })
+      return () => {
+        active = false
+      }
+    },
   }
 }
diff --git a/src2/middleware/adapters/editor/compiler-adapter.ts b/src/middleware/adapters/editor/compiler-adapter.ts
similarity index 62%
rename from src2/middleware/adapters/editor/compiler-adapter.ts
rename to src/middleware/adapters/editor/compiler-adapter.ts
index 2eb4cbbee..9132f2a26 100644
--- a/src2/middleware/adapters/editor/compiler-adapter.ts
+++ b/src/middleware/adapters/editor/compiler-adapter.ts
@@ -11,6 +11,7 @@
  *   - Port uses `configurations` (plural), IPC uses `configuration` (singular)
  */
 
+import { preprocessPous } from '../../../frontend/utils/PLC/preprocess-pous'
 import type {
   CompileProgramArgs,
   CompilerPort,
@@ -40,6 +41,7 @@ interface IpcProjectData {
     }
   }>
   configuration: PLCProjectData['configurations']
+  originalCppPous?: Array<{ name: string; code: string; variables: unknown[] }>
 }
 
 /** Converts a flat port POU to the editor's discriminated-union IPC format. */
@@ -57,14 +59,31 @@ function portPouToIpcPou(pou: PLCPou) {
 }
 
 /** Converts PLCProjectData (port format) to the editor's IPC format. */
-function toIpcProjectData(data: PLCProjectData): IpcProjectData {
+function toIpcProjectData(data: PLCProjectData & { originalCppPous?: unknown[] }): IpcProjectData {
   return {
     dataTypes: data.dataTypes,
     pous: data.pous.map(portPouToIpcPou),
     configuration: data.configurations,
+    ...(data.originalCppPous ? { originalCppPous: data.originalCppPous as IpcProjectData['originalCppPous'] } : {}),
   }
 }
 
+/** Decode a Buffer/Uint8Array message to string lines. */
+function decodeMessage(raw: unknown): string {
+  if (typeof raw === 'string') return raw
+  if (raw instanceof Uint8Array || raw instanceof ArrayBuffer) {
+    return new TextDecoder().decode(raw)
+  }
+  if (raw && typeof raw === 'object' && 'type' in raw) {
+    const obj = raw as Record<string, unknown>
+    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+      // Electron serializes Node Buffers as { type: 'Buffer', data: number[] }
+      return new TextDecoder().decode(new Uint8Array(obj.data as number[]))
+    }
+  }
+  return String(raw)
+}
+
 /** Best-effort stage inference from compiler log messages. */
 function inferStage(message: string): CompileProgressEvent['stage'] {
   const lower = message.toLowerCase()
@@ -85,8 +104,25 @@ export function createEditorCompilerAdapter(): CompilerPort {
       const boards = await window.bridge.getAvailableBoards()
       const boardInfo = boards.get(args.boardTarget)
       const boardCore = boardInfo?.core ?? null
+      const isSimulator = args.isSimulator ?? boardInfo?.compiler === 'simulator'
+
+      // Preprocess POUs (comment wrapping, Python->ST stubs, C++ validation/ST generation)
+      const { projectData: processedData, validationFailed } = preprocessPous(
+        args.projectData,
+        isSimulator,
+        (level, message) => {
+          onProgress({ stage: 'st', message, level })
+        },
+      )
+
+      if (validationFailed) {
+        return {
+          success: false,
+          error: 'POU validation failed. Check C/C++ code for missing setup()/loop() functions.',
+        }
+      }
 
-      const ipcData = toIpcProjectData(args.projectData)
+      const ipcData = toIpcProjectData(processedData)
 
       return new Promise<CompileResult>((resolve) => {
         let hasError = false
@@ -100,10 +136,17 @@ export function createEditorCompilerAdapter(): CompilerPort {
             boardCore,
             args.compileOnly ?? false,
             ipcData as never,
-            null, // runtimeIpAddress — runtime upload handled by RuntimePort
-            null, // jwtToken
+            args.runtimeIpAddress ?? null,
+            args.runtimeJwtToken ?? null,
           ],
           (data: Record<string, unknown>) => {
+            // Extract simulator firmware path BEFORE the closePort early return,
+            // because the backend sends both fields in the same message.
+            if (data.simulatorFirmwarePath) {
+              hexPath = data.simulatorFirmwarePath as string
+              onProgress({ stage: 'done', message: 'Simulator firmware ready', firmwarePath: hexPath })
+            }
+
             if (data.closePort) {
               onProgress({ stage: 'done', message: 'Compilation complete' })
               resolve(
@@ -114,19 +157,24 @@ export function createEditorCompilerAdapter(): CompilerPort {
               return
             }
 
-            if (data.simulatorFirmwarePath) {
-              hexPath = data.simulatorFirmwarePath as string
+            // Forward plcStatus for runtime status updates
+            if (data.plcStatus) {
+              onProgress({ stage: 'arduino', message: '', plcStatus: data.plcStatus as string })
             }
 
             if (data.message) {
-              const message = typeof data.message === 'string' ? data.message : String(data.message)
+              const message = decodeMessage(data.message)
 
               if (data.logLevel === 'error') {
                 hasError = true
                 lastError = message
-                onProgress({ stage: 'error', message })
+                onProgress({ stage: 'error', message, level: 'error' })
               } else {
-                onProgress({ stage: inferStage(message), message })
+                onProgress({
+                  stage: inferStage(message),
+                  message,
+                  level: (data.logLevel as string) ?? 'info',
+                })
               }
             }
           },
@@ -138,7 +186,20 @@ export function createEditorCompilerAdapter(): CompilerPort {
       args: DebugCompileArgs,
       onProgress: (event: CompileProgressEvent) => void,
     ): Promise<DebugCompileResult> {
-      const ipcData = toIpcProjectData(args.projectData)
+      // Preprocess for debug compilation too
+      const { projectData: processedData, validationFailed } = preprocessPous(
+        args.projectData,
+        false,
+        (level, message) => {
+          onProgress({ stage: 'st', message, level })
+        },
+      )
+
+      if (validationFailed) {
+        return { success: false, error: 'POU validation failed.' }
+      }
+
+      const ipcData = toIpcProjectData(processedData)
 
       return new Promise<DebugCompileResult>((resolve) => {
         let hasError = false
@@ -154,14 +215,14 @@ export function createEditorCompilerAdapter(): CompilerPort {
             }
 
             if (data.message) {
-              const message = typeof data.message === 'string' ? data.message : String(data.message)
+              const message = decodeMessage(data.message)
 
               if (data.logLevel === 'error') {
                 hasError = true
                 lastError = message
-                onProgress({ stage: 'error', message })
+                onProgress({ stage: 'error', message, level: 'error' })
               } else {
-                onProgress({ stage: inferStage(message), message })
+                onProgress({ stage: inferStage(message), message, level: (data.logLevel as string) ?? 'info' })
               }
             }
           },
@@ -181,4 +242,4 @@ export function createEditorCompilerAdapter(): CompilerPort {
   }
 }
 
-export { portPouToIpcPou, toIpcProjectData, inferStage }
+export { decodeMessage, inferStage, portPouToIpcPou, toIpcProjectData }
diff --git a/src2/middleware/adapters/editor/debugger-adapter.ts b/src/middleware/adapters/editor/debugger-adapter.ts
similarity index 51%
rename from src2/middleware/adapters/editor/debugger-adapter.ts
rename to src/middleware/adapters/editor/debugger-adapter.ts
index facf9416f..169a0f16f 100644
--- a/src2/middleware/adapters/editor/debugger-adapter.ts
+++ b/src/middleware/adapters/editor/debugger-adapter.ts
@@ -5,49 +5,33 @@
  * methods. The main process manages Modbus clients (TCP, RTU, WebSocket) and the
  * simulator virtual serial port.
  *
- * Connection context:
- *   - Connection config (type + params): provided via getConnectionConfig() callback
- *     injected at creation. Set by the store/UI based on the current device config.
- *   - The main process persists the Modbus/WebSocket client between calls and handles
- *     auto-reconnection using stored connection parameters.
+ * Connection config is passed per-call via the DebugConnectionConfig parameter.
+ * The main process persists the Modbus/WebSocket client between calls and handles
+ * auto-reconnection using stored connection parameters.
  */
 
+import { getErrorMessage } from '../../../frontend/utils/get-error-message'
 import type { DebuggerPort } from '../../shared/ports/debugger-port'
-import type { DebugSetResult, DebugVariableResult, Md5VerifyResult, Unsubscribe } from '../../shared/ports/types'
+import type {
+  DebugConnectionConfig,
+  DebugSetResult,
+  DebugVariableResult,
+  Md5VerifyResult,
+  Unsubscribe,
+} from '../../shared/ports/types'
 
-export type EditorDebugConnectionType = 'tcp' | 'rtu' | 'websocket' | 'simulator'
-
-export interface EditorDebugConnectionConfig {
-  connectionType: EditorDebugConnectionType
-  connectionParams: {
-    ipAddress?: string
-    port?: string
-    baudRate?: number
-    slaveId?: number
-    jwtToken?: string
-  }
-}
-
-export function createEditorDebuggerAdapter(
-  getConnectionConfig: () => EditorDebugConnectionConfig | null,
-): DebuggerPort {
+export function createEditorDebuggerAdapter(): DebuggerPort {
   let connected = false
   const disconnectCallbacks: Array<() => void> = []
 
   return {
-    async connect(): Promise<{ success: boolean; error?: string }> {
+    async connect(config: DebugConnectionConfig): Promise<{ success: boolean; error?: string }> {
       try {
-        const config = getConnectionConfig()
-        if (!config) return { success: false, error: 'No debug connection configured' }
-
-        const result = await window.bridge.debuggerConnect(
-          config.connectionType,
-          config.connectionParams,
-        )
+        const result = await window.bridge.debuggerConnect(config.connectionType, config.connectionParams)
         if (result.success) connected = true
         return result
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -68,7 +52,7 @@ export function createEditorDebuggerAdapter(
       try {
         return await window.bridge.debuggerGetVariablesList(indexes)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -76,22 +60,15 @@ export function createEditorDebuggerAdapter(
       try {
         return await window.bridge.debuggerSetVariable(index, force, valueBuffer)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
-    async verifyMd5(expectedMd5: string): Promise<Md5VerifyResult> {
+    async verifyMd5(expectedMd5: string, config: DebugConnectionConfig): Promise<Md5VerifyResult> {
       try {
-        const config = getConnectionConfig()
-        if (!config) return { success: false, error: 'No debug connection configured' }
-
-        return await window.bridge.debuggerVerifyMd5(
-          config.connectionType,
-          config.connectionParams,
-          expectedMd5,
-        )
+        return await window.bridge.debuggerVerifyMd5(config.connectionType, config.connectionParams, expectedMd5)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -102,7 +79,7 @@ export function createEditorDebuggerAdapter(
       try {
         return await window.bridge.debuggerReadProgramStMd5(projectPath, boardTarget)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -113,7 +90,7 @@ export function createEditorDebuggerAdapter(
       try {
         return await window.bridge.readDebugFile(projectPath, boardTarget)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
diff --git a/src2/middleware/adapters/editor/device-adapter.ts b/src/middleware/adapters/editor/device-adapter.ts
similarity index 100%
rename from src2/middleware/adapters/editor/device-adapter.ts
rename to src/middleware/adapters/editor/device-adapter.ts
diff --git a/src/middleware/adapters/editor/orchestrator-adapter.ts b/src/middleware/adapters/editor/orchestrator-adapter.ts
new file mode 100644
index 000000000..bc5f9bd08
--- /dev/null
+++ b/src/middleware/adapters/editor/orchestrator-adapter.ts
@@ -0,0 +1,17 @@
+/**
+ * Editor OrchestratorPort adapter — no-op.
+ *
+ * The editor connects to devices directly (via IP address), not through
+ * orchestrators. This adapter satisfies the PlatformPorts interface but
+ * is never called because the UI is gated by hasOrchestratorDevices=false.
+ */
+
+import type { OrchestratorPort } from '../../shared/ports/orchestrator-port'
+
+export function createEditorOrchestratorAdapter(): OrchestratorPort {
+  return {
+    async listOrchestrators() {
+      return []
+    },
+  }
+}
diff --git a/src2/middleware/adapters/editor/project-adapter.ts b/src/middleware/adapters/editor/project-adapter.ts
similarity index 81%
rename from src2/middleware/adapters/editor/project-adapter.ts
rename to src/middleware/adapters/editor/project-adapter.ts
index 07144d98c..7191e86a5 100644
--- a/src2/middleware/adapters/editor/project-adapter.ts
+++ b/src/middleware/adapters/editor/project-adapter.ts
@@ -24,6 +24,7 @@ import type {
   PLCDataType,
   PLCInstance,
   PLCPou,
+  PLCProjectData,
   PLCTask,
   PLCVariable,
   RecentProject,
@@ -35,6 +36,7 @@ interface IpcPou {
   type: string
   data: {
     name: string
+    language?: string
     variables: unknown[]
     returnType?: string
     body: { language: string; value: unknown }
@@ -56,6 +58,9 @@ interface IpcProjectResponse {
           dataTypes: PLCDataType[]
           pous: IpcPou[]
           configuration: { resource: { tasks: PLCTask[]; instances: PLCInstance[]; globalVariables: PLCVariable[] } }
+          servers?: unknown[]
+          remoteDevices?: unknown[]
+          debugVariables?: { global?: string[]; pous?: Record<string, string[]> }
         }
       }
       pous: IpcPou[]
@@ -68,7 +73,7 @@ interface IpcProjectResponse {
 /** Editor IPC save response shape. */
 interface IpcSaveResponse {
   success: boolean
-  reason: { title: string; description: string }
+  error?: { title: string; description: string }
 }
 
 /** Editor IPC POU service response shape. */
@@ -85,13 +90,10 @@ function mapIpcPouToPortPou(ipcPou: IpcPou): PLCPou {
   return {
     name: ipcPou.data.name,
     pouType: ipcPou.type as PLCPou['pouType'],
-    interface:
-      ipcPou.data.variables.length > 0 || ipcPou.data.returnType
-        ? {
-            returnType: ipcPou.data.returnType,
-            variables: ipcPou.data.variables as PLCVariable[],
-          }
-        : undefined,
+    interface: {
+      returnType: ipcPou.data.returnType,
+      variables: ipcPou.data.variables as PLCVariable[],
+    },
     body: ipcPou.data.body as PLCPou['body'],
     documentation: ipcPou.data.documentation || undefined,
   }
@@ -105,6 +107,7 @@ function mapPortPouToIpcPou(portPou: PLCPou): IpcPou {
     type: portPou.pouType,
     data: {
       name: portPou.name,
+      language: portPou.body.language,
       variables: (portPou.interface?.variables ?? []) as unknown[],
       ...(portPou.interface?.returnType ? { returnType: portPou.interface.returnType } : {}),
       body: portPou.body as { language: string; value: unknown },
@@ -128,7 +131,9 @@ function mapIpcResponse(
   }
 
   const { content, meta } = response.data
+
   const projectMeta = content.project.meta ?? fallbackMeta
+  const configuration = content.project.data.configuration
 
   return {
     success: true,
@@ -141,7 +146,10 @@ function mapIpcResponse(
       projectData: {
         dataTypes: content.project.data.dataTypes,
         pous: content.pous.map(mapIpcPouToPortPou),
-        configurations: content.project.data.configuration,
+        configurations: configuration,
+        servers: content.project.data.servers as PLCProjectData['servers'],
+        remoteDevices: content.project.data.remoteDevices as PLCProjectData['remoteDevices'],
+        debugVariables: content.project.data.debugVariables,
       },
       deviceConfiguration: content.deviceConfiguration,
       devicePinMapping: content.devicePinMapping,
@@ -156,8 +164,8 @@ export function createEditorProjectAdapter(): ProjectPort {
         name: params.name,
         type: params.type,
         path: params.path ?? '',
-        language: 'il',
-        time: new Date().toISOString(),
+        language: (params.language ?? 'il') as 'il' | 'st' | 'ld' | 'sfc' | 'fbd',
+        time: params.time ?? new Date().toISOString(),
       })) as unknown as IpcProjectResponse
 
       return mapIpcResponse(response, { name: params.name, type: params.type })
@@ -178,25 +186,38 @@ export function createEditorProjectAdapter(): ProjectPort {
       const projectName = pathParts[pathParts.length - 1] || 'untitled'
       const editorPous = params.projectData.pous.map(mapPortPouToIpcPou)
 
+      // Inject variablesText from sanitized POUs into IPC format
+      for (let i = 0; i < params.projectData.pous.length; i++) {
+        const portPou = params.projectData.pous[i] as PLCPou & { variablesText?: string }
+        if (portPou.variablesText != null) {
+          editorPous[i].data.variablesText = portPou.variablesText
+        }
+      }
+
+      const projectDataPayload: Record<string, unknown> = {
+        meta: { name: projectName, type: 'plc-project' as const },
+        data: {
+          dataTypes: params.projectData.dataTypes,
+          pous: editorPous,
+          configuration: params.projectData.configurations,
+          debugVariables: params.projectData.debugVariables,
+        },
+      }
+
       const response = (await window.bridge.saveProject({
         projectPath: params.projectPath,
         content: {
-          projectData: {
-            meta: { name: projectName, type: 'plc-project' as const },
-            data: {
-              dataTypes: params.projectData.dataTypes,
-              pous: editorPous,
-              configuration: params.projectData.configurations,
-            },
-          },
+          projectData: projectDataPayload,
           pous: editorPous,
           deviceConfiguration: params.deviceConfiguration,
           devicePinMapping: params.devicePinMapping,
+          servers: params.projectData.servers ?? [],
+          remoteDevices: params.projectData.remoteDevices ?? [],
         },
       } as never)) as unknown as IpcSaveResponse
 
       if (!response.success) {
-        return { success: false, error: response.reason?.description ?? 'Save failed' }
+        return { success: false, error: response.error?.description ?? 'Save failed' }
       }
 
       return { success: true }
diff --git a/src2/middleware/adapters/editor/runtime-adapter.ts b/src/middleware/adapters/editor/runtime-adapter.ts
similarity index 81%
rename from src2/middleware/adapters/editor/runtime-adapter.ts
rename to src/middleware/adapters/editor/runtime-adapter.ts
index baadb7c27..08ac0ff3d 100644
--- a/src2/middleware/adapters/editor/runtime-adapter.ts
+++ b/src/middleware/adapters/editor/runtime-adapter.ts
@@ -12,6 +12,7 @@
  *     updated on token-refresh events, cleared on clearCredentials().
  */
 
+import { getErrorMessage } from '../../../frontend/utils/get-error-message'
 import type {
   CompilationStatusResult,
   LoginParams,
@@ -33,6 +34,10 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
   }
 
   return {
+    isReadyForDebug() {
+      return getIpAddress() !== '' && jwtToken !== ''
+    },
+
     async login(params: LoginParams): Promise<LoginResult> {
       try {
         const ip = requireIp()
@@ -42,7 +47,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         }
         return result
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -51,7 +56,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeCreateUser(ip, params.username, params.password)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -60,7 +65,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeGetUsersInfo(ip)
       } catch (err) {
-        return { hasUsers: false, error: err instanceof Error ? err.message : String(err) }
+        return { hasUsers: false, error: getErrorMessage(err) }
       }
     },
 
@@ -69,7 +74,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeGetStatus(ip, jwtToken, includeStats)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -78,7 +83,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeStartPlc(ip, jwtToken)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -87,7 +92,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeStopPlc(ip, jwtToken)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -96,7 +101,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeGetLogs(ip, jwtToken, minId)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -105,7 +110,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeGetSerialPorts(ip, jwtToken)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
@@ -114,7 +119,7 @@ export function createEditorRuntimeAdapter(getIpAddress: () => string): RuntimeP
         const ip = requireIp()
         return await window.bridge.runtimeGetCompilationStatus(ip, jwtToken)
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
diff --git a/src2/middleware/adapters/editor/simulator-adapter.ts b/src/middleware/adapters/editor/simulator-adapter.ts
similarity index 96%
rename from src2/middleware/adapters/editor/simulator-adapter.ts
rename to src/middleware/adapters/editor/simulator-adapter.ts
index 0f900c63d..72aebf308 100644
--- a/src2/middleware/adapters/editor/simulator-adapter.ts
+++ b/src/middleware/adapters/editor/simulator-adapter.ts
@@ -12,6 +12,7 @@
  * wires the VirtualSerialPort when debuggerConnect is called with 'simulator' type.
  */
 
+import { getErrorMessage } from '../../../frontend/utils/get-error-message'
 import type { SimulatorPort } from '../../shared/ports/simulator-port'
 import type { SimulatorDebugResult, Unsubscribe } from '../../shared/ports/types'
 
@@ -37,7 +38,7 @@ export function createEditorSimulatorAdapter(
         if (result.success) running = true
         return result
       } catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) }
+        return { success: false, error: getErrorMessage(err) }
       }
     },
 
diff --git a/src2/middleware/adapters/editor/system-adapter.ts b/src/middleware/adapters/editor/system-adapter.ts
similarity index 100%
rename from src2/middleware/adapters/editor/system-adapter.ts
rename to src/middleware/adapters/editor/system-adapter.ts
diff --git a/src2/middleware/adapters/editor/theme-adapter.ts b/src/middleware/adapters/editor/theme-adapter.ts
similarity index 100%
rename from src2/middleware/adapters/editor/theme-adapter.ts
rename to src/middleware/adapters/editor/theme-adapter.ts
diff --git a/src2/middleware/adapters/editor/window-adapter.ts b/src/middleware/adapters/editor/window-adapter.ts
similarity index 75%
rename from src2/middleware/adapters/editor/window-adapter.ts
rename to src/middleware/adapters/editor/window-adapter.ts
index 8ca1cefc4..c8fb72b86 100644
--- a/src2/middleware/adapters/editor/window-adapter.ts
+++ b/src/middleware/adapters/editor/window-adapter.ts
@@ -19,8 +19,8 @@
  *   - window-controls:toggle-maximized (on) — maximize state change
  */
 
-import type { WindowPort } from '../../shared/ports/window-port'
 import type { Unsubscribe } from '../../shared/ports/types'
+import type { WindowPort } from '../../shared/ports/window-port'
 
 export function createEditorWindowAdapter(): WindowPort {
   return {
@@ -53,15 +53,29 @@ export function createEditorWindowAdapter(): WindowPort {
     },
 
     onCloseRequested(callback: () => void): Unsubscribe {
-      const handler = () => callback()
+      let active = true
+      window.bridge.windowIsClosing(() => {
+        if (active) callback()
+      })
+      return () => {
+        active = false
+      }
+    },
 
-      window.bridge.windowIsClosing(handler)
-      window.bridge.darwinAppIsClosing(handler)
+    onDarwinAppQuitting(callback: () => void): Unsubscribe {
+      let active = true
+      window.bridge.darwinAppIsClosing(() => {
+        if (active) callback()
+      })
+      return () => {
+        active = false
+      }
+    },
 
+    enableAutoCloseHandshake(): Unsubscribe {
+      window.bridge.handleCloseOrHideWindowAccelerator()
       return () => {
-        // Electron IPC listeners are removed by channel name.
-        // The bridge does not expose a per-listener removeListener,
-        // so we guard with an active flag instead.
+        window.bridge.removeHandleCloseOrHideWindowAccelerator()
       }
     },
 
@@ -76,7 +90,7 @@ export function createEditorWindowAdapter(): WindowPort {
       window.bridge.isMaximizedWindow(handler)
 
       return () => {
-        // Same limitation as onCloseRequested — no per-listener unsubscribe.
+        // Electron IPC does not expose per-listener unsubscribe for this channel.
       }
     },
   }
diff --git a/src2/middleware/editor-platform.ts b/src/middleware/editor-platform.ts
similarity index 86%
rename from src2/middleware/editor-platform.ts
rename to src/middleware/editor-platform.ts
index cb28ef883..d9a41f6ee 100644
--- a/src2/middleware/editor-platform.ts
+++ b/src/middleware/editor-platform.ts
@@ -13,45 +13,41 @@
  *   </PlatformProvider>
  */
 
-import type { PlatformPorts } from './shared/providers/types'
-import { EDITOR_CAPABILITIES } from './shared/ports/platform-capabilities'
 import { createEditorAcceleratorAdapter } from './adapters/editor/accelerator-adapter'
 import { createEditorCompilerAdapter } from './adapters/editor/compiler-adapter'
-import type { EditorDebugConnectionConfig } from './adapters/editor/debugger-adapter'
 import { createEditorDebuggerAdapter } from './adapters/editor/debugger-adapter'
 import { createEditorDeviceAdapter } from './adapters/editor/device-adapter'
+import { createEditorOrchestratorAdapter } from './adapters/editor/orchestrator-adapter'
 import { createEditorProjectAdapter } from './adapters/editor/project-adapter'
 import { createEditorRuntimeAdapter } from './adapters/editor/runtime-adapter'
+import { createEditorSimulatorAdapter } from './adapters/editor/simulator-adapter'
 import { createEditorSystemAdapter } from './adapters/editor/system-adapter'
 import { createEditorThemeAdapter } from './adapters/editor/theme-adapter'
-import { createEditorSimulatorAdapter } from './adapters/editor/simulator-adapter'
 import { createEditorWindowAdapter } from './adapters/editor/window-adapter'
+import { EDITOR_CAPABILITIES } from './shared/ports/platform-capabilities'
+import type { PlatformPorts } from './shared/providers/types'
 
 /**
  * Runtime connection target — IP address of the OpenPLC runtime device.
  * Set by the store/UI when the user configures or connects to a device.
  */
 let _runtimeIpAddress = ''
-let _debugConnectionConfig: EditorDebugConnectionConfig | null = null
 
 export function setRuntimeIpAddress(ip: string): void {
   _runtimeIpAddress = ip
 }
 
-export function setDebugConnectionConfig(config: EditorDebugConnectionConfig | null): void {
-  _debugConnectionConfig = config
-}
-
 /**
  * Editor platform ports — all port interfaces wired to Electron IPC bridge.
  */
 export const editorPorts: PlatformPorts = {
   compiler: createEditorCompilerAdapter(),
   runtime: createEditorRuntimeAdapter(() => _runtimeIpAddress),
-  debugger: createEditorDebuggerAdapter(() => _debugConnectionConfig),
+  debugger: createEditorDebuggerAdapter(),
   simulator: createEditorSimulatorAdapter(),
   project: createEditorProjectAdapter(),
   device: createEditorDeviceAdapter(),
+  orchestrator: createEditorOrchestratorAdapter(),
   system: createEditorSystemAdapter(),
   window: createEditorWindowAdapter(),
   accelerator: createEditorAcceleratorAdapter(),
diff --git a/src2/middleware/shared/ports/accelerator-port.ts b/src/middleware/shared/ports/accelerator-port.ts
similarity index 94%
rename from src2/middleware/shared/ports/accelerator-port.ts
rename to src/middleware/shared/ports/accelerator-port.ts
index 650e25cfe..e28dca55a 100644
--- a/src2/middleware/shared/ports/accelerator-port.ts
+++ b/src/middleware/shared/ports/accelerator-port.ts
@@ -39,7 +39,7 @@ export interface AcceleratorPort {
   // --- Project actions ---
   onCreateProject(callback: () => void): Unsubscribe
   onOpenProject(callback: () => void): Unsubscribe
-  onOpenRecent(callback: () => void): Unsubscribe
+  onOpenRecent(callback: (projectData?: unknown) => void): Unsubscribe
   onSaveProject(callback: () => void): Unsubscribe
   onSaveFile(callback: () => void): Unsubscribe
   onCloseProject(callback: () => void): Unsubscribe
@@ -55,4 +55,7 @@ export interface AcceleratorPort {
   // --- View actions ---
   onSwitchPerspective(callback: () => void): Unsubscribe
   onAbout(callback: () => void): Unsubscribe
+
+  // --- App lifecycle ---
+  onQuitApp(callback: () => void): Unsubscribe
 }
diff --git a/src/middleware/shared/ports/ai-port.ts b/src/middleware/shared/ports/ai-port.ts
new file mode 100644
index 000000000..738559d93
--- /dev/null
+++ b/src/middleware/shared/ports/ai-port.ts
@@ -0,0 +1,83 @@
+/**
+ * AIPort — Contract for AI-assisted coding features (inline completions, chat, credits, telemetry).
+ *
+ * The shared UI depends only on this interface. Platform adapters provide concrete
+ * implementations that handle HTTP streaming, SSE parsing, and API authentication.
+ */
+
+import type { AIFeatureConfig } from './types'
+
+// ---------------------------------------------------------------------------
+// Parameter & result types
+// ---------------------------------------------------------------------------
+
+/** Language identifiers supported by AI completion. */
+export type AICompletionLanguage = 'st' | 'il' | 'python' | 'cpp'
+
+/** Language identifiers supported by AI chat (superset of completion languages). */
+export type AIChatLanguage = 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd'
+
+/** Inline completion request parameters. */
+export interface AICompleteParams {
+  prefix: string
+  suffix: string
+  language: AICompletionLanguage
+  projectContext?: string
+  model?: 'haiku' | 'sonnet'
+  maxTokens?: number
+}
+
+/** Chat request parameters. */
+export interface AIChatParams {
+  messages: Array<{ role: 'user' | 'assistant'; content: string }>
+  pouContext?: string
+  language?: AIChatLanguage
+  model?: 'haiku' | 'sonnet'
+}
+
+/** Credit status returned by fetchCredits. */
+export interface AICreditStatus {
+  credits_used: number
+  credits_total: number
+  tier: 'free' | 'pro'
+  current_period_end: string | null
+}
+
+/** Telemetry event names. */
+export type AITelemetryEventName =
+  | 'completion_requested'
+  | 'completion_shown'
+  | 'completion_accepted'
+  | 'completion_dismissed'
+  | 'completion_error'
+  | 'completion_timeout'
+  | 'chat_message'
+  | 'chat_rating'
+
+// ---------------------------------------------------------------------------
+// Port interface
+// ---------------------------------------------------------------------------
+
+export interface AIPort extends AIFeatureConfig {
+  /**
+   * Stream an inline code completion.
+   * Yields string tokens as they arrive. Handles SSE parsing internally.
+   */
+  streamCompletion(params: AICompleteParams, signal?: AbortSignal): AsyncGenerator<string, void, unknown>
+
+  /**
+   * Stream a chat response.
+   * Yields string tokens as they arrive. Handles SSE parsing internally.
+   */
+  streamChat(params: AIChatParams, signal?: AbortSignal): AsyncGenerator<string, void, unknown>
+
+  /**
+   * Fetch current AI credit status.
+   */
+  fetchCredits(signal?: AbortSignal): Promise<AICreditStatus>
+
+  /**
+   * Send a telemetry event (fire-and-forget).
+   */
+  sendTelemetry(event: AITelemetryEventName, data: Record<string, unknown>): void
+}
diff --git a/src2/frontend/components/_atoms/graphical-editor/types/block.ts b/src/middleware/shared/ports/block-types.ts
similarity index 82%
rename from src2/frontend/components/_atoms/graphical-editor/types/block.ts
rename to src/middleware/shared/ports/block-types.ts
index 700d62ed9..9830fe668 100644
--- a/src2/frontend/components/_atoms/graphical-editor/types/block.ts
+++ b/src/middleware/shared/ports/block-types.ts
@@ -1,11 +1,7 @@
-import {
-  BaseLibraryPouSchema,
-  BaseLibraryVariableSchema,
-  baseTypeSchema,
-  genericTypeSchema,
-} from '../../../../../middleware/shared/ports/plc-schemas'
 import { z } from 'zod'
 
+import { BaseLibraryPouSchema, BaseLibraryVariableSchema, baseTypeSchema, genericTypeSchema } from './plc-schemas'
+
 const blockVariantVariableSchema = BaseLibraryVariableSchema.extend({
   id: z.string().optional(),
   class: z.enum(['input', 'output', 'local', 'inOut']),
diff --git a/src2/middleware/shared/ports/compiler-port.ts b/src/middleware/shared/ports/compiler-port.ts
similarity index 91%
rename from src2/middleware/shared/ports/compiler-port.ts
rename to src/middleware/shared/ports/compiler-port.ts
index 09f1c816c..2b4a245cf 100644
--- a/src2/middleware/shared/ports/compiler-port.ts
+++ b/src/middleware/shared/ports/compiler-port.ts
@@ -40,6 +40,9 @@ export interface CompileProgramArgs {
   projectPath: string
   communicationPort?: string
   compileOnly?: boolean
+  isSimulator?: boolean
+  runtimeIpAddress?: string | null
+  runtimeJwtToken?: string | null
 }
 
 export interface DebugCompileArgs {
@@ -59,10 +62,7 @@ export interface CompilerPort {
    * Run the full compilation pipeline (XML -> ST -> C -> binary).
    * Emits progress events for UI feedback.
    */
-  compileProgram(
-    args: CompileProgramArgs,
-    onProgress: (event: CompileProgressEvent) => void,
-  ): Promise<CompileResult>
+  compileProgram(args: CompileProgramArgs, onProgress: (event: CompileProgressEvent) => void): Promise<CompileResult>
 
   /**
    * Run a debug-mode compilation that produces debug symbols.
diff --git a/src2/middleware/shared/ports/debugger-port.ts b/src/middleware/shared/ports/debugger-port.ts
similarity index 80%
rename from src2/middleware/shared/ports/debugger-port.ts
rename to src/middleware/shared/ports/debugger-port.ts
index cccf85eae..5a1bd8830 100644
--- a/src2/middleware/shared/ports/debugger-port.ts
+++ b/src/middleware/shared/ports/debugger-port.ts
@@ -28,20 +28,15 @@
  *   - DebugTransport interface implementations
  */
 
-import type {
-  DebugSetResult,
-  DebugVariableResult,
-  Md5VerifyResult,
-  Unsubscribe,
-} from './types'
+import type { DebugConnectionConfig, DebugSetResult, DebugVariableResult, Md5VerifyResult, Unsubscribe } from './types'
 
 export interface DebuggerPort {
   /**
    * Connect to a debug target.
-   * The adapter resolves the actual transport (TCP, RTU, WebSocket, WebRTC, simulator)
-   * based on the current device configuration and platform capabilities.
+   * @param config — Connection target (TCP host, RTU serial, WebSocket, or simulator).
+   *                 The adapter maps this to the platform's transport mechanism.
    */
-  connect(): Promise<{ success: boolean; error?: string }>
+  connect(config: DebugConnectionConfig): Promise<{ success: boolean; error?: string }>
 
   /** Disconnect from the current debug target. */
   disconnect(): Promise<{ success: boolean }>
@@ -64,8 +59,9 @@ export interface DebuggerPort {
   /**
    * Verify that the running program matches the expected MD5 hash.
    * Used to detect program mismatch before starting a debug session.
+   * @param config — Connection target used for the verification request.
    */
-  verifyMd5(expectedMd5: string): Promise<Md5VerifyResult>
+  verifyMd5(expectedMd5: string, config: DebugConnectionConfig): Promise<Md5VerifyResult>
 
   /**
    * Read the MD5 hash of the compiled ST program from the debug artifacts.
@@ -79,7 +75,10 @@ export interface DebuggerPort {
    * Editor: reads .dbg file from disk.
    * Web: reads from compiler API response.
    */
-  readDebugFile(projectPath: string, boardTarget: string): Promise<{ success: boolean; content?: string; error?: string }>
+  readDebugFile(
+    projectPath: string,
+    boardTarget: string,
+  ): Promise<{ success: boolean; content?: string; error?: string }>
 
   /**
    * Subscribe to debugger disconnection events (e.g., simulator stopped, connection lost).
diff --git a/src2/middleware/shared/ports/device-port.ts b/src/middleware/shared/ports/device-port.ts
similarity index 100%
rename from src2/middleware/shared/ports/device-port.ts
rename to src/middleware/shared/ports/device-port.ts
diff --git a/src2/middleware/shared/ports/index.ts b/src/middleware/shared/ports/index.ts
similarity index 75%
rename from src2/middleware/shared/ports/index.ts
rename to src/middleware/shared/ports/index.ts
index 42707d68c..1c12ab1a3 100644
--- a/src2/middleware/shared/ports/index.ts
+++ b/src/middleware/shared/ports/index.ts
@@ -24,17 +24,19 @@
  *     const { compiler, runtime, debugger } = usePlatform()
  *     await compiler.compileProgram(args, onProgress)
  *
- * 10 Port Interfaces:
- *   1. CompilerPort    — PLC compilation pipeline
- *   2. RuntimePort     — Remote PLC runtime communication
- *   3. DebuggerPort    — Debug protocol (variable read/write)
- *   4. SimulatorPort   — Built-in AVR simulator
- *   5. ProjectPort     — Project lifecycle (create, open, save, POU management)
- *   6. DevicePort      — Board/hardware discovery
- *   7. SystemPort      — Platform services (store, links, logging)
- *   8. WindowPort      — Native window management
- *   9. AcceleratorPort — Keyboard shortcuts
- *  10. ThemePort       — Theme detection and switching
+ * 12 Port Interfaces:
+ *   1. CompilerPort      — PLC compilation pipeline
+ *   2. RuntimePort       — Remote PLC runtime communication
+ *   3. DebuggerPort      — Debug protocol (variable read/write)
+ *   4. SimulatorPort     — Built-in AVR simulator
+ *   5. ProjectPort       — Project lifecycle (create, open, save, POU management)
+ *   6. DevicePort        — Board/hardware discovery
+ *   7. OrchestratorPort  — Orchestrator discovery and device listing
+ *   8. SystemPort        — Platform services (store, links, logging)
+ *   9. WindowPort        — Native window management
+ *  10. AcceleratorPort   — Keyboard shortcuts
+ *  11. ThemePort         — Theme detection and switching
+ *  12. AIPort            — AI-assisted coding (completions, chat, credits, telemetry)
  *
  * Plus:
  *   - PlatformCapabilities — Feature toggle flags
@@ -42,16 +44,26 @@
  */
 
 // --- Port interfaces ---
+export type { AcceleratorPort } from './accelerator-port'
+export type {
+  AIChatLanguage,
+  AIChatParams,
+  AICompleteParams,
+  AICompletionLanguage,
+  AICreditStatus,
+  AIPort,
+  AITelemetryEventName,
+} from './ai-port'
 export type { CompilerPort } from './compiler-port'
-export type { RuntimePort } from './runtime-port'
 export type { DebuggerPort } from './debugger-port'
-export type { SimulatorPort } from './simulator-port'
-export type { ProjectPort } from './project-port'
 export type { DevicePort } from './device-port'
+export type { OrchestratorPort } from './orchestrator-port'
+export type { ProjectPort } from './project-port'
+export type { RuntimePort } from './runtime-port'
+export type { SimulatorPort } from './simulator-port'
 export type { SystemPort } from './system-port'
-export type { WindowPort } from './window-port'
-export type { AcceleratorPort } from './accelerator-port'
 export type { ThemePort } from './theme-port'
+export type { WindowPort } from './window-port'
 
 // --- Feature toggles ---
 export type { PlatformCapabilities } from './platform-capabilities'
@@ -59,59 +71,59 @@ export { EDITOR_CAPABILITIES, WEB_CAPABILITIES } from './platform-capabilities'
 
 // --- Shared domain types ---
 export type {
-  // Result wrappers
-  Result,
-  Unsubscribe,
-  // PLC
-  PLCLanguage,
-  PLCExtendedLanguage,
-  PouType,
-  VariableClass,
-  PLCVariable,
-  PLCVariableType,
-  PLCTask,
-  PLCInstance,
-  PLCDataType,
-  PLCBody,
-  PLCPou,
-  PLCProjectData,
-  ProjectMeta,
-  // Device
-  CompilerType,
+  Architecture,
   BoardInfo,
   CommunicationPort,
-  SerialPort,
-  PinType,
-  DevicePin,
-  DeviceConfiguration,
-  ModbusRTUConfig,
-  ModbusTCPConfig,
-  // Runtime
-  PlcStatus,
-  TimingStats,
-  RuntimeLogLevel,
-  RuntimeLogEntry,
-  // Debugger
-  DebugVariableResult,
-  DebugSetResult,
-  Md5VerifyResult,
-  // Simulator Debug
-  SimulatorDebugResult,
   // Compiler
   CompileProgressEvent,
   CompileResult,
+  // Device
+  CompilerType,
   DebugCompileResult,
+  DebugSetResult,
+  DebugTreeNode,
+  // Debugger
+  DebugVariableResult,
+  DeviceConfiguration,
+  DevicePin,
+  // Debugger session
+  FbInstanceInfo,
   // Console
   LogObject,
-  PlcLogs,
+  Md5VerifyResult,
+  ModbusRTUConfig,
+  ModbusTCPConfig,
+  PinType,
   // System
   Platform,
-  Architecture,
-  SystemInfo,
+  PLCBody,
+  PLCDataType,
+  PLCExtendedLanguage,
+  PLCInstance,
+  // PLC
+  PLCLanguage,
+  PlcLogs,
+  PLCPou,
+  PLCProjectData,
+  // Runtime
+  PlcStatus,
+  PLCTask,
+  PLCVariable,
+  PLCVariableType,
+  PouType,
+  ProjectMeta,
   RecentProject,
-  // Debugger session
-  FbInstanceInfo,
-  DebugTreeNode,
+  // Result wrappers
+  Result,
+  RuntimeLogEntry,
+  RuntimeLogLevel,
+  SerialPort,
+  // Simulator Debug
+  SimulatorDebugResult,
+  SystemInfo,
+  TimingStats,
+  Unsubscribe,
+  VariableClass,
 } from './types'
 
 // --- Runtime log helpers ---
@@ -122,20 +134,21 @@ export { BaseLibraryPouSchema, BaseLibraryVariableSchema, baseTypeSchema, generi
 
 // --- Port parameter/result types ---
 export type { CompileProgramArgs, DebugCompileArgs, ExportXmlArgs } from './compiler-port'
+export type { OrchestratorDevice, OrchestratorInfo } from './orchestrator-port'
 export type {
-  LoginParams,
-  LoginResult,
-  CreateUserParams,
-  UsersInfoResult,
-  RuntimeStatusResult,
-  CompilationStatusResult,
-  RuntimeLogsResult,
-} from './runtime-port'
-export type {
+  CreatePouParams,
   CreateProjectParams,
   ProjectResponse,
-  SaveProjectParams,
-  CreatePouParams,
   RenamePouParams,
+  SaveProjectParams,
 } from './project-port'
+export type {
+  CompilationStatusResult,
+  CreateUserParams,
+  LoginParams,
+  LoginResult,
+  RuntimeLogsResult,
+  RuntimeStatusResult,
+  UsersInfoResult,
+} from './runtime-port'
 export type { ThemeVariant } from './theme-port'
diff --git a/src2/frontend/store/slices/library/types.ts b/src/middleware/shared/ports/library-types.ts
similarity index 60%
rename from src2/frontend/store/slices/library/types.ts
rename to src/middleware/shared/ports/library-types.ts
index 16b10528b..543c0f1d5 100644
--- a/src2/frontend/store/slices/library/types.ts
+++ b/src/middleware/shared/ports/library-types.ts
@@ -1,14 +1,15 @@
-import type { PLCVariable } from '../../../../middleware/shared/ports/types'
-
 export type LibraryPouType = 'function' | 'function-block'
 export type LibraryLanguage = 'il' | 'st' | 'ld' | 'sfc' | 'fbd'
 
 export interface SystemLibraryVariable {
   name: string
   class: 'input' | 'output' | 'local'
-  type: { definition: 'base-type'; value: string }
+  type:
+    | { definition: 'base-type'; value: string }
+    | { definition: 'derived-type'; value: string }
+    | { definition: 'generic-type'; value: string }
   location?: string
-  initialValue?: string | null
+  initialValue?: unknown
   documentation?: string
 }
 
@@ -42,15 +43,3 @@ export type LibraryState = {
     user: UserLibrary[]
   }
 }
-
-export type LibraryActions = {
-  setSystemLibraries: (libraries: SystemLibrary[]) => void
-  addLibrary: (name: string, type: 'function' | 'function-block') => void
-  updateLibraryName: (name: string, newName: string) => void
-  clearUserLibraries: () => void
-  removeUserLibrary: (name: string) => void
-}
-
-export type LibrarySlice = LibraryState & {
-  libraryActions: LibraryActions
-}
diff --git a/src/middleware/shared/ports/orchestrator-port.ts b/src/middleware/shared/ports/orchestrator-port.ts
new file mode 100644
index 000000000..6f94e496f
--- /dev/null
+++ b/src/middleware/shared/ports/orchestrator-port.ts
@@ -0,0 +1,44 @@
+/**
+ * OrchestratorPort — Abstracts orchestrator discovery and device listing.
+ *
+ * Orchestrators are agent-managed hosts that contain one or more runtime devices.
+ * This port provides the interface for fetching the list of orchestrators and
+ * their devices, decoupling the UI from the specific API transport.
+ *
+ * Editor adapter: No-op (editor connects to devices directly, not through orchestrators).
+ * Web adapter:    Calls Edge API GET /orchestrators with cookie-based auth.
+ */
+
+/**
+ * A runtime device within an orchestrator.
+ */
+export interface OrchestratorDevice {
+  id: string
+  name: string
+  status: string | null
+  active: boolean
+}
+
+/**
+ * An orchestrator host with its managed devices.
+ */
+export interface OrchestratorInfo {
+  /** Database ID of the orchestrator record. */
+  id: string
+  /** Display name. */
+  name: string
+  /** Agent identifier used for runtime commands (run-command proxy). */
+  agentId: string
+  /** Optional description. */
+  description: string | null
+  /** Devices managed by this orchestrator. */
+  devices: OrchestratorDevice[]
+}
+
+/**
+ * Port interface for orchestrator operations.
+ */
+export interface OrchestratorPort {
+  /** Fetch all orchestrators with their devices. */
+  listOrchestrators(): Promise<OrchestratorInfo[]>
+}
diff --git a/src2/middleware/shared/ports/platform-capabilities.ts b/src/middleware/shared/ports/platform-capabilities.ts
similarity index 100%
rename from src2/middleware/shared/ports/platform-capabilities.ts
rename to src/middleware/shared/ports/platform-capabilities.ts
diff --git a/src2/middleware/shared/ports/plc-schemas.ts b/src/middleware/shared/ports/plc-schemas.ts
similarity index 93%
rename from src2/middleware/shared/ports/plc-schemas.ts
rename to src/middleware/shared/ports/plc-schemas.ts
index 3f380a346..0e58754e1 100644
--- a/src2/middleware/shared/ports/plc-schemas.ts
+++ b/src/middleware/shared/ports/plc-schemas.ts
@@ -14,26 +14,26 @@ import z from 'zod'
  * Base PLC types common to all libraries.
  */
 const baseTypeSchema = z.enum([
-  'BOOL',
-  'SINT',
-  'INT',
-  'DINT',
-  'LINT',
-  'USINT',
-  'UINT',
-  'UDINT',
-  'ULINT',
-  'REAL',
-  'LREAL',
-  'TIME',
-  'DATE',
-  'TOD',
-  'DT',
-  'STRING',
-  'BYTE',
-  'WORD',
-  'DWORD',
-  'LWORD',
+  'bool',
+  'sint',
+  'int',
+  'dint',
+  'lint',
+  'usint',
+  'uint',
+  'udint',
+  'ulint',
+  'real',
+  'lreal',
+  'time',
+  'date',
+  'tod',
+  'dt',
+  'string',
+  'byte',
+  'word',
+  'dword',
+  'lword',
 ])
 
 const genericTypeSchema = z.object({
diff --git a/src2/middleware/shared/ports/project-port.ts b/src/middleware/shared/ports/project-port.ts
similarity index 91%
rename from src2/middleware/shared/ports/project-port.ts
rename to src/middleware/shared/ports/project-port.ts
index 64585857c..e09d9fff5 100644
--- a/src2/middleware/shared/ports/project-port.ts
+++ b/src/middleware/shared/ports/project-port.ts
@@ -29,19 +29,14 @@
  *   - Project state in Zustand store
  */
 
-import type {
-  DeviceConfiguration,
-  DevicePin,
-  PLCProjectData,
-  ProjectMeta,
-  RecentProject,
-  Unsubscribe,
-} from './types'
+import type { DeviceConfiguration, DevicePin, PLCProjectData, ProjectMeta, RecentProject, Unsubscribe } from './types'
 
 export interface CreateProjectParams {
   name: string
   type: 'plc-project' | 'plc-library'
   path?: string
+  language?: 'il' | 'st' | 'ld' | 'sfc' | 'fbd' | 'python' | 'cpp'
+  time?: string
 }
 
 export interface ProjectResponse {
@@ -60,7 +55,11 @@ export interface ProjectResponse {
 
 export interface SaveProjectParams {
   projectPath: string
-  projectData: PLCProjectData
+  projectName?: string
+  projectData: PLCProjectData & {
+    /** Debug variable flags to persist (collected before save). */
+    debugVariables?: { global?: string[]; pous?: Record<string, string[]> }
+  }
   deviceConfiguration: DeviceConfiguration
   devicePinMapping: DevicePin[]
 }
diff --git a/src2/middleware/shared/ports/runtime-port.ts b/src/middleware/shared/ports/runtime-port.ts
similarity index 86%
rename from src2/middleware/shared/ports/runtime-port.ts
rename to src/middleware/shared/ports/runtime-port.ts
index e6ab3f6f0..fe432af85 100644
--- a/src2/middleware/shared/ports/runtime-port.ts
+++ b/src/middleware/shared/ports/runtime-port.ts
@@ -37,13 +37,7 @@
  *   - runtimeLogout()
  */
 
-import type {
-  PlcStatus,
-  RuntimeLogEntry,
-  SerialPort,
-  TimingStats,
-  Unsubscribe,
-} from './types'
+import type { PlcStatus, RuntimeLogEntry, SerialPort, TimingStats, Unsubscribe } from './types'
 
 export interface LoginParams {
   username: string
@@ -69,7 +63,7 @@ export interface UsersInfoResult {
 
 export interface RuntimeStatusResult {
   success: boolean
-  status?: PlcStatus | string
+  status?: PlcStatus | (string & {})
   timingStats?: TimingStats
   error?: string
 }
@@ -91,6 +85,9 @@ export interface RuntimeLogsResult {
 }
 
 export interface RuntimePort {
+  /** Set the target device for subsequent API calls. */
+  setDeviceContext?(context: { agentId: string; deviceId: string } | null): void
+
   /** Authenticate with the runtime. Returns JWT on success. */
   login(params: LoginParams): Promise<LoginResult>
 
@@ -121,6 +118,14 @@ export interface RuntimePort {
   /** Clear stored credentials (logout). */
   clearCredentials(): Promise<{ success: boolean }>
 
+  /**
+   * Check if the runtime connection is ready for debug operations.
+   * Each adapter implements its own readiness criteria:
+   *   - Web: device context set and authenticated (orchestrator connection)
+   *   - Editor: runtime IP address configured and authenticated
+   */
+  isReadyForDebug?(): boolean
+
   /**
    * Upload a compiled program to the runtime.
    * Web adapter: sends zip as base64.
diff --git a/src2/middleware/shared/ports/simulator-port.ts b/src/middleware/shared/ports/simulator-port.ts
similarity index 100%
rename from src2/middleware/shared/ports/simulator-port.ts
rename to src/middleware/shared/ports/simulator-port.ts
diff --git a/src2/middleware/shared/ports/system-port.ts b/src/middleware/shared/ports/system-port.ts
similarity index 100%
rename from src2/middleware/shared/ports/system-port.ts
rename to src/middleware/shared/ports/system-port.ts
diff --git a/src2/middleware/shared/ports/theme-port.ts b/src/middleware/shared/ports/theme-port.ts
similarity index 100%
rename from src2/middleware/shared/ports/theme-port.ts
rename to src/middleware/shared/ports/theme-port.ts
diff --git a/src2/middleware/shared/ports/types.ts b/src/middleware/shared/ports/types.ts
similarity index 81%
rename from src2/middleware/shared/ports/types.ts
rename to src/middleware/shared/ports/types.ts
index a1615c256..dc9afae6a 100644
--- a/src2/middleware/shared/ports/types.ts
+++ b/src/middleware/shared/ports/types.ts
@@ -12,7 +12,7 @@
 // ---------------------------------------------------------------------------
 
 /** Standard result for operations that can fail */
-export type Result<T = void> = { success: true } & T | { success: false; error: string }
+export type Result<T = void> = ({ success: true } & T) | { success: false; error: string }
 
 /** Unsubscribe function returned by event subscriptions */
 export type Unsubscribe = () => void
@@ -61,8 +61,8 @@ export interface PLCTask {
 
 export interface PLCInstance {
   name: string
-  taskName: string
-  pouName: string
+  task: string
+  program: string
 }
 
 export interface PLCStructureVariable {
@@ -180,12 +180,18 @@ export interface ModbusIOGroup {
   offset: string
   length: number
   errorHandling: 'keep-last-value' | 'set-to-zero'
-  ioPoints: ModbusIOPoint[]
+  ioPoints?: ModbusIOPoint[]
 }
 
 export interface ModbusRemoteTcpConfig {
+  transport?: 'tcp' | 'rtu'
   host: string
   port: number
+  serialPort?: string
+  baudRate?: number
+  parity?: 'N' | 'E' | 'O'
+  stopBits?: number
+  dataBits?: number
   slaveId: number
   timeout: number
   ioGroups: ModbusIOGroup[]
@@ -213,6 +219,7 @@ export interface S7CommPlcIdentity {
 }
 
 export interface S7CommBufferMapping {
+  type?: string
   startByte: number
   endByte: number
   iecAddresses: string[]
@@ -373,8 +380,15 @@ export interface PLCProjectData {
   }
   servers?: PLCServer[]
   remoteDevices?: PLCRemoteDevice[]
+  debugVariables?: {
+    global?: string[]
+    pous?: Record<string, string[]>
+  }
 }
 
+/** Alias used by Monaco completion providers */
+export type PLCProject = PLCProjectData
+
 export interface ProjectMeta {
   name: string
   type: 'plc-project' | 'plc-library'
@@ -388,7 +402,7 @@ export interface ProjectMeta {
 export type CompilerType = 'arduino-cli' | 'openplc-compiler' | 'simulator'
 
 export interface BoardInfo {
-  compiler: CompilerType | string
+  compiler: CompilerType | (string & {})
   core: string
   preview: string
   specs: Record<string, string>
@@ -489,6 +503,19 @@ export interface RuntimeLogEntry {
 // Debugger
 // ---------------------------------------------------------------------------
 
+export type DebugConnectionType = 'tcp' | 'rtu' | 'websocket' | 'simulator'
+
+export interface DebugConnectionConfig {
+  connectionType: DebugConnectionType
+  connectionParams: {
+    ipAddress?: string
+    port?: string
+    baudRate?: number
+    slaveId?: number
+    jwtToken?: string
+  }
+}
+
 export interface DebugVariableResult {
   success: boolean
   tick?: number
@@ -530,12 +557,17 @@ export interface CompileProgressEvent {
   stage: 'xml' | 'st' | 'c' | 'glue' | 'arduino' | 'done' | 'error'
   message: string
   progress?: number
+  level?: string
+  firmwarePath?: string
+  plcStatus?: string
 }
 
 export interface CompileResult {
   success: boolean
   message?: string
   hexPath?: string
+  /** Generated Structured Text program — available for runtime upload after compilation. */
+  programSt?: string
   error?: string
 }
 
@@ -625,6 +657,80 @@ export interface RecentProject {
   createdAt: string
 }
 
+// ---------------------------------------------------------------------------
+// AI Feature
+// ---------------------------------------------------------------------------
+
+/**
+ * Platform-provided configuration for the AI feature.
+ * Resolved by the composition root from environment variables and persistent storage.
+ */
+export interface AIFeatureConfig {
+  /** Whether the AI feature is enabled on this platform */
+  isFeatureEnabled: boolean
+  /** Whether the user has previously consented to AI usage */
+  hasUserConsented: boolean
+}
+
+// ---------------------------------------------------------------------------
+// AI Chat
+// ---------------------------------------------------------------------------
+
+export type ChatMessageRole = 'user' | 'assistant'
+
+export type ChatMessage = {
+  id: string
+  role: ChatMessageRole
+  content: string
+  timestamp: number
+  rating?: 'up' | 'down'
+}
+
+// ---------------------------------------------------------------------------
+// Graphical Editor Flow Data Shapes
+// ---------------------------------------------------------------------------
+
+/**
+ * FBD rung data — nodes + edges for one Function Block Diagram rung.
+ * Used by both the store slice and the compiler adapter.
+ */
+export type FBDRungState = {
+  comment: string
+  selectedNodes: import('@xyflow/react').Node[]
+  nodes: import('@xyflow/react').Node[]
+  edges: import('@xyflow/react').Edge[]
+}
+
+/**
+ * Ladder rung data — nodes + edges + layout for one Ladder rung.
+ * Used by both the store slice and the compiler adapter.
+ */
+export type RungLadderState = {
+  id: string
+  comment: string
+  defaultBounds: number[]
+  reactFlowViewport: number[]
+  selectedNodes: import('@xyflow/react').Node[]
+  nodes: import('@xyflow/react').Node[]
+  edges: import('@xyflow/react').Edge[]
+}
+
+// ---------------------------------------------------------------------------
+// WebRTC
+// ---------------------------------------------------------------------------
+
+export type WebRTCConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error' | 'failed'
+
+/** Narrow callback interface for the WebRTC connection manager. */
+export interface WebRTCSessionCallbacks {
+  setStatus: (status: WebRTCConnectionStatus) => void
+  setError: (error: string | null) => void
+  setSessionId: (id: string | null) => void
+  setReconnectAttempt: (attempt: number) => void
+  startSession: (params: { deviceId: string; deviceName: string; agentId: string }) => void
+  endSession: () => void
+}
+
 // ---------------------------------------------------------------------------
 // Variable Reference
 // ---------------------------------------------------------------------------
diff --git a/src2/middleware/shared/ports/window-port.ts b/src/middleware/shared/ports/window-port.ts
similarity index 79%
rename from src2/middleware/shared/ports/window-port.ts
rename to src/middleware/shared/ports/window-port.ts
index c5c47ecc0..183ca0866 100644
--- a/src2/middleware/shared/ports/window-port.ts
+++ b/src/middleware/shared/ports/window-port.ts
@@ -61,4 +61,18 @@ export interface WindowPort {
    * Web: no-op (never fires).
    */
   onMaximizedChanged?(callback: (isMaximized: boolean) => void): Unsubscribe
+
+  /**
+   * Subscribe to macOS app-level quit events (before-quit → close → will-quit).
+   * Editor: fires when the macOS app receives a before-quit event.
+   * Web: no-op (never fires).
+   */
+  onDarwinAppQuitting?(callback: () => void): Unsubscribe
+
+  /**
+   * Register the auto-response handler for window close requests from the main process.
+   * Editor: listens for `window-controls:request-close` and responds with `window-controls:close`.
+   * Web: no-op.
+   */
+  enableAutoCloseHandshake?(): Unsubscribe
 }
diff --git a/src/middleware/shared/providers/extension-panels.tsx b/src/middleware/shared/providers/extension-panels.tsx
new file mode 100644
index 000000000..db4041f3b
--- /dev/null
+++ b/src/middleware/shared/providers/extension-panels.tsx
@@ -0,0 +1,36 @@
+/**
+ * Extension Panel Provider — optional UI component injection.
+ *
+ * Platforms provide React components for optional panels (e.g. AI Chat)
+ * via this context. Shared code reads from the context and conditionally
+ * renders them. When no provider is present, all slots return null.
+ *
+ * Web: Wraps with ExtensionPanelProvider and provides AIChatPanel.
+ * Editor: Does not wrap — useChatPanel() returns null by default.
+ */
+
+import { type ComponentType, createContext, type ReactNode, useContext } from 'react'
+
+interface ExtensionPanels {
+  ChatPanel: ComponentType | null
+}
+
+const defaultPanels: ExtensionPanels = {
+  ChatPanel: null,
+}
+
+const ExtensionPanelContext = createContext<ExtensionPanels>(defaultPanels)
+
+interface ExtensionPanelProviderProps {
+  panels: ExtensionPanels
+  children: ReactNode
+}
+
+export function ExtensionPanelProvider({ panels, children }: ExtensionPanelProviderProps) {
+  return <ExtensionPanelContext.Provider value={panels}>{children}</ExtensionPanelContext.Provider>
+}
+
+/** Returns the platform-injected ChatPanel component, or null if not available. */
+export function useChatPanel(): ComponentType | null {
+  return useContext(ExtensionPanelContext).ChatPanel
+}
diff --git a/src2/middleware/shared/providers/index.ts b/src/middleware/shared/providers/index.ts
similarity index 75%
rename from src2/middleware/shared/providers/index.ts
rename to src/middleware/shared/providers/index.ts
index 739cc5134..a955fb138 100644
--- a/src2/middleware/shared/providers/index.ts
+++ b/src/middleware/shared/providers/index.ts
@@ -1,15 +1,18 @@
+export { ExtensionPanelProvider, useChatPanel } from './extension-panels'
 export { PlatformProvider, usePlatform } from './platform-context'
 export {
+  useAccelerator,
+  useAI,
+  useCapabilities,
   useCompiler,
-  useRuntime,
   useDebugger,
-  useSimulator,
-  useProject,
   useDevice,
+  useOrchestrator,
+  useProject,
+  useRuntime,
+  useSimulator,
   useSystem,
-  useWindow,
-  useAccelerator,
   useTheme,
-  useCapabilities,
+  useWindow,
 } from './platform-context'
 export type { PlatformPorts } from './types'
diff --git a/src2/middleware/shared/providers/platform-context.tsx b/src/middleware/shared/providers/platform-context.tsx
similarity index 92%
rename from src2/middleware/shared/providers/platform-context.tsx
rename to src/middleware/shared/providers/platform-context.tsx
index f1151112b..51446b8a2 100644
--- a/src2/middleware/shared/providers/platform-context.tsx
+++ b/src/middleware/shared/providers/platform-context.tsx
@@ -1,4 +1,4 @@
-import { createContext, useContext, type ReactNode } from 'react'
+import { createContext, type ReactNode, useContext } from 'react'
 
 import type { PlatformPorts } from './types'
 
@@ -74,6 +74,10 @@ export function useDevice() {
   return usePlatform().device
 }
 
+export function useOrchestrator() {
+  return usePlatform().orchestrator
+}
+
 export function useSystem() {
   return usePlatform().system
 }
@@ -93,3 +97,7 @@ export function useTheme() {
 export function useCapabilities() {
   return usePlatform().capabilities
 }
+
+export function useAI() {
+  return usePlatform().ai
+}
diff --git a/src2/middleware/shared/providers/types.ts b/src/middleware/shared/providers/types.ts
similarity index 87%
rename from src2/middleware/shared/providers/types.ts
rename to src/middleware/shared/providers/types.ts
index 4795b58b2..ada544f2e 100644
--- a/src2/middleware/shared/providers/types.ts
+++ b/src/middleware/shared/providers/types.ts
@@ -3,17 +3,19 @@
  * This is the shape of the value provided by PlatformContext.
  */
 
+import type { AcceleratorPort } from '../ports/accelerator-port'
+import type { AIPort } from '../ports/ai-port'
 import type { CompilerPort } from '../ports/compiler-port'
-import type { RuntimePort } from '../ports/runtime-port'
 import type { DebuggerPort } from '../ports/debugger-port'
-import type { SimulatorPort } from '../ports/simulator-port'
-import type { ProjectPort } from '../ports/project-port'
 import type { DevicePort } from '../ports/device-port'
+import type { OrchestratorPort } from '../ports/orchestrator-port'
+import type { PlatformCapabilities } from '../ports/platform-capabilities'
+import type { ProjectPort } from '../ports/project-port'
+import type { RuntimePort } from '../ports/runtime-port'
+import type { SimulatorPort } from '../ports/simulator-port'
 import type { SystemPort } from '../ports/system-port'
-import type { WindowPort } from '../ports/window-port'
-import type { AcceleratorPort } from '../ports/accelerator-port'
 import type { ThemePort } from '../ports/theme-port'
-import type { PlatformCapabilities } from '../ports/platform-capabilities'
+import type { WindowPort } from '../ports/window-port'
 
 export interface PlatformPorts {
   compiler: CompilerPort
@@ -22,9 +24,11 @@ export interface PlatformPorts {
   simulator: SimulatorPort
   project: ProjectPort
   device: DevicePort
+  orchestrator: OrchestratorPort
   system: SystemPort
   window: WindowPort
   accelerator: AcceleratorPort
   theme: ThemePort
   capabilities: PlatformCapabilities
+  ai?: AIPort
 }
diff --git a/src/types/PLC/open-plc.ts b/src/types/PLC/open-plc.ts
index 2f4cdd4bc..3dd2a49d5 100644
--- a/src/types/PLC/open-plc.ts
+++ b/src/types/PLC/open-plc.ts
@@ -1,7 +1,7 @@
 import { z } from 'zod'
 
-import { zodFBDFlowSchema } from '../../renderer/store/slices/fbd/types'
-import { zodLadderFlowSchema } from '../../renderer/store/slices/ladder/types'
+import { zodFBDFlowSchema } from '../../frontend/store/slices/fbd/types'
+import { zodLadderFlowSchema } from '../../frontend/store/slices/ladder/types'
 
 const baseTypeSchema = z.enum([
   'bool',
diff --git a/src/types/PLC/units/base-types.ts b/src/types/PLC/units/base-types.ts
index e3f0b7cee..fab4a0c8f 100644
--- a/src/types/PLC/units/base-types.ts
+++ b/src/types/PLC/units/base-types.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const PLCBaseTypesSchema = z.enum(baseTypes)
diff --git a/src/types/PLC/units/function-block.ts b/src/types/PLC/units/function-block.ts
index 01ca77d6f..1e6dcd09c 100644
--- a/src/types/PLC/units/function-block.ts
+++ b/src/types/PLC/units/function-block.ts
@@ -1,4 +1,4 @@
-import { PLCLanguagesShortenedForm } from '@root/shared/data'
+import { PLCLanguagesShortenedForm } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 import { PLCVariableSchema } from './variable'
diff --git a/src/types/PLC/units/function.ts b/src/types/PLC/units/function.ts
index a8981f3da..0a29acf7f 100644
--- a/src/types/PLC/units/function.ts
+++ b/src/types/PLC/units/function.ts
@@ -1,4 +1,4 @@
-import { baseTypes, PLCLanguagesShortenedForm } from '@root/shared/data'
+import { baseTypes, PLCLanguagesShortenedForm } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 import { PLCVariableSchema } from './variable'
diff --git a/src/types/PLC/units/program.ts b/src/types/PLC/units/program.ts
index 1fc20a37e..a11cbdff5 100644
--- a/src/types/PLC/units/program.ts
+++ b/src/types/PLC/units/program.ts
@@ -1,4 +1,4 @@
-import { PLCLanguagesShortenedForm } from '@root/shared/data'
+import { PLCLanguagesShortenedForm } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 import { PLCVariableSchema } from './variable'
diff --git a/src/types/PLC/xml-data/codesys/base-diagram.ts b/src/types/PLC/xml-data/codesys/base-diagram.ts
index 5d9d0fa60..ccaf489a0 100644
--- a/src/types/PLC/xml-data/codesys/base-diagram.ts
+++ b/src/types/PLC/xml-data/codesys/base-diagram.ts
@@ -1,4 +1,4 @@
-import { formatDate } from '@root/utils'
+import { formatDate } from '@root/frontend/utils/format-date'
 import { z } from 'zod'
 
 import { dataTypeSchema } from './data-types/data-types-diagram'
diff --git a/src/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts b/src/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts
index 9d6b208f3..52d72bea7 100644
--- a/src/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts
+++ b/src/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const dataTypeArraySchema = z.object({
diff --git a/src/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts b/src/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts
index aa813f0f8..12e4cc15e 100644
--- a/src/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts
+++ b/src/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const dataTypeStructSchema = z.object({
diff --git a/src/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts b/src/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts
index f286b9454..31e98c335 100644
--- a/src/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts
+++ b/src/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 import { variableXMLSchema } from '../../variable/variable-diagram'
diff --git a/src/types/PLC/xml-data/codesys/variable/variable-diagram.ts b/src/types/PLC/xml-data/codesys/variable/variable-diagram.ts
index 7c48760cd..6387d9a2c 100644
--- a/src/types/PLC/xml-data/codesys/variable/variable-diagram.ts
+++ b/src/types/PLC/xml-data/codesys/variable/variable-diagram.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const variableXMLSchema = z.object({
diff --git a/src/types/PLC/xml-data/old-editor/base-diagram.ts b/src/types/PLC/xml-data/old-editor/base-diagram.ts
index fb495f516..0decb948f 100644
--- a/src/types/PLC/xml-data/old-editor/base-diagram.ts
+++ b/src/types/PLC/xml-data/old-editor/base-diagram.ts
@@ -1,4 +1,4 @@
-import { formatDate } from '@root/utils'
+import { formatDate } from '@root/frontend/utils/format-date'
 import { z } from 'zod'
 
 import { dataTypeSchema } from './data-types/data-types-diagram'
diff --git a/src/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts b/src/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts
index 9d6b208f3..52d72bea7 100644
--- a/src/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts
+++ b/src/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const dataTypeArraySchema = z.object({
diff --git a/src/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts b/src/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts
index aa813f0f8..12e4cc15e 100644
--- a/src/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts
+++ b/src/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const dataTypeStructSchema = z.object({
diff --git a/src/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts b/src/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts
index f286b9454..31e98c335 100644
--- a/src/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts
+++ b/src/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 import { variableXMLSchema } from '../../variable/variable-diagram'
diff --git a/src/types/PLC/xml-data/old-editor/variable/variable-diagram.ts b/src/types/PLC/xml-data/old-editor/variable/variable-diagram.ts
index 7c48760cd..6387d9a2c 100644
--- a/src/types/PLC/xml-data/old-editor/variable/variable-diagram.ts
+++ b/src/types/PLC/xml-data/old-editor/variable/variable-diagram.ts
@@ -1,4 +1,4 @@
-import { baseTypes } from '@root/shared/data'
+import { baseTypes } from '@root/frontend/utils/plc-constants'
 import { z } from 'zod'
 
 const variableXMLSchema = z.object({
diff --git a/src/types/clipboard.ts b/src/types/clipboard.ts
index b5c845530..5713ad38c 100644
--- a/src/types/clipboard.ts
+++ b/src/types/clipboard.ts
@@ -1,4 +1,4 @@
-import { edgeSchema, nodeSchema } from '@root/renderer/store/slices/react-flow'
+import { edgeSchema, nodeSchema } from '@root/frontend/store/slices/react-flow'
 import z from 'zod'
 
 export const clipboardSchema = z.discriminatedUnion('language', [
diff --git a/src2/App.tsx b/src2/App.tsx
deleted file mode 100644
index 7083d5444..000000000
--- a/src2/App.tsx
+++ /dev/null
@@ -1,24 +0,0 @@
-import '@xyflow/react/dist/style.css'
-import 'tailwindcss/tailwind.css'
-import './backend/styles/globals.css'
-
-import { AppLayout } from './frontend/components/_templates/app-layout'
-import { StartScreen } from './frontend/screens/start-screen'
-import { WorkspaceScreen } from './frontend/screens/workspace-screen'
-import { useOpenPLCStore } from './frontend/store'
-import { editorPorts } from './middleware/editor-platform'
-import { PlatformProvider } from './middleware/shared/providers'
-
-export default function App() {
-  const {
-    project: {
-      meta: { path },
-    },
-  } = useOpenPLCStore()
-
-  return (
-    <PlatformProvider ports={editorPorts}>
-      <AppLayout>{path === '' ? <StartScreen /> : <WorkspaceScreen />}</AppLayout>
-    </PlatformProvider>
-  )
-}
diff --git a/src2/backend/shared/ai/__tests__/resolve-ai-initial-state.test.ts b/src2/backend/shared/ai/__tests__/resolve-ai-initial-state.test.ts
deleted file mode 100644
index 9c2cd18f8..000000000
--- a/src2/backend/shared/ai/__tests__/resolve-ai-initial-state.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { resolveAIInitialState } from '../resolve-ai-initial-state'
-
-describe('resolveAIInitialState', () => {
-  it('returns enabled and consented when config has both true', () => {
-    const result = resolveAIInitialState({
-      isFeatureEnabled: true,
-      hasUserConsented: true,
-    })
-    expect(result).toEqual({
-      isEnabled: true,
-      hasConsented: true,
-    })
-  })
-
-  it('returns disabled and not consented when config has both false', () => {
-    const result = resolveAIInitialState({
-      isFeatureEnabled: false,
-      hasUserConsented: false,
-    })
-    expect(result).toEqual({
-      isEnabled: false,
-      hasConsented: false,
-    })
-  })
-
-  it('returns enabled but not consented when only feature is enabled', () => {
-    const result = resolveAIInitialState({
-      isFeatureEnabled: true,
-      hasUserConsented: false,
-    })
-    expect(result).toEqual({
-      isEnabled: true,
-      hasConsented: false,
-    })
-  })
-
-  it('returns disabled but consented when only consent is given', () => {
-    const result = resolveAIInitialState({
-      isFeatureEnabled: false,
-      hasUserConsented: true,
-    })
-    expect(result).toEqual({
-      isEnabled: false,
-      hasConsented: true,
-    })
-  })
-})
diff --git a/src2/backend/shared/ai/index.ts b/src2/backend/shared/ai/index.ts
deleted file mode 100644
index b12632adc..000000000
--- a/src2/backend/shared/ai/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export { resolveAIInitialState } from './resolve-ai-initial-state'
-export type { AIFeatureConfig, ConsentStorage } from './types'
diff --git a/src2/backend/shared/ai/resolve-ai-initial-state.ts b/src2/backend/shared/ai/resolve-ai-initial-state.ts
deleted file mode 100644
index 6e0727533..000000000
--- a/src2/backend/shared/ai/resolve-ai-initial-state.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { AIFeatureConfig } from './types'
-
-/**
- * Derives the AI-specific initial state overrides from platform configuration.
- *
- * Business rules:
- * - AI is enabled only when the platform feature flag is on
- * - Consent status is loaded from persistent storage at startup
- *
- * Returns only the fields that depend on platform config. The caller merges
- * these with the slice's hardcoded defaults.
- */
-export function resolveAIInitialState(config: AIFeatureConfig) {
-  return {
-    isEnabled: config.isFeatureEnabled,
-    hasConsented: config.hasUserConsented,
-  }
-}
diff --git a/src2/backend/shared/ai/types.ts b/src2/backend/shared/ai/types.ts
deleted file mode 100644
index 27a293ac2..000000000
--- a/src2/backend/shared/ai/types.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * Platform-provided configuration for the AI feature.
- * Resolved by the composition root from environment variables and persistent storage.
- */
-export interface AIFeatureConfig {
-  /** Whether the AI feature is enabled on this platform */
-  isFeatureEnabled: boolean
-  /** Whether the user has previously consented to AI usage */
-  hasUserConsented: boolean
-}
-
-/**
- * Contract for persisting AI consent decisions across sessions.
- * Implemented by the composition root using platform-specific storage
- * (e.g., localStorage for web, electron-store for desktop).
- */
-export interface ConsentStorage {
-  load(): boolean
-  save(consented: boolean): void
-}
diff --git a/src2/frontend/assets/icons/project/ladder/Coil.tsx b/src2/frontend/assets/icons/project/ladder/Coil.tsx
deleted file mode 100644
index b7c44dd5e..000000000
--- a/src2/frontend/assets/icons/project/ladder/Coil.tsx
+++ /dev/null
@@ -1,41 +0,0 @@
-import { cn } from '../../../../utils/cn'
-import { ComponentPropsWithoutRef } from 'react'
-type ICoilIconProps = ComponentPropsWithoutRef<'svg'> & {
-  size?: 'sm' | 'md' | 'lg'
-}
-const sizeClasses = {
-  sm: 'w-5 h-5',
-  md: 'w-6 h-6',
-  lg: 'w-12 h-12',
-}
-
-export default function CoilIcon(props: ICoilIconProps) {
-  const { className, size = 'sm', ...res } = props
-
-  return (
-    <svg
-    className={cn(sizeClasses[size], className)}
-    viewBox='0 0 24 24'
-    fill='none'
-    xmlns='http://www.w3.org/2000/svg'
-    {...res}
-  >
-    <path
-      opacity='0.4'
-      d='M4.66667 0H18.6667C21.244 0 23.3333 2.08934 23.3333 4.66667V18.6667C23.3333 21.244 21.244 23.3333 18.6667 23.3333H4.66667C2.08934 23.3333 0 21.244 0 18.6667V4.66667C0 2.08934 2.08934 0 4.66667 0Z'
-      fill='#B4D0FE'
-    />
-    <path
-      d='M10.9629 7C10.6587 7.37547 10.4051 7.73261 10.1854 8.06229C9.94881 8.39197 9.76289 8.7308 9.61078 9.06964C9.45867 9.41763 9.34036 9.77478 9.27275 10.1411C9.18824 10.5166 9.15444 10.9286 9.15444 11.3682C9.15444 11.8169 9.18824 12.229 9.27275 12.5953C9.34036 12.9708 9.45867 13.328 9.61078 13.6668C9.76289 14.0056 9.94881 14.3445 10.1854 14.6741C10.4051 15.0038 10.6587 15.361 10.9629 15.7273H9.66148C8.95162 15.0496 8.37698 14.3353 7.97134 13.5935C7.56571 12.8609 7.36289 12.1191 7.36289 11.3682C7.36289 10.6264 7.56571 9.88467 7.97134 9.1429C8.37698 8.40113 8.95162 7.68683 9.66148 7H10.9629Z'
-      fill='#B4D0FE'
-    />
-    <path
-      d='M13.0371 7C13.3413 7.37547 13.5949 7.73261 13.8146 8.06229C14.0512 8.39197 14.2371 8.7308 14.3892 9.06964C14.5413 9.41763 14.6596 9.77478 14.7272 10.1411C14.8118 10.5166 14.8456 10.9286 14.8456 11.3682C14.8456 11.8169 14.8118 12.229 14.7272 12.5953C14.6596 12.9708 14.5413 13.328 14.3892 13.6668C14.2371 14.0056 14.0512 14.3445 13.8146 14.6741C13.5949 15.0038 13.3413 15.361 13.0371 15.7273H14.3385C15.0484 15.0496 15.623 14.3353 16.0287 13.5935C16.4343 12.8609 16.6371 12.1191 16.6371 11.3682C16.6371 10.6264 16.4343 9.88467 16.0287 9.1429C15.623 8.40113 15.0484 7.68683 14.3385 7H13.0371Z'
-      fill='#B4D0FE'
-    />
-    <path d='M16.6371 11.3629H21.0003' stroke='#B4D0FE' strokeWidth='1.35' />
-    <path d='M3 11.3629H7.36364' stroke='#B4D0FE' strokeWidth='1.35' />
-  </svg>
-
-  )
-}
diff --git a/src2/frontend/assets/icons/window-controls/Minimize.tsx b/src2/frontend/assets/icons/window-controls/Minimize.tsx
deleted file mode 100644
index dbd4b3a8d..000000000
--- a/src2/frontend/assets/icons/window-controls/Minimize.tsx
+++ /dev/null
@@ -1,10 +0,0 @@
-const MinimizeIcon = () => {
-    return (
-      <svg width='12' height='2' viewBox='0 0 16 2' fill='none' xmlns='http://www.w3.org/2000/svg'>
-        <title>Minimize</title>
-        <path d='M1 1H15' stroke='white' strokeWidth='1.5' strokeLinecap='round' />
-      </svg>
-  )
-}
-
-export { MinimizeIcon }
\ No newline at end of file
diff --git a/src2/frontend/components/_atoms/react-flow/custom-nodes/coil.tsx b/src2/frontend/components/_atoms/react-flow/custom-nodes/coil.tsx
deleted file mode 100644
index 2fdaa3e9c..000000000
--- a/src2/frontend/components/_atoms/react-flow/custom-nodes/coil.tsx
+++ /dev/null
@@ -1,282 +0,0 @@
-import { useOpenPLCStore } from '../../../../store'
-import { cn } from '../../../../utils/cn'
-import { useEffect, useRef, useState } from 'react'
-
-import { HighlightedTextArea } from '../../highlighted-textarea'
-import { CustomHandle } from './handle'
-import { getPouVariablesRungNodeAndEdges } from './utils'
-import type { BasicNodeData, CoilProps } from './utils/types'
-import { VariablesBlockAutoComplete } from './variables-block-autocomplete'
-import { DEFAULT_COIL_BLOCK_HEIGHT, DEFAULT_COIL_BLOCK_WIDTH, DEFAULT_COIL_TYPES } from './utils/constants'
-
-export const Coil = (block: CoilProps) => {
-  const { selected, data, id } = block
-
-  const {
-    editor,
-    project: {
-      data: { pous },
-    },
-    flows,
-    flowActions: { updateNode },
-  } = useOpenPLCStore()
-
-  const coil = DEFAULT_COIL_TYPES[data.variant]
-  const [coilVariableValue, setCoilVariableValue] = useState<string>(data.variable.name)
-  const [wrongVariable, setWrongVariable] = useState<boolean>(false)
-
-  const inputWrapperRef = useRef<HTMLDivElement>(null)
-  const inputVariableRef = useRef<
-    HTMLTextAreaElement & {
-      blur: ({ submit }: { submit?: boolean }) => void
-      isFocused: boolean
-    }
-  >(null)
-  const autocompleteRef = useRef<
-    HTMLDivElement & {
-      focus: () => void
-      isFocused: boolean
-      selectedVariable: { positionInArray: number; variableName: string }
-    }
-  >(null)
-
-  const [openAutocomplete, setOpenAutocomplete] = useState<boolean>(false)
-  const [keyPressedAtTextarea, setKeyPressedAtTextarea] = useState<string>('')
-
-  useEffect(() => {
-    if (inputVariableRef.current && inputWrapperRef.current) {
-      inputWrapperRef.current.style.top = inputVariableRef.current.scrollHeight >= 24 ? '-24px' : '-20px'
-    }
-  }, [coilVariableValue])
-
-  /**
-   * useEffect to focus the variable input when the block is selected
-   */
-  useEffect(() => {
-    if (data.variable && data.variable.name !== '') {
-      setCoilVariableValue(data.variable.name)
-      return
-    }
-
-    if (inputVariableRef.current && selected) {
-      inputVariableRef.current.focus()
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-
-  /**
-   * Update wrongVariable state when the table of variables is updated
-   */
-  useEffect(() => {
-    const { variables, node, rung } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-      nodeId: id,
-      variableName: coilVariableValue,
-    })
-
-    if (!rung || !node) return
-
-    const variable = variables.selected
-    if (!variable) {
-      setWrongVariable(true)
-      return
-    }
-
-    if (variable && (variable.type.definition !== 'base-type' || variable.type.value.toUpperCase() !== 'BOOL')) {
-      setWrongVariable(true)
-      return
-    }
-
-    if ((node.data as BasicNodeData).variable.id !== variable.id) {
-      setCoilVariableValue(variable.name)
-      updateNode({
-        editorName: editor.meta.name,
-        rungId: rung.id,
-        nodeId: node.id,
-        node: {
-          ...node,
-          data: {
-            ...node.data,
-            variable,
-          },
-        },
-      })
-      setWrongVariable(false)
-      return
-    }
-
-    if ((node.data as BasicNodeData).variable.id === variable.id && variable.name !== coilVariableValue) {
-      if ((node.data as BasicNodeData).variable.name !== variable.name) {
-        updateNode({
-          editorName: editor.meta.name,
-          rungId: rung.id,
-          nodeId: node.id,
-          node: {
-            ...node,
-            data: {
-              ...node.data,
-              variable: {
-                ...variable,
-                name: variable.name,
-              },
-            },
-          },
-        })
-      }
-      setCoilVariableValue(variable.name)
-      setWrongVariable(false)
-      return
-    }
-
-    setWrongVariable(false)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [pous])
-
-  /**
-   * Handle with the variable input onBlur event
-   */
-  const handleSubmitCoilVariableOnTextareaBlur = (variableName?: string) => {
-    const variableNameToSubmit = variableName || coilVariableValue
-    const { variables, rung, node } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-      nodeId: id,
-      variableName: variableNameToSubmit,
-    })
-    if (!rung || !node) return
-
-    const variable = variables.selected
-    if (
-      !variable ||
-      variable.name !== variableNameToSubmit ||
-      variable.type.definition !== 'base-type' ||
-      variable.type.value.toUpperCase() !== 'BOOL'
-    ) {
-      updateNode({
-        editorName: editor.meta.name,
-        rungId: rung.id,
-        nodeId: node.id,
-        node: {
-          ...node,
-          data: {
-            ...node.data,
-            variable: { name: variableNameToSubmit },
-          },
-        },
-      })
-      setWrongVariable(true)
-      return
-    }
-
-    updateNode({
-      editorName: editor.meta.name,
-      rungId: rung.id,
-      nodeId: node.id,
-      node: {
-        ...node,
-        data: {
-          ...node.data,
-          variable: variable,
-        },
-      },
-    })
-    setWrongVariable(false)
-  }
-
-  const onChangeHandler = () => {
-    if (!openAutocomplete) {
-      setOpenAutocomplete(true)
-    }
-  }
-
-  return (
-    <div
-      className={cn({
-        'opacity-40': id.startsWith('copycat'),
-      })}
-    >
-      <div
-        className={cn(
-          'relative rounded-[1px] border border-transparent hover:outline hover:outline-2 hover:outline-offset-[3px] hover:outline-brand',
-          {
-            'outline outline-2 outline-offset-[3px] outline-brand': selected,
-          },
-        )}
-        style={{ width: DEFAULT_COIL_BLOCK_WIDTH, height: DEFAULT_COIL_BLOCK_HEIGHT }}
-      >
-        {coil.svg(wrongVariable)}
-        <div className='absolute left-1/2 w-[72px] -translate-x-1/2' ref={inputWrapperRef}>
-          <HighlightedTextArea
-            textAreaValue={coilVariableValue}
-            setTextAreaValue={setCoilVariableValue}
-            handleSubmit={handleSubmitCoilVariableOnTextareaBlur}
-            inputHeight={{
-              height: 24,
-              scrollLimiter: 32,
-            }}
-            ref={inputVariableRef}
-            textAreaClassName='text-center text-xs leading-3'
-            highlightClassName='text-center text-xs leading-3'
-            onFocus={(e) => {
-              e.target.select()
-              const { node, rung } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-                nodeId: id ?? '',
-              })
-              if (!node || !rung) return
-              updateNode({
-                editorName: editor.meta.name,
-                nodeId: node.id,
-                rungId: rung.id,
-                node: {
-                  ...node,
-                  draggable: false,
-                },
-              })
-              return
-            }}
-            onBlur={() => {
-              const { node, rung } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-                nodeId: id ?? '',
-              })
-              if (!node || !rung) return
-              updateNode({
-                editorName: editor.meta.name,
-                nodeId: node.id,
-                rungId: rung.id,
-                node: {
-                  ...node,
-                  draggable: node.data.draggable as boolean,
-                },
-              })
-              return
-            }}
-            onChange={onChangeHandler}
-            onKeyDown={(e) => {
-              if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Tab') e.preventDefault()
-              if (e.key === 'Enter' && autocompleteRef.current?.selectedVariable.positionInArray !== -1) {
-                inputVariableRef.current?.blur({ submit: false })
-              }
-              setKeyPressedAtTextarea(e.key)
-            }}
-            onKeyUp={() => setKeyPressedAtTextarea('')}
-          />
-          {openAutocomplete && (
-            <div className='relative flex justify-center'>
-              <div className='absolute -bottom-4'>
-                <VariablesBlockAutoComplete
-                  ref={autocompleteRef}
-                  block={block}
-                  blockType={'coil'}
-                  valueToSearch={coilVariableValue}
-                  isOpen={openAutocomplete}
-                  setIsOpen={(value) => setOpenAutocomplete(value)}
-                  keyPressed={keyPressedAtTextarea}
-                />
-              </div>
-            </div>
-          )}
-        </div>
-      </div>
-      {data.handles.map((handle, index) => (
-        <CustomHandle key={index} {...handle} />
-      ))}
-    </div>
-  )
-}
diff --git a/src2/frontend/components/_atoms/react-flow/custom-nodes/contact.tsx b/src2/frontend/components/_atoms/react-flow/custom-nodes/contact.tsx
deleted file mode 100644
index 5e7d68e2d..000000000
--- a/src2/frontend/components/_atoms/react-flow/custom-nodes/contact.tsx
+++ /dev/null
@@ -1,281 +0,0 @@
-import { useOpenPLCStore } from '../../../../store'
-import { cn } from '../../../../utils/cn'
-import { useEffect, useRef, useState } from 'react'
-
-import { HighlightedTextArea } from '../../highlighted-textarea'
-import { CustomHandle } from './handle'
-import { getPouVariablesRungNodeAndEdges } from './utils'
-import type { BasicNodeData, ContactProps } from './utils/types'
-import { VariablesBlockAutoComplete } from './variables-block-autocomplete'
-import { DEFAULT_CONTACT_TYPES, DEFAULT_CONTACT_BLOCK_WIDTH, DEFAULT_CONTACT_BLOCK_HEIGHT } from './utils/constants'
-
-export const Contact = (block: ContactProps) => {
-  const { selected, data, id } = block
-  const {
-    editor,
-    project: {
-      data: { pous },
-    },
-    flows,
-    flowActions: { updateNode },
-  } = useOpenPLCStore()
-
-  const contact = DEFAULT_CONTACT_TYPES[data.variant]
-  const [contactVariableValue, setContactVariableValue] = useState<string>(data.variable.name)
-  const [wrongVariable, setWrongVariable] = useState<boolean>(false)
-
-  const inputWrapperRef = useRef<HTMLDivElement>(null)
-  const inputVariableRef = useRef<
-    HTMLTextAreaElement & {
-      blur: ({ submit }: { submit?: boolean }) => void
-      isFocused: boolean
-    }
-  >(null)
-  const autocompleteRef = useRef<
-    HTMLDivElement & {
-      focus: () => void
-      isFocused: boolean
-      selectedVariable: { positionInArray: number; variableName: string }
-    }
-  >(null)
-
-  const [openAutocomplete, setOpenAutocomplete] = useState<boolean>(false)
-  const [keyPressedAtTextarea, setKeyPressedAtTextarea] = useState<string>('')
-
-  useEffect(() => {
-    if (inputVariableRef.current && inputWrapperRef.current) {
-      // top
-      inputWrapperRef.current.style.top = inputVariableRef.current.scrollHeight >= 24 ? '-24px' : '-20px'
-    }
-  }, [contactVariableValue])
-
-  /**
-   * useEffect to focus the variable input when the block is selected
-   */
-  useEffect(() => {
-    if (data.variable && data.variable.name !== '') {
-      setContactVariableValue(data.variable.name)
-      return
-    }
-
-    if (inputVariableRef.current && selected) {
-      inputVariableRef.current.focus()
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-
-  /**
-   * Update wrongVariable state when the table of variables is updated
-   */
-  useEffect(() => {
-    const { variables, node, rung } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-      nodeId: id,
-      variableName: contactVariableValue,
-    })
-    if (!node || !rung) return
-
-    const variable = variables.selected
-
-    if (!variable) {
-      setWrongVariable(true)
-      return
-    }
-    if (variable && (variable.type.definition !== 'base-type' || variable.type.value.toUpperCase() !== 'BOOL')) {
-      setWrongVariable(true)
-      return
-    }
-
-    // Variable of the node is different from the selected variable
-    if ((node.data as BasicNodeData).variable.id !== variable.id) {
-      updateNode({
-        editorName: editor.meta.name,
-        rungId: rung.id,
-        nodeId: node.id,
-        node: {
-          ...node,
-          data: {
-            ...node.data,
-            variable,
-          },
-        },
-      })
-      setWrongVariable(false)
-      return
-    }
-
-    if ((node.data as BasicNodeData).variable.id === variable.id && variable.name !== contactVariableValue) {
-      if ((node.data as BasicNodeData).variable.name !== variable.name) {
-        updateNode({
-          editorName: editor.meta.name,
-          rungId: rung.id,
-          nodeId: node.id,
-          node: {
-            ...node,
-            data: {
-              ...node.data,
-              variable: {
-                ...variable,
-                name: variable.name,
-              },
-            },
-          },
-        })
-      }
-      setContactVariableValue(variable.name)
-      setWrongVariable(false)
-      return
-    }
-
-    setWrongVariable(false)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [pous])
-
-  /**
-   * Handle with the variable input onBlur event
-   */
-  const handleSubmitContactVariableOnTextareaBlur = (variableName?: string) => {
-    const variableNameToSubmit = variableName || contactVariableValue
-    const { rung, node, variables } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-      nodeId: id,
-      variableName: variableNameToSubmit,
-    })
-    if (!rung || !node) return
-
-    const variable = variables.selected
-    if (
-      !variable ||
-      variable.name !== variableNameToSubmit ||
-      variable.type.definition !== 'base-type' ||
-      variable.type.value.toUpperCase() !== 'BOOL'
-    ) {
-      updateNode({
-        editorName: editor.meta.name,
-        rungId: rung.id,
-        nodeId: node.id,
-        node: {
-          ...node,
-          data: {
-            ...node.data,
-            variable: { name: variableNameToSubmit },
-          },
-        },
-      })
-      setWrongVariable(true)
-      return
-    }
-
-    updateNode({
-      editorName: editor.meta.name,
-      rungId: rung.id,
-      nodeId: node.id,
-      node: {
-        ...node,
-        data: {
-          ...node.data,
-          variable,
-        },
-      },
-    })
-    setWrongVariable(false)
-  }
-
-  const onChangeHandler = () => {
-    if (!openAutocomplete) {
-      setOpenAutocomplete(true)
-    }
-  }
-
-  return (
-    <div
-      className={cn({
-        'opacity-40': id.startsWith('copycat'),
-      })}
-    >
-      <div
-        className={cn(
-          'relative rounded-[1px] border border-transparent hover:outline hover:outline-2 hover:outline-offset-[3px] hover:outline-brand',
-          {
-            'outline outline-2 outline-offset-[3px] outline-brand': selected,
-          },
-        )}
-        style={{ width: DEFAULT_CONTACT_BLOCK_WIDTH, height: DEFAULT_CONTACT_BLOCK_HEIGHT }}
-      >
-        {contact.svg(wrongVariable)}
-        <div className='absolute left-1/2 w-[72px] -translate-x-1/2' ref={inputWrapperRef}>
-          <HighlightedTextArea
-            textAreaValue={contactVariableValue}
-            setTextAreaValue={setContactVariableValue}
-            handleSubmit={handleSubmitContactVariableOnTextareaBlur}
-            inputHeight={{
-              height: 24,
-              scrollLimiter: 32,
-            }}
-            ref={inputVariableRef}
-            textAreaClassName='text-center text-xs leading-3'
-            highlightClassName='text-center text-xs leading-3'
-            onFocus={(e) => {
-              e.target.select()
-              const { node, rung } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-                nodeId: id ?? '',
-              })
-              if (!node || !rung) return
-              updateNode({
-                editorName: editor.meta.name,
-                nodeId: node.id,
-                rungId: rung.id,
-                node: {
-                  ...node,
-                  draggable: false,
-                },
-              })
-              return
-            }}
-            onBlur={() => {
-              const { node, rung } = getPouVariablesRungNodeAndEdges(editor, pous, flows, {
-                nodeId: id ?? '',
-              })
-              if (!node || !rung) return
-              updateNode({
-                editorName: editor.meta.name,
-                nodeId: node.id,
-                rungId: rung.id,
-                node: {
-                  ...node,
-                  draggable: node.data.draggable as boolean,
-                },
-              })
-              return
-            }}
-            onChange={onChangeHandler}
-            onKeyDown={(e) => {
-              if (e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'Tab') e.preventDefault()
-              if (e.key === 'Enter' && autocompleteRef.current?.selectedVariable.positionInArray !== -1) {
-                inputVariableRef.current?.blur({ submit: false })
-              }
-              setKeyPressedAtTextarea(e.key)
-            }}
-            onKeyUp={() => setKeyPressedAtTextarea('')}
-          />
-          {openAutocomplete && (
-            <div className='relative flex justify-center'>
-              <div className='absolute -bottom-4'>
-                <VariablesBlockAutoComplete
-                  ref={autocompleteRef}
-                  block={block}
-                  blockType={'contact'}
-                  valueToSearch={contactVariableValue}
-                  isOpen={openAutocomplete}
-                  setIsOpen={(value) => setOpenAutocomplete(value)}
-                  keyPressed={keyPressedAtTextarea}
-                />
-              </div>
-            </div>
-          )}
-        </div>
-      </div>
-      {data.handles.map((handle, index) => (
-        <CustomHandle key={index} {...handle} />
-      ))}
-    </div>
-  )
-}
diff --git a/src2/frontend/components/_features/[app]/debug-manager/index.tsx b/src2/frontend/components/_features/[app]/debug-manager/index.tsx
deleted file mode 100644
index 050daf664..000000000
--- a/src2/frontend/components/_features/[app]/debug-manager/index.tsx
+++ /dev/null
@@ -1,370 +0,0 @@
-/**
- * Debug Manager Component
- *
- * Single headless component that manages the entire debug lifecycle,
- * replacing the previous dual SimulatorManager + WebRTCManager pattern.
- *
- * Architecture:
- * - One useDebugSession hook (parses debug.c, builds trees, manages state)
- * - One useDebugPolling hook (polls via debugBridge, transport-agnostic)
- * - Transport selection based on board type:
- *   - Simulator board → ModbusRtuTransport (local AVR emulator)
- *   - Remote board → WebRTCTransport (with HTTP fallback)
- * - WebRTC connection lifecycle runs in background (does not block HTTP)
- *
- * Mirrors the desktop editor's MainProcessBridge pattern where one bridge
- * manages one active transport and the polling loop never knows which
- * transport is active.
- */
-
-import { useCallback, useEffect, useRef } from 'react'
-import { useOpenPLCStore } from '../../../../store'
-import { useWebRTCConnection } from '../../../../hooks/useWebRTCConnection'
-import { useDebugSession } from '../../../../hooks/useDebugSession'
-import { useDebugPolling } from '../../../../hooks/useDebugPolling'
-import { debugBridge } from '../../../../services/debug/debug-bridge'
-import { ModbusRtuTransport } from '../../../../services/debug/transports/modbus-rtu-transport'
-import { WebRTCTransport } from '../../../../services/debug/transports/webrtc-transport'
-import type { WebRTCTransportConfig } from '../../../../services/debug/transports/webrtc-transport'
-import { simulatorService } from '../../../../services/simulator/simulator-service'
-import { setDebugSessionControls, clearDebugSessionControls } from '../../../../services/debug-session-controls'
-
-export const DebugManager = () => {
-  const { runtimeConnection, workspaceActions, consoleActions, webrtcActions } = useOpenPLCStore()
-  const webrtcStatus = useOpenPLCStore((state) => state.session.status)
-  const isDebuggerVisible = useOpenPLCStore((state) => state.workspace.isDebuggerVisible)
-
-  // Detect if the current board is the simulator
-  const isSimulatorBoard = useOpenPLCStore((state) => {
-    const boardName = state.deviceDefinitions.configuration.deviceBoard
-    const boardInfo = state.deviceAvailableOptions.availableBoards.get(boardName)
-    return boardInfo?.compiler === 'simulator'
-  })
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Single debug session + single polling loop (transport-agnostic)
-  // ─────────────────────────────────────────────────────────────────────────
-  const debugSession = useDebugSession()
-  useDebugPolling({ debugTreesRef: debugSession.debugTreesRef })
-
-  const debugSessionRef = useRef(debugSession)
-  debugSessionRef.current = debugSession
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // WebRTC connection (only used when NOT simulator board)
-  // ─────────────────────────────────────────────────────────────────────────
-  const webrtcTransportRef = useRef<WebRTCTransport | null>(null)
-  const selectedDevice = runtimeConnection.selectedDevice
-
-  const webrtc = useWebRTCConnection({
-    deviceId: selectedDevice?.deviceId ?? '',
-    deviceName: selectedDevice?.deviceName ?? '',
-    agentId: selectedDevice?.orchestratorAgentId ?? '',
-    onDebugMessage: (msg) => webrtcTransportRef.current?.onDebugMessage(msg),
-  })
-
-  const {
-    connect: webrtcConnect,
-    disconnect: webrtcDisconnect,
-    sendDebugMessage: webrtcSendDebugMessage,
-    openDebugChannel: webrtcOpenDebugChannel,
-    closeDebugChannel: webrtcCloseDebugChannel,
-  } = webrtc
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // WebRTC upgrade helper
-  // ─────────────────────────────────────────────────────────────────────────
-  const tryUpgradeToWebRTC = useCallback(
-    (context: string) => {
-      webrtcOpenDebugChannel()
-        .then((opened) => {
-          if (opened) {
-            console.log(`[DebugManager] Debug channel opened (${context}) — upgrading transport to WebRTC`)
-            webrtcActions.setDebugTransport('webrtc')
-            consoleActions.addLog({
-              id: crypto.randomUUID(),
-              level: 'info',
-              message: 'WebRTC connected. Debug polling upgraded to high-speed mode.',
-            })
-          } else {
-            console.warn(`[DebugManager] Debug channel failed to open (${context}) — staying on HTTP`)
-          }
-        })
-        .catch((err) => {
-          console.error(`[DebugManager] Debug channel upgrade error (${context}):`, err)
-        })
-    },
-    [webrtcOpenDebugChannel, webrtcActions, consoleActions],
-  )
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Debug session controls — registered once, transport-aware
-  // ─────────────────────────────────────────────────────────────────────────
-  useEffect(() => {
-    setDebugSessionControls({
-      startDebug: async (deviceId, username, password, debugCContent, port) => {
-        if (isSimulatorBoard) {
-          // Simulator path: set up ModbusRtuTransport
-          debugBridge.setTransport('simulator', new ModbusRtuTransport())
-        } else {
-          // Remote path: set up WebRTCTransport (starts on HTTP, WebRTC upgrades in background)
-          const transportConfig: WebRTCTransportConfig = {
-            sendViaDataChannel: webrtcSendDebugMessage,
-            agentId: selectedDevice?.orchestratorAgentId ?? '',
-            deviceId: selectedDevice?.deviceId ?? '',
-            username,
-            password,
-            port,
-            onReady: () => {
-              // Auto-recovery: remote agent restarted mid-session — re-send debug_start
-              const { workspace: ws, runtimeConnection: rc } = useOpenPLCStore.getState()
-              if (ws.isDebuggerVisible) {
-                const creds = rc.storedCredentials
-                const device = rc.selectedDevice
-                if (creds && device) {
-                  consoleActions.addLog({
-                    id: crypto.randomUUID(),
-                    level: 'info',
-                    message: 'Debug channel reconnected. Resuming debug session...',
-                  })
-                  webrtcSendDebugMessage({
-                    type: 'debug_start',
-                    device_id: device.deviceId,
-                    username: creds.username,
-                    password: creds.password,
-                    port: port ?? 8443,
-                  })
-                } else {
-                  consoleActions.addLog({
-                    id: crypto.randomUUID(),
-                    level: 'warning',
-                    message: 'Debug channel reconnected but credentials unavailable. Please restart the debugger.',
-                  })
-                  workspaceActions.clearDebugState()
-                }
-              }
-            },
-          }
-          const transport = new WebRTCTransport(transportConfig)
-          webrtcTransportRef.current = transport
-          debugBridge.setTransport('webrtc', transport)
-        }
-
-        // For remote boards, connect the transport (sends debug_start to the agent).
-        // This goes via HTTP fallback initially; WebRTC DataChannel upgrade happens below.
-        // For simulator, connectDebugger() is already called by useDebuggerLauncher before
-        // this function, so we skip it here to avoid double-connecting.
-        if (!isSimulatorBoard) {
-          try {
-            await debugBridge.connect()
-          } catch (err) {
-            consoleActions.addLog({
-              id: crypto.randomUUID(),
-              level: 'error',
-              message: `Debug connection failed: ${err instanceof Error ? err.message : err}`,
-            })
-            debugBridge.clearTransport()
-            return false
-          }
-        }
-
-        // Start debug session (builds trees, indexes, commits to store)
-        const result = debugSessionRef.current.startDebug(deviceId, username, password, debugCContent, port)
-
-        // If WebRTC main channel is connected, try to open debug channel in background
-        if (!isSimulatorBoard) {
-          const currentStatus = useOpenPLCStore.getState().session.status
-          if (currentStatus === 'connected') {
-            tryUpgradeToWebRTC('debug-start')
-          }
-        }
-
-        return result
-      },
-
-      stopDebug: () => {
-        if (!isSimulatorBoard) {
-          webrtcActions.setDebugTransport('http')
-          webrtcCloseDebugChannel()
-          webrtcTransportRef.current = null
-        }
-        debugSessionRef.current.stopDebug()
-        debugBridge.clearTransport()
-      },
-
-      forceVariable: (index, force, valueHex) => {
-        return debugSessionRef.current.forceVariable(index, force, valueHex)
-      },
-    })
-
-    return () => {
-      clearDebugSessionControls()
-    }
-  }, [
-    isSimulatorBoard,
-    webrtcActions,
-    consoleActions,
-    workspaceActions,
-    webrtcCloseDebugChannel,
-    webrtcSendDebugMessage,
-    selectedDevice,
-    tryUpgradeToWebRTC,
-  ])
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // WebRTC connection lifecycle (background — only for non-simulator boards)
-  // ─────────────────────────────────────────────────────────────────────────
-  const prevConnectionStatusRef = useRef(runtimeConnection.connectionStatus)
-  const prevSelectedDeviceRef = useRef(selectedDevice?.deviceId ?? null)
-
-  useEffect(() => {
-    if (isSimulatorBoard) return
-
-    const prevStatus = prevConnectionStatusRef.current
-    const currentStatus = runtimeConnection.connectionStatus
-    prevConnectionStatusRef.current = currentStatus
-
-    if (prevStatus !== 'connected' && currentStatus === 'connected' && selectedDevice) {
-      console.log('[DebugManager] Runtime connected, establishing WebRTC in background')
-      webrtcConnect().catch((err) => {
-        console.error('[DebugManager] WebRTC background connection failed:', err)
-      })
-    }
-
-    if (prevStatus === 'connected' && currentStatus !== 'connected') {
-      console.log('[DebugManager] Runtime disconnected, closing WebRTC')
-      webrtcActions.setDebugTransport('http')
-      if (isDebuggerVisible) {
-        workspaceActions.clearDebugState()
-      }
-      webrtcDisconnect().catch((err) => {
-        console.error('[DebugManager] Failed to close connection:', err)
-      })
-    }
-  }, [
-    runtimeConnection.connectionStatus,
-    selectedDevice,
-    isSimulatorBoard,
-    isDebuggerVisible,
-    workspaceActions,
-    webrtcActions,
-    webrtcConnect,
-    webrtcDisconnect,
-  ])
-
-  // Clear debug state when user switches to a different device while debugging
-  useEffect(() => {
-    if (isSimulatorBoard) return
-
-    const prevDeviceId = prevSelectedDeviceRef.current
-    const currentDeviceId = selectedDevice?.deviceId ?? null
-    prevSelectedDeviceRef.current = currentDeviceId
-
-    if (prevDeviceId && currentDeviceId && prevDeviceId !== currentDeviceId && isDebuggerVisible) {
-      consoleActions.addLog({
-        id: crypto.randomUUID(),
-        level: 'info',
-        message: 'Device changed. Clearing debug session.',
-      })
-      webrtcActions.setDebugTransport('http')
-      workspaceActions.clearDebugState()
-    }
-  }, [selectedDevice?.deviceId, isSimulatorBoard, isDebuggerVisible, consoleActions, workspaceActions, webrtcActions])
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // WebRTC transport status management (non-simulator only)
-  // ─────────────────────────────────────────────────────────────────────────
-  const prevWebrtcStatusRef = useRef(webrtcStatus)
-  useEffect(() => {
-    if (isSimulatorBoard) return
-
-    const prev = prevWebrtcStatusRef.current
-    prevWebrtcStatusRef.current = webrtcStatus
-
-    // Permanent failure → downgrade to HTTP
-    if (prev !== 'failed' && webrtcStatus === 'failed') {
-      webrtcActions.setDebugTransport('http')
-      if (isDebuggerVisible) {
-        consoleActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'warning',
-          message: 'WebRTC connection failed permanently. Debugger continuing via HTTP.',
-        })
-      }
-    }
-
-    // Transient failure → ensure HTTP
-    if (webrtcStatus === 'error' || webrtcStatus === 'disconnected' || webrtcStatus === 'reconnecting') {
-      const currentTransport = useOpenPLCStore.getState().session.debugTransport
-      if (currentTransport === 'webrtc') {
-        webrtcActions.setDebugTransport('http')
-      }
-    }
-  }, [webrtcStatus, isSimulatorBoard, isDebuggerVisible, consoleActions, webrtcActions])
-
-  // WebRTC upgrade on reconnect
-  const prevWebrtcStatusForUpgradeRef = useRef(webrtcStatus)
-  useEffect(() => {
-    if (isSimulatorBoard) return
-
-    const prevStatus = prevWebrtcStatusForUpgradeRef.current
-    prevWebrtcStatusForUpgradeRef.current = webrtcStatus
-
-    if (prevStatus !== 'connected' && webrtcStatus === 'connected' && isDebuggerVisible) {
-      tryUpgradeToWebRTC('webrtc-reconnect')
-    }
-  }, [webrtcStatus, isSimulatorBoard, isDebuggerVisible, tryUpgradeToWebRTC])
-
-  // Close debug channel when debugger becomes hidden
-  const prevDebuggerVisibleRef = useRef(isDebuggerVisible)
-  useEffect(() => {
-    const wasVisible = prevDebuggerVisibleRef.current
-    prevDebuggerVisibleRef.current = isDebuggerVisible
-
-    if (wasVisible && !isDebuggerVisible) {
-      if (!isSimulatorBoard) {
-        webrtcActions.setDebugTransport('http')
-        webrtcCloseDebugChannel()
-      }
-      webrtcTransportRef.current = null
-      debugBridge.clearTransport()
-    }
-  }, [isDebuggerVisible, isSimulatorBoard, webrtcActions, webrtcCloseDebugChannel])
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Simulator lifecycle (only when simulator board is selected)
-  // ─────────────────────────────────────────────────────────────────────────
-
-  // Subscribe to simulator stop events to clear debug state
-  useEffect(() => {
-    if (!isSimulatorBoard) return
-    const unsub = simulatorService.onStopped(() => {
-      const { workspace } = useOpenPLCStore.getState()
-      if (workspace.isDebuggerVisible) {
-        workspaceActions.clearDebugState()
-      }
-    })
-    return unsub
-  }, [isSimulatorBoard, workspaceActions])
-
-  // Stop simulator if the board is switched away while it's running
-  const prevIsSimulatorBoardRef = useRef(isSimulatorBoard)
-  useEffect(() => {
-    const wasSimulator = prevIsSimulatorBoardRef.current
-    prevIsSimulatorBoardRef.current = isSimulatorBoard
-
-    if (wasSimulator && !isSimulatorBoard && simulatorService.isRunning()) {
-      consoleActions.addLog({
-        id: crypto.randomUUID(),
-        level: 'info',
-        message: 'Board changed from simulator. Stopping simulator.',
-      })
-      simulatorService.stop()
-      if (isDebuggerVisible) {
-        workspaceActions.clearDebugState()
-      }
-    }
-  }, [isSimulatorBoard, isDebuggerVisible, consoleActions, workspaceActions])
-
-  return null
-}
diff --git a/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-input.tsx b/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-input.tsx
deleted file mode 100644
index 986baecef..000000000
--- a/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-input.tsx
+++ /dev/null
@@ -1,114 +0,0 @@
-import { useOpenPLCStore } from '../../../../store'
-import { useCallback, useRef, useState } from 'react'
-
-type AIChatInputProps = {
-  onSend: (message: string) => void
-  onCancel: () => void
-  isLoading: boolean
-  selectedText?: string
-}
-
-export const AIChatInput = ({ onSend, onCancel, isLoading, selectedText }: AIChatInputProps) => {
-  const [input, setInput] = useState('')
-  const textareaRef = useRef<HTMLTextAreaElement>(null)
-  const model = useOpenPLCStore.useAi().model
-  const { setAIModel } = useOpenPLCStore.useAiActions()
-
-  const handleSubmit = useCallback(() => {
-    const trimmed = input.trim()
-    if (!trimmed || isLoading) return
-    onSend(trimmed)
-    setInput('')
-    if (textareaRef.current) {
-      textareaRef.current.style.height = 'auto'
-    }
-  }, [input, isLoading, onSend])
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === 'Enter' && !e.shiftKey) {
-      e.preventDefault()
-      handleSubmit()
-    }
-  }
-
-  const handleQuickAction = (action: 'explain' | 'refactor') => {
-    if (!selectedText) return
-    const prefix = action === 'explain' ? 'Explain this code:\n\n' : 'Refactor this code:\n\n'
-    const message = `${prefix}\`\`\`\n${selectedText}\n\`\`\``
-    onSend(message)
-  }
-
-  const handleTextareaInput = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
-    setInput(e.target.value)
-    const el = e.target
-    el.style.height = 'auto'
-    el.style.height = `${Math.min(el.scrollHeight, 120)}px`
-  }
-
-  return (
-    <div className='flex flex-col gap-1.5 border-t border-neutral-200 p-2 dark:border-neutral-700'>
-      {selectedText && (
-        <div className='flex gap-1'>
-          <button
-            onClick={() => handleQuickAction('explain')}
-            className='rounded bg-neutral-100 px-2 py-0.5 text-[10px] font-medium text-neutral-600 hover:bg-neutral-200 dark:bg-neutral-800 dark:text-neutral-300 dark:hover:bg-neutral-700'
-          >
-            Explain selection
-          </button>
-          <button
-            onClick={() => handleQuickAction('refactor')}
-            className='rounded bg-neutral-100 px-2 py-0.5 text-[10px] font-medium text-neutral-600 hover:bg-neutral-200 dark:bg-neutral-800 dark:text-neutral-300 dark:hover:bg-neutral-700'
-          >
-            Refactor selection
-          </button>
-        </div>
-      )}
-
-      <div className='flex items-end gap-1'>
-        <textarea
-          ref={textareaRef}
-          value={input}
-          onChange={handleTextareaInput}
-          onKeyDown={handleKeyDown}
-          placeholder='Ask about your PLC code...'
-          rows={1}
-          className='flex-1 resize-none rounded-md border border-neutral-200 bg-white px-2 py-1.5 text-xs text-neutral-900 placeholder-neutral-400 outline-none focus:border-brand dark:border-neutral-700 dark:bg-neutral-900 dark:text-neutral-100 dark:placeholder-neutral-500 dark:focus:border-brand-light'
-        />
-        {isLoading ? (
-          <button
-            onClick={onCancel}
-            className='flex h-7 w-7 shrink-0 items-center justify-center rounded-md bg-red-500 text-white hover:bg-red-600'
-            title='Stop generating'
-          >
-            <svg width='10' height='10' viewBox='0 0 10 10'>
-              <rect width='10' height='10' rx='1' fill='currentColor' />
-            </svg>
-          </button>
-        ) : (
-          <button
-            onClick={handleSubmit}
-            disabled={!input.trim()}
-            className='flex h-7 w-7 shrink-0 items-center justify-center rounded-md bg-brand text-white hover:bg-brand-medium disabled:cursor-not-allowed disabled:opacity-40'
-            title='Send message'
-          >
-            <svg width='12' height='12' viewBox='0 0 12 12' fill='none'>
-              <path d='M1 11L11 6L1 1V5L8 6L1 7V11Z' fill='currentColor' />
-            </svg>
-          </button>
-        )}
-      </div>
-
-      <div className='flex items-center justify-between'>
-        <select
-          value={model}
-          onChange={(e) => setAIModel(e.target.value as 'haiku' | 'sonnet')}
-          className='rounded border border-neutral-200 bg-white px-1 py-0.5 text-[10px] text-neutral-600 outline-none dark:border-neutral-700 dark:bg-neutral-900 dark:text-neutral-400'
-        >
-          <option value='haiku'>Haiku (Fast)</option>
-          <option value='sonnet'>Sonnet (Best)</option>
-        </select>
-        <span className='text-[10px] text-neutral-400'>Shift+Enter for new line</span>
-      </div>
-    </div>
-  )
-}
diff --git a/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-message.tsx b/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-message.tsx
deleted file mode 100644
index 8fce6d046..000000000
--- a/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-message.tsx
+++ /dev/null
@@ -1,147 +0,0 @@
-import { useOpenPLCStore } from '../../../../store'
-import { trackChatRating } from '../../../../services/ai/telemetry'
-import type { ChatMessage } from '../../../../store/slices/ai/types'
-import Markdown from 'react-markdown'
-import { AICodeBlock } from './ai-code-block'
-
-type AIMessageProps = {
-  message: ChatMessage
-  pouName: string
-  language?: string
-  isStreaming?: boolean
-  onInsertAtCursor?: (code: string) => void
-}
-
-export const AIChatMessage = ({ message, pouName, language, isStreaming, onInsertAtCursor }: AIMessageProps) => {
-  const { rateMessage } = useOpenPLCStore.useAiActions()
-  const isUser = message.role === 'user'
-
-  const handleRate = (rating: 'up' | 'down') => {
-    const newRating = message.rating === rating ? undefined : rating
-    rateMessage(pouName, message.id, newRating)
-    if (newRating) {
-      trackChatRating({ messageId: message.id, rating: newRating, language: language ?? 'st' })
-    }
-  }
-
-  return (
-    <div className={`flex flex-col gap-1 ${isUser ? 'items-end' : 'items-start'}`}>
-      <div
-        className={`max-w-[90%] rounded-lg px-3 py-2 text-xs ${
-          isUser ? 'bg-brand text-white' : 'bg-neutral-100 text-neutral-900 dark:bg-neutral-800 dark:text-neutral-100'
-        }`}
-      >
-        {isUser || isStreaming ? (
-          <p className='whitespace-pre-wrap leading-relaxed'>{message.content}</p>
-        ) : (
-          <Markdown
-            components={{
-              code({ className, children }) {
-                const match = /language-(\w+)/.exec(className || '')
-                const code = String(children).replace(/\n$/, '')
-                if (match) {
-                  return <AICodeBlock code={code} language={match[1]} onInsertAtCursor={onInsertAtCursor} />
-                }
-                return (
-                  <code className='rounded bg-neutral-200 px-1 py-0.5 font-mono text-[11px] dark:bg-neutral-700'>
-                    {children}
-                  </code>
-                )
-              },
-              pre({ children }) {
-                return <>{children}</>
-              },
-              p({ children }) {
-                return <p className='my-1 leading-relaxed'>{children}</p>
-              },
-              ul({ children }) {
-                return <ul className='my-1 ml-4 list-disc'>{children}</ul>
-              },
-              ol({ children }) {
-                return <ol className='my-1 ml-4 list-decimal'>{children}</ol>
-              },
-              li({ children }) {
-                return <li className='my-0.5'>{children}</li>
-              },
-              h1({ children }) {
-                return <h1 className='my-1 text-sm font-bold'>{children}</h1>
-              },
-              h2({ children }) {
-                return <h2 className='my-1 text-sm font-bold'>{children}</h2>
-              },
-              h3({ children }) {
-                return <h3 className='my-1 font-bold'>{children}</h3>
-              },
-              strong({ children }) {
-                return <strong className='font-semibold'>{children}</strong>
-              },
-              blockquote({ children }) {
-                return (
-                  <blockquote className='my-1 border-l-2 border-neutral-300 pl-2 italic dark:border-neutral-600'>
-                    {children}
-                  </blockquote>
-                )
-              },
-              hr() {
-                return <hr className='my-2 border-neutral-300 dark:border-neutral-600' />
-              },
-            }}
-          >
-            {message.content}
-          </Markdown>
-        )}
-      </div>
-
-      {!isUser && message.content && (
-        <div className='flex items-center gap-1 px-1'>
-          <button
-            onClick={() => handleRate('up')}
-            className={`rounded p-0.5 text-[10px] ${
-              message.rating === 'up'
-                ? 'text-green-600 dark:text-green-400'
-                : 'text-neutral-400 hover:text-green-600 dark:text-neutral-500 dark:hover:text-green-400'
-            }`}
-            title='Good response'
-          >
-            <svg
-              width='12'
-              height='12'
-              viewBox='0 0 24 24'
-              fill='none'
-              stroke='currentColor'
-              strokeWidth='2'
-              strokeLinecap='round'
-              strokeLinejoin='round'
-            >
-              <path d='M7 10v12' />
-              <path d='M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z' />
-            </svg>
-          </button>
-          <button
-            onClick={() => handleRate('down')}
-            className={`rounded p-0.5 text-[10px] ${
-              message.rating === 'down'
-                ? 'text-red-600 dark:text-red-400'
-                : 'text-neutral-400 hover:text-red-600 dark:text-neutral-500 dark:hover:text-red-400'
-            }`}
-            title='Bad response'
-          >
-            <svg
-              width='12'
-              height='12'
-              viewBox='0 0 24 24'
-              fill='none'
-              stroke='currentColor'
-              strokeWidth='2'
-              strokeLinecap='round'
-              strokeLinejoin='round'
-            >
-              <path d='M17 14V2' />
-              <path d='M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z' />
-            </svg>
-          </button>
-        </div>
-      )}
-    </div>
-  )
-}
diff --git a/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-panel.tsx b/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-panel.tsx
deleted file mode 100644
index a46f6e463..000000000
--- a/src2/frontend/components/_features/[workspace]/ai-chat/ai-chat-panel.tsx
+++ /dev/null
@@ -1,235 +0,0 @@
-import { useAIChat } from '../../../../hooks/useAI'
-import { collectProjectContext } from '../../../../services/ai/context-collector'
-import { trackChatMessage } from '../../../../services/ai/telemetry'
-import type { AIChatMessage } from '../../../../services/ai/types'
-import { openPLCStoreBase, useOpenPLCStore } from '../../../../store'
-import { useCallback, useEffect, useRef, useState } from 'react'
-import { v4 as uuidv4 } from 'uuid'
-
-import { AIChatInput } from './ai-chat-input'
-import { AIChatMessage as ChatMessageComponent } from './ai-chat-message'
-
-export const AIChatPanel = () => {
-  const aiState = useOpenPLCStore.useAi()
-  const editor = useOpenPLCStore.useEditor()
-  const { setChatOpen, setActiveConversationPou, addMessage, updateMessageContent, clearConversation } =
-    useOpenPLCStore.useAiActions()
-
-  const { chat, cancel } = useAIChat()
-  const messagesEndRef = useRef<HTMLDivElement>(null)
-  const [selectedText, setSelectedText] = useState<string | undefined>()
-  const [streamingMessageId, setStreamingMessageId] = useState<string | null>(null)
-
-  // Derive the active POU name from the editor
-  const pouName = editor.type === 'plc-textual' || editor.type === 'plc-graphical' ? editor.meta.name : null
-
-  const language = editor.type === 'plc-textual' ? editor.meta.language : undefined
-
-  // Sync active conversation with current POU
-  useEffect(() => {
-    if (pouName && pouName !== aiState.activeConversationPou) {
-      setActiveConversationPou(pouName)
-    }
-  }, [pouName, aiState.activeConversationPou, setActiveConversationPou])
-
-  // Get current conversation messages
-  const conversation = aiState.conversations.find((c) => c.pouName === (pouName ?? aiState.activeConversationPou))
-  const messages = conversation?.messages ?? []
-
-  // Auto-scroll to bottom on new messages
-  const lastMessageContent = messages[messages.length - 1]?.content
-  useEffect(() => {
-    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
-  }, [messages.length, lastMessageContent])
-
-  // Track selected text in the editor for quick actions
-  useEffect(() => {
-    const checkSelection = () => {
-      const sel = window.getSelection()?.toString()
-      setSelectedText(sel && sel.length > 0 ? sel : undefined)
-    }
-
-    document.addEventListener('selectionchange', checkSelection)
-    return () => document.removeEventListener('selectionchange', checkSelection)
-  }, [])
-
-  const handleInsertAtCursor = useCallback((code: string) => {
-    // Dispatch a custom event that the Monaco editor can listen to
-    window.dispatchEvent(new CustomEvent('ai-insert-at-cursor', { detail: code }))
-  }, [])
-
-  const handleSend = useCallback(
-    async (userMessage: string) => {
-      const activePou = pouName ?? 'general'
-
-      // Add user message to store
-      const userMsg = {
-        id: uuidv4(),
-        role: 'user' as const,
-        content: userMessage,
-        timestamp: Date.now(),
-      }
-      addMessage(activePou, userMsg)
-
-      // Create placeholder for assistant response
-      const assistantMsgId = uuidv4()
-      const assistantMsg = {
-        id: assistantMsgId,
-        role: 'assistant' as const,
-        content: '',
-        timestamp: Date.now(),
-      }
-      addMessage(activePou, assistantMsg)
-      setStreamingMessageId(assistantMsgId)
-
-      // Build messages array for API (use all messages including the new user message)
-      const storeState = openPLCStoreBase.getState()
-      const conv = storeState.ai.conversations.find((c) => c.pouName === activePou)
-      const apiMessages: AIChatMessage[] = (conv?.messages ?? [])
-        .filter((m) => m.role === 'user' || (m.role === 'assistant' && m.content))
-        .map((m) => ({ role: m.role, content: m.content }))
-
-      // Resolve language from POU data (covers graphical editors like FBD/LD)
-      const pou = pouName ? storeState.project.data.pous.find((p) => p.data.name === pouName) : undefined
-      const pouLang = pou?.data.body.language ?? language ?? 'st'
-
-      // Collect project context: POU identity + body + variables/globals/FBs
-      let pouContext: string | undefined
-      if (pouName) {
-        const pouType = pou?.type ?? 'program'
-        const bodyValue = typeof pou?.data.body.value === 'string' ? pou.data.body.value : ''
-        const projectCtx = collectProjectContext(storeState, pouName, 4000)
-
-        const parts: string[] = []
-        // Always identify which POU the user is working on
-        parts.push(`(* Current POU: ${pouName} [${pouType}] language=${pouLang} *)`)
-        if (bodyValue) {
-          parts.push(bodyValue)
-        } else {
-          parts.push('(* POU body is empty — no code written yet *)')
-        }
-        if (projectCtx) {
-          parts.push(projectCtx)
-        }
-        pouContext = parts.join('\n\n')
-      }
-
-      // Track telemetry
-      trackChatMessage({
-        language: pouLang,
-        model: aiState.model,
-        messageCount: apiMessages.length,
-        pouName: activePou,
-      })
-
-      // Stream the response
-      let accumulated = ''
-      await chat(
-        {
-          messages: apiMessages,
-          pouContext,
-          language: language as 'st' | 'il' | 'python' | 'cpp' | undefined,
-        },
-        (token) => {
-          accumulated += token
-          updateMessageContent(activePou, assistantMsgId, accumulated)
-        },
-      )
-
-      // If no tokens were received (e.g., request failed), show an error in the placeholder
-      if (!accumulated) {
-        updateMessageContent(
-          activePou,
-          assistantMsgId,
-          'Unable to get a response from the AI service. Please try again.',
-        )
-      }
-
-      setStreamingMessageId(null)
-    },
-    [pouName, language, aiState.model, addMessage, updateMessageContent, chat],
-  )
-
-  const handleCancel = useCallback(() => {
-    cancel()
-    setStreamingMessageId(null)
-  }, [cancel])
-
-  const handleClear = useCallback(() => {
-    const activePou = pouName ?? aiState.activeConversationPou
-    if (activePou) {
-      clearConversation(activePou)
-    }
-  }, [pouName, aiState.activeConversationPou, clearConversation])
-
-  return (
-    <div className='flex h-full w-full flex-col overflow-hidden rounded-lg border-2 border-inherit border-neutral-200 bg-white dark:border-neutral-850 dark:bg-neutral-950'>
-      {/* Header */}
-      <div className='flex items-center justify-between border-b border-neutral-200 px-3 py-2 dark:border-neutral-700'>
-        <div className='flex items-center gap-2'>
-          <span className='text-xs font-medium text-neutral-700 dark:text-neutral-200'>AI Chat</span>
-          {pouName && (
-            <span className='rounded bg-neutral-100 px-1.5 py-0.5 text-[10px] text-neutral-500 dark:bg-neutral-800 dark:text-neutral-400'>
-              {pouName}
-            </span>
-          )}
-        </div>
-        <div className='flex items-center gap-1'>
-          {messages.length > 0 && (
-            <button
-              onClick={handleClear}
-              className='rounded px-1.5 py-0.5 text-[10px] text-neutral-500 hover:bg-neutral-100 dark:text-neutral-400 dark:hover:bg-neutral-800'
-              title='Clear conversation'
-            >
-              Clear
-            </button>
-          )}
-          <button
-            onClick={() => setChatOpen(false)}
-            className='rounded p-0.5 text-neutral-500 hover:bg-neutral-100 dark:text-neutral-400 dark:hover:bg-neutral-800'
-            title='Close chat'
-          >
-            <svg width='14' height='14' viewBox='0 0 14 14' fill='none'>
-              <path d='M3 3L11 11M11 3L3 11' stroke='currentColor' strokeWidth='1.5' strokeLinecap='round' />
-            </svg>
-          </button>
-        </div>
-      </div>
-
-      {/* Messages */}
-      <div className='flex-1 overflow-y-auto p-3'>
-        {messages.length === 0 ? (
-          <div className='flex h-full items-center justify-center'>
-            <p className='text-center text-xs text-neutral-400 dark:text-neutral-500'>
-              Ask questions about your PLC code.
-              <br />
-              <span className='text-[10px]'>Conversations are per-POU and limited to 20 messages.</span>
-            </p>
-          </div>
-        ) : (
-          <div className='flex flex-col gap-3'>
-            {messages.map((msg) => (
-              <ChatMessageComponent
-                key={msg.id}
-                message={msg}
-                pouName={pouName ?? aiState.activeConversationPou ?? 'general'}
-                language={language}
-                isStreaming={msg.id === streamingMessageId}
-                onInsertAtCursor={handleInsertAtCursor}
-              />
-            ))}
-            <div ref={messagesEndRef} />
-          </div>
-        )}
-      </div>
-
-      {/* Input */}
-      <AIChatInput
-        onSend={(msg) => void handleSend(msg)}
-        onCancel={handleCancel}
-        isLoading={!!streamingMessageId}
-        selectedText={selectedText}
-      />
-    </div>
-  )
-}
diff --git a/src2/frontend/components/_features/[workspace]/ai-chat/ai-code-block.tsx b/src2/frontend/components/_features/[workspace]/ai-chat/ai-code-block.tsx
deleted file mode 100644
index e48fbe6eb..000000000
--- a/src2/frontend/components/_features/[workspace]/ai-chat/ai-code-block.tsx
+++ /dev/null
@@ -1,62 +0,0 @@
-import * as monaco from 'monaco-editor'
-import { useCallback, useEffect, useRef, useState } from 'react'
-
-type AICodeBlockProps = {
-  code: string
-  language?: string
-  onInsertAtCursor?: (code: string) => void
-}
-
-export const AICodeBlock = ({ code, language, onInsertAtCursor }: AICodeBlockProps) => {
-  const containerRef = useRef<HTMLDivElement>(null)
-  const [copied, setCopied] = useState(false)
-
-  useEffect(() => {
-    if (!containerRef.current) return
-
-    const lang = language ?? 'st'
-    monaco.editor
-      .colorize(code, lang, { tabSize: 2 })
-      .then((html) => {
-        if (containerRef.current) {
-          containerRef.current.innerHTML = html
-        }
-      })
-      .catch(() => {
-        if (containerRef.current) {
-          containerRef.current.textContent = code
-        }
-      })
-  }, [code, language])
-
-  const handleCopy = useCallback(async () => {
-    await navigator.clipboard.writeText(code)
-    setCopied(true)
-    setTimeout(() => setCopied(false), 2000)
-  }, [code])
-
-  return (
-    <div className='group relative my-1 rounded-md border border-neutral-200 bg-neutral-50 dark:border-neutral-700 dark:bg-neutral-900'>
-      <div className='flex items-center justify-between px-3 py-1 text-[10px] text-neutral-500 dark:text-neutral-400'>
-        <span>{language ?? 'st'}</span>
-        <div className='flex gap-1'>
-          <button
-            onClick={() => void handleCopy()}
-            className='rounded px-1.5 py-0.5 hover:bg-neutral-200 dark:hover:bg-neutral-700'
-          >
-            {copied ? 'Copied' : 'Copy'}
-          </button>
-          {onInsertAtCursor && (
-            <button
-              onClick={() => onInsertAtCursor(code)}
-              className='rounded px-1.5 py-0.5 hover:bg-neutral-200 dark:hover:bg-neutral-700'
-            >
-              Insert
-            </button>
-          )}
-        </div>
-      </div>
-      <div ref={containerRef} className='overflow-x-auto px-3 py-2 font-mono text-xs leading-relaxed' />
-    </div>
-  )
-}
diff --git a/src2/frontend/components/_features/[workspace]/ai-chat/index.ts b/src2/frontend/components/_features/[workspace]/ai-chat/index.ts
deleted file mode 100644
index 007c64acb..000000000
--- a/src2/frontend/components/_features/[workspace]/ai-chat/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { AIChatPanel } from './ai-chat-panel'
diff --git a/src2/frontend/components/_molecules/menu-bar/menus/display.tsx b/src2/frontend/components/_molecules/menu-bar/menus/display.tsx
deleted file mode 100644
index ab7e2913c..000000000
--- a/src2/frontend/components/_molecules/menu-bar/menus/display.tsx
+++ /dev/null
@@ -1,2 +0,0 @@
-// Platform-specific: will be reconciled in step 26
-export const DisplayMenu = () => null
diff --git a/src2/frontend/components/_molecules/menu-bar/menus/edit.tsx b/src2/frontend/components/_molecules/menu-bar/menus/edit.tsx
deleted file mode 100644
index 017cf5e2b..000000000
--- a/src2/frontend/components/_molecules/menu-bar/menus/edit.tsx
+++ /dev/null
@@ -1,2 +0,0 @@
-// Platform-specific: will be reconciled in step 26
-export const EditMenu = () => null
diff --git a/src2/frontend/components/_molecules/menu-bar/menus/file.tsx b/src2/frontend/components/_molecules/menu-bar/menus/file.tsx
deleted file mode 100644
index 8ddffaaf0..000000000
--- a/src2/frontend/components/_molecules/menu-bar/menus/file.tsx
+++ /dev/null
@@ -1,2 +0,0 @@
-// Platform-specific: will be reconciled in step 26
-export const FileMenu = () => null
diff --git a/src2/frontend/components/_molecules/menu-bar/menus/help.tsx b/src2/frontend/components/_molecules/menu-bar/menus/help.tsx
deleted file mode 100644
index c8cd9ff2b..000000000
--- a/src2/frontend/components/_molecules/menu-bar/menus/help.tsx
+++ /dev/null
@@ -1,2 +0,0 @@
-// Platform-specific: will be reconciled in step 26
-export const HelpMenu = () => null
diff --git a/src2/frontend/components/_molecules/menu-bar/menus/recent.tsx b/src2/frontend/components/_molecules/menu-bar/menus/recent.tsx
deleted file mode 100644
index dc360a58a..000000000
--- a/src2/frontend/components/_molecules/menu-bar/menus/recent.tsx
+++ /dev/null
@@ -1,2 +0,0 @@
-// Platform-specific: will be reconciled in step 26
-export const RecentMenu = () => null
diff --git a/src2/frontend/components/_molecules/tabs/index.tsx b/src2/frontend/components/_molecules/tabs/index.tsx
deleted file mode 100644
index 115c9f03d..000000000
--- a/src2/frontend/components/_molecules/tabs/index.tsx
+++ /dev/null
@@ -1,73 +0,0 @@
-import { useRef } from 'react'
-
-import { useOpenPLCStore } from '../../../store'
-import type { TabsProps } from '../../../store/slices/tabs'
-import { Tab } from '../../_atoms/tab'
-import { TabList } from '../../_atoms/tab-list'
-
-const Tabs = () => {
-  const {
-    tabs,
-    editor,
-    tabsActions: { sortTabs, removeTab },
-    editorActions: { setEditor, getEditorFromEditors },
-    fileActions: { removeFile },
-  } = useOpenPLCStore()
-
-  const selectedTab = editor.meta.name
-  const hasTabs = tabs.length > 0
-  const dndTab = useRef<number>(0)
-  const replaceTab = useRef<number>(0)
-
-  const handleRemoveTab = (tabName: string | null) => {
-    if (!tabName) return
-    removeTab(tabName)
-    removeFile({ name: tabName })
-  }
-
-  const handleClickedTab = (tab: TabsProps) => {
-    if (tab.name === selectedTab) return
-    const candidate = getEditorFromEditors(tab.name)
-    if (candidate) {
-      setEditor(candidate)
-    }
-  }
-
-  const handleSortOnDragEnd = () => {
-    const tabsClone = [...tabs]
-    const draggedTab = tabsClone.splice(dndTab.current, 1)[0]
-    tabsClone.splice(replaceTab.current, 0, draggedTab)
-    sortTabs(tabsClone)
-  }
-
-  const handleDragStart = ({ tab, idx }: { tab: TabsProps; idx: number }) => {
-    dndTab.current = idx
-    handleClickedTab(tab)
-  }
-
-  const handleDragEnter = (idx: number) => {
-    replaceTab.current = idx
-  }
-
-  return (
-    <TabList>
-      {hasTabs &&
-        tabs.map((tab, idx) => (
-          <Tab
-            key={tab.name}
-            tab={tab}
-            onClick={() => handleClickedTab(tab)}
-            onClose={() => handleRemoveTab(tab.name)}
-            selected={selectedTab === tab.name}
-            draggable
-            onDragStart={() => handleDragStart({ tab, idx })}
-            onDragEnter={() => handleDragEnter(idx)}
-            onDragEnd={handleSortOnDragEnd}
-            onDragOver={(e) => e.preventDefault()}
-          />
-        ))}
-    </TabList>
-  )
-}
-
-export { Tabs }
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/default/download.tsx b/src2/frontend/components/_molecules/workspace-activity-bar/default/download.tsx
deleted file mode 100644
index 772d0044f..000000000
--- a/src2/frontend/components/_molecules/workspace-activity-bar/default/download.tsx
+++ /dev/null
@@ -1,14 +0,0 @@
-import { DownloadIcon } from '../../../../assets/icons/interface/Download'
-import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
-
-type DownloadButtonProps = { onClick?: () => void }
-
-const DownloadButton = ({ onClick }: DownloadButtonProps) => {
-  return (
-    <ActivityBarButton aria-label='Download' onClick={onClick}>
-      <DownloadIcon />
-    </ActivityBarButton>
-  )
-}
-
-export { DownloadButton }
diff --git a/src2/frontend/components/_organisms/modals/save-changes-file-modal.tsx b/src2/frontend/components/_organisms/modals/save-changes-file-modal.tsx
deleted file mode 100644
index e84b0d3b0..000000000
--- a/src2/frontend/components/_organisms/modals/save-changes-file-modal.tsx
+++ /dev/null
@@ -1,95 +0,0 @@
-import { WarningIcon } from '../../../assets/icons/interface/Warning'
-import { useOpenPLCStore } from '../../../store'
-import { ComponentPropsWithoutRef } from 'react'
-
-import { Modal, ModalContent, ModalTitle } from '../../_molecules/modal'
-
-export type SaveChangesFileModalData = {
-  fileName: string
-  onSave?: () => void
-  onDiscard?: () => void
-}
-
-export type SaveChangesFileModalProps = ComponentPropsWithoutRef<typeof Modal> & {
-  isOpen: boolean
-  data: SaveChangesFileModalData
-}
-
-const SaveChangesFileModal = ({ isOpen, data, ...rest }: SaveChangesFileModalProps) => {
-  const {
-    modalActions: { closeModal, onOpenChange },
-    sharedWorkspaceActions: { forceCloseFile },
-  } = useOpenPLCStore()
-
-  const { fileName } = data
-
-  const handleSave = () => {
-    closeModal()
-    if (data.onSave) {
-      data.onSave()
-    }
-    forceCloseFile(fileName)
-  }
-
-  const handleDontSave = () => {
-    closeModal()
-    if (data.onDiscard) {
-      data.onDiscard()
-    }
-    forceCloseFile(fileName)
-  }
-
-  const handleCancel = () => {
-    closeModal()
-  }
-
-  return (
-    <Modal
-      open={isOpen}
-      onOpenChange={(open) => {
-        if (!open) {
-          handleCancel()
-        }
-        onOpenChange('save-changes-file', open)
-      }}
-      {...rest}
-    >
-      <ModalContent className='flex h-[420px] w-[340px] select-none flex-col items-center justify-evenly rounded-lg'>
-        <ModalTitle className='hidden'>Save file changes</ModalTitle>
-        <div className='flex h-[350px] select-none flex-col items-center gap-6'>
-          <WarningIcon className='mr-2 mt-2 h-[73px] w-[73px]' />
-          <div>
-            <p className='text-m w-full text-center font-bold text-gray-600 dark:text-neutral-100'>
-              <strong>{fileName}</strong> has unsaved changes. Do you want to save before closing?
-            </p>
-          </div>
-
-          <div className='flex w-[300px] flex-col text-sm'>
-            <div className='mb-6 flex flex-col gap-2'>
-              <button
-                onClick={handleSave}
-                className='w-full rounded-lg bg-brand px-4 py-2 text-center font-medium text-white'
-              >
-                Save
-              </button>
-              <button
-                onClick={handleDontSave}
-                className='w-full rounded-lg bg-neutral-100 px-4 py-2 text-center font-medium text-neutral-1000 dark:bg-neutral-850 dark:text-neutral-100'
-              >
-                Don't Save
-              </button>
-            </div>
-            <button
-              onClick={handleCancel}
-              className='w-full rounded-lg bg-neutral-100 px-4 py-2 text-center font-medium text-neutral-1000 dark:bg-neutral-850 dark:text-neutral-100'
-            >
-              Cancel
-            </button>
-          </div>
-        </div>
-      </ModalContent>
-    </Modal>
-  )
-}
-
-export { SaveChangesFileModal }
diff --git a/src2/frontend/components/_organisms/workspace-activity-bar/default.tsx b/src2/frontend/components/_organisms/workspace-activity-bar/default.tsx
deleted file mode 100644
index 9f27fc8b7..000000000
--- a/src2/frontend/components/_organisms/workspace-activity-bar/default.tsx
+++ /dev/null
@@ -1,386 +0,0 @@
-import { StopIcon } from '../../../assets/icons/interface/Stop'
-import { cn } from '../../../utils/cn'
-import { useOpenPLCStore } from '../../../store'
-import type { RuntimeConnection } from '../../../store/slices/device/types'
-import { useCompiler, useRuntime, useSimulator, useDebugger } from '../../../../middleware/shared/providers'
-import { useCallback, useEffect, useRef, useState } from 'react'
-
-import { ChatButton } from '../../_molecules/workspace-activity-bar/default/chat'
-import { DebuggerButton } from '../../_molecules/workspace-activity-bar/default/debugger'
-import { DownloadButton } from '../../_molecules/workspace-activity-bar/default/download'
-import { PlayButton } from '../../_molecules/workspace-activity-bar/default/play'
-import { SearchButton } from '../../_molecules/workspace-activity-bar/default/search'
-import { ZoomButton } from '../../_molecules/workspace-activity-bar/default/zoom'
-import { TooltipSidebarWrapperButton } from '../../_molecules/workspace-activity-bar/tooltip-button'
-
-const showDebuggerMessage = (
-  type: 'info' | 'warning' | 'error' | 'question',
-  title: string,
-  message: string,
-  buttons: string[],
-): Promise<number> => {
-  return new Promise((resolve) => {
-    useOpenPLCStore.getState().modalActions.openModal('debugger-message', {
-      type,
-      title,
-      message,
-      buttons,
-      onResponse: (buttonIndex: number) => resolve(buttonIndex),
-    })
-  })
-}
-
-const disabledButtonClass = 'cursor-not-allowed opacity-50 [&>*:first-child]:hover:bg-transparent'
-
-type DefaultWorkspaceActivityBarProps = {
-  zoom?: {
-    onClick: () => void
-  }
-}
-
-export const DefaultWorkspaceActivityBar = ({ zoom }: DefaultWorkspaceActivityBarProps) => {
-  const {
-    project: { data: projectData, meta: projectMeta },
-    deviceDefinitions,
-    deviceAvailableOptions: { availableBoards },
-    workspace: { editingState },
-    consoleActions: { addLog },
-  } = useOpenPLCStore()
-
-  const compiler = useCompiler()
-  const runtime = useRuntime()
-  const simulator = useSimulator()
-  const debuggerPort = useDebugger()
-
-  const [isCompiling, setIsCompiling] = useState(false)
-  const [isDebuggerProcessing, setIsDebuggerProcessing] = useState(false)
-  const [simulatorRunning, setSimulatorRunning] = useState(false)
-  const pendingSimulatorDebugRef = useRef(false)
-
-  const connectionStatus = useOpenPLCStore((state) => state.runtimeConnection.connectionStatus)
-  const plcStatus = useOpenPLCStore((state): RuntimeConnection['plcStatus'] => state.runtimeConnection.plcStatus)
-  const jwtToken = useOpenPLCStore((state) => state.runtimeConnection.jwtToken)
-  const isDebuggerVisible = useOpenPLCStore((state) => state.workspace.isDebuggerVisible)
-
-  const currentBoardInfo = availableBoards.get(deviceDefinitions.configuration.deviceBoard)
-  const isSimulatorBoard = currentBoardInfo?.compiler === 'simulator'
-
-  // Sync simulatorRunning when the simulator stops externally
-  useEffect(() => {
-    const unsub = simulator.onStopped(() => {
-      pendingSimulatorDebugRef.current = false
-      setSimulatorRunning(false)
-      // Clean up debugger state if it was connected via simulator
-      const { workspace, workspaceActions } = useOpenPLCStore.getState()
-      if (workspace.isDebuggerVisible) {
-        void debuggerPort.disconnect()
-        workspaceActions.setDebuggerVisible(false)
-        workspaceActions.clearDebugState()
-      }
-    })
-    return unsub
-  }, [simulator, debuggerPort])
-
-  const handleBuild = useCallback(async () => {
-    if (isCompiling) return
-    setIsCompiling(true)
-
-    addLog({ id: crypto.randomUUID(), level: 'info', message: 'Build process started' })
-
-    try {
-      const boardTarget = deviceDefinitions.configuration.deviceBoard
-      const projectPath = projectMeta.path
-
-      const result = await compiler.compileProgram(
-        {
-          projectData,
-          boardTarget,
-          projectPath,
-          compileOnly: !isSimulatorBoard,
-        },
-        (event) => {
-          if (event.message) {
-            event.message
-              .trim()
-              .split('\n')
-              .forEach((line) => {
-                addLog({ id: crypto.randomUUID(), level: event.level ?? 'info', message: line })
-              })
-          }
-          if (event.firmwarePath && isSimulatorBoard) {
-            void simulator.loadFirmware(event.firmwarePath).then((loadResult) => {
-              if (loadResult.success) {
-                setSimulatorRunning(true)
-                addLog({ id: crypto.randomUUID(), level: 'info', message: 'Simulator is running.' })
-                if (pendingSimulatorDebugRef.current) {
-                  pendingSimulatorDebugRef.current = false
-                  void connectDebuggerAfterBuild()
-                }
-              } else {
-                pendingSimulatorDebugRef.current = false
-                addLog({
-                  id: crypto.randomUUID(),
-                  level: 'error',
-                  message: `Failed to start simulator: ${loadResult.error ?? 'Unknown error'}`,
-                })
-              }
-            })
-          }
-        },
-      )
-
-      if (!result.success) {
-        addLog({
-          id: crypto.randomUUID(),
-          level: 'error',
-          message: result.error ?? 'Compilation failed',
-        })
-      }
-    } catch (err: unknown) {
-      addLog({
-        id: crypto.randomUUID(),
-        level: 'error',
-        message: `Build error: ${err instanceof Error ? err.message : String(err)}`,
-      })
-    } finally {
-      setIsCompiling(false)
-    }
-  }, [compiler, projectData, projectMeta, deviceDefinitions, isSimulatorBoard, simulator, addLog, isCompiling])
-
-  const handleBuildRef = useRef(handleBuild)
-  handleBuildRef.current = handleBuild
-
-  const connectDebuggerAfterBuild = async () => {
-    const { workspaceActions, consoleActions: logActions } = useOpenPLCStore.getState()
-    const boardTarget = deviceDefinitions.configuration.deviceBoard
-    const projectPath = projectMeta.path
-
-    logActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Connecting debugger...' })
-
-    try {
-      // Read debug file and set up variable mapping
-      const debugFileResult = await debuggerPort.readDebugFile(projectPath, boardTarget)
-      if (!debugFileResult.success || !debugFileResult.content) {
-        logActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'error',
-          message: `Failed to read debug file: ${debugFileResult.error ?? 'No content'}`,
-        })
-        return
-      }
-
-      workspaceActions.setDebugCContent(debugFileResult.content)
-
-      // Connect debugger
-      const connectResult = await debuggerPort.connect()
-      if (!connectResult.success) {
-        logActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'error',
-          message: `Debugger connection failed: ${connectResult.error ?? 'Unknown error'}`,
-        })
-        return
-      }
-
-      workspaceActions.setDebuggerVisible(true)
-      logActions.addLog({ id: crypto.randomUUID(), level: 'info', message: 'Debugger connected.' })
-    } catch (err: unknown) {
-      logActions.addLog({
-        id: crypto.randomUUID(),
-        level: 'error',
-        message: `Debugger error: ${err instanceof Error ? err.message : String(err)}`,
-      })
-    }
-  }
-
-  const handlePlcControl = useCallback(async (): Promise<void> => {
-    if (!jwtToken || connectionStatus !== 'connected') return
-
-    try {
-      if (plcStatus === 'RUNNING') {
-        const result = await runtime.stopPlc()
-        if (!result.success) {
-          addLog({
-            id: crypto.randomUUID(),
-            level: 'error',
-            message: `Failed to stop PLC: ${result.error ?? 'Unknown error'}`,
-          })
-          return
-        }
-      } else {
-        const result = await runtime.startPlc()
-        if (!result.success) {
-          addLog({
-            id: crypto.randomUUID(),
-            level: 'error',
-            message: `Failed to start PLC: ${result.error ?? 'Unknown error'}`,
-          })
-          return
-        }
-      }
-
-      const statusResult = await runtime.getStatus()
-      if (statusResult.success && statusResult.status) {
-        useOpenPLCStore.getState().deviceActions.setPlcRuntimeStatus(
-          statusResult.status as NonNullable<RuntimeConnection['plcStatus']>,
-        )
-      }
-    } catch (error: unknown) {
-      addLog({
-        id: crypto.randomUUID(),
-        level: 'error',
-        message: `PLC control error: ${String(error)}`,
-      })
-    }
-  }, [runtime, jwtToken, connectionStatus, plcStatus, addLog])
-
-  const handleSimulatorControl = useCallback(async (): Promise<void> => {
-    try {
-      if (simulatorRunning) {
-        // Stop: disconnect debugger first, then stop simulator
-        const { workspace, workspaceActions } = useOpenPLCStore.getState()
-        if (workspace.isDebuggerVisible) {
-          await debuggerPort.disconnect()
-          workspaceActions.setDebuggerVisible(false)
-          workspaceActions.clearDebugState()
-        }
-        await simulator.stop()
-        setSimulatorRunning(false)
-        addLog({ id: crypto.randomUUID(), level: 'info', message: 'Simulator stopped.' })
-      } else {
-        // Start: build, load firmware, then auto-connect debugger
-        pendingSimulatorDebugRef.current = true
-        handleBuildRef.current().catch(() => {
-          pendingSimulatorDebugRef.current = false
-        })
-      }
-    } catch (error: unknown) {
-      pendingSimulatorDebugRef.current = false
-      addLog({
-        id: crypto.randomUUID(),
-        level: 'error',
-        message: `Simulator control error: ${String(error)}`,
-      })
-    }
-  }, [simulator, debuggerPort, simulatorRunning, addLog])
-
-  const handleDebuggerClick = useCallback(async () => {
-    if (isDebuggerProcessing) return
-    setIsDebuggerProcessing(true)
-
-    try {
-      const { workspace, workspaceActions } = useOpenPLCStore.getState()
-
-      if (workspace.isDebuggerVisible) {
-        // Disconnect
-        await debuggerPort.disconnect()
-        workspaceActions.setDebuggerVisible(false)
-        workspaceActions.clearDebugState()
-        return
-      }
-
-      // Verify MD5 before connecting
-      const boardTarget = deviceDefinitions.configuration.deviceBoard
-      const projectPath = projectMeta.path
-
-      const md5Result = await debuggerPort.readProgramMd5(projectPath, boardTarget)
-      if (!md5Result.success || !md5Result.md5) {
-        const choice = await showDebuggerMessage(
-          'warning',
-          'Debug Data Not Found',
-          'No debug data found. Would you like to compile the project first?',
-          ['Compile', 'Cancel'],
-        )
-        if (choice === 0) {
-          await handleBuildRef.current()
-        }
-        return
-      }
-
-      const verifyResult = await debuggerPort.verifyMd5(md5Result.md5)
-      if (!verifyResult.success) {
-        const choice = await showDebuggerMessage(
-          'warning',
-          'Program Mismatch',
-          'The running program does not match the compiled program. Do you want to recompile?',
-          ['Recompile', 'Continue Anyway', 'Cancel'],
-        )
-        if (choice === 0) {
-          await handleBuildRef.current()
-          return
-        }
-        if (choice === 2) return
-      }
-
-      await connectDebuggerAfterBuild()
-    } catch (err: unknown) {
-      addLog({
-        id: crypto.randomUUID(),
-        level: 'error',
-        message: `Debugger error: ${err instanceof Error ? err.message : String(err)}`,
-      })
-    } finally {
-      setIsDebuggerProcessing(false)
-    }
-  }, [debuggerPort, deviceDefinitions, projectMeta, isDebuggerProcessing, addLog])
-
-  return (
-    <>
-      <TooltipSidebarWrapperButton tooltipContent='Search'>
-        <SearchButton />
-      </TooltipSidebarWrapperButton>
-      <TooltipSidebarWrapperButton tooltipContent='Open/Close Toolbox'>
-        <ZoomButton {...zoom} />
-      </TooltipSidebarWrapperButton>
-      <TooltipSidebarWrapperButton tooltipContent={isSimulatorBoard ? 'Use Start to build and run' : 'Compile'}>
-        <DownloadButton
-          disabled={isCompiling || isSimulatorBoard}
-          className={cn((isCompiling || isSimulatorBoard) && disabledButtonClass)}
-          onClick={() => void handleBuild()}
-        />
-      </TooltipSidebarWrapperButton>
-      <TooltipSidebarWrapperButton
-        tooltipContent={
-          isSimulatorBoard
-            ? simulatorRunning
-              ? 'Stop Simulator'
-              : 'Start Simulator'
-            : connectionStatus !== 'connected'
-              ? 'Connect to runtime first'
-              : plcStatus === 'RUNNING'
-                ? 'Stop PLC'
-                : 'Start PLC'
-        }
-      >
-        <PlayButton
-          onClick={isSimulatorBoard ? () => void handleSimulatorControl() : () => void handlePlcControl()}
-          disabled={
-            isSimulatorBoard
-              ? isCompiling || isDebuggerProcessing
-              : connectionStatus !== 'connected'
-          }
-          className={cn(
-            isSimulatorBoard
-              ? isCompiling || isDebuggerProcessing
-                ? disabledButtonClass
-                : ''
-              : connectionStatus !== 'connected'
-                ? disabledButtonClass
-                : '',
-          )}
-        >
-          {(isSimulatorBoard ? simulatorRunning : plcStatus === 'RUNNING') ? <StopIcon /> : null}
-        </PlayButton>
-      </TooltipSidebarWrapperButton>
-      <TooltipSidebarWrapperButton tooltipContent={isSimulatorBoard ? 'Use Start to debug' : 'Debugger'}>
-        <DebuggerButton
-          onClick={() => void handleDebuggerClick()}
-          disabled={isDebuggerProcessing || isSimulatorBoard}
-          isActive={isDebuggerVisible}
-          className={cn((isDebuggerProcessing || isSimulatorBoard) && disabledButtonClass)}
-        />
-      </TooltipSidebarWrapperButton>
-      <ChatButton />
-    </>
-  )
-}
diff --git a/src2/frontend/hooks/use-pou-snapshot.ts b/src2/frontend/hooks/use-pou-snapshot.ts
deleted file mode 100644
index 7fbdff8d3..000000000
--- a/src2/frontend/hooks/use-pou-snapshot.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { useCallback } from 'react'
-
-import { useOpenPLCStore } from '../store'
-
-/**
- * Convenience hook wrapping snapshotActions.pushToHistory().
- * Captures the current POU state (variables, body, globalVariables) and pushes it
- * to the undo history in a single call.
- */
-export function usePouSnapshot() {
-  const {
-    project,
-    snapshotActions: { pushToHistory, undo, redo },
-  } = useOpenPLCStore()
-
-  const captureAndPush = useCallback(
-    (pouName: string) => {
-      const pou = project.data.pous.find((p) => p.name === pouName)
-      if (!pou) return
-
-      pushToHistory(pouName, {
-        variables: pou.interface?.variables ?? [],
-        body: pou.body.value,
-        globalVariables: project.data.configurations.resource.globalVariables,
-      })
-    },
-    [project.data.pous, project.data.configurations.resource.globalVariables, pushToHistory],
-  )
-
-  return { captureAndPush, undo, redo }
-}
diff --git a/src2/frontend/hooks/useAI.ts b/src2/frontend/hooks/useAI.ts
deleted file mode 100644
index 252e92a7b..000000000
--- a/src2/frontend/hooks/useAI.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { useQuery } from '@tanstack/react-query'
-import { useCallback, useRef } from 'react'
-
-import { AIRequestError, fetchAICredits, streamAIRequest } from '../services/ai/api-client'
-import type { AIChatRequest, AICompleteRequest } from '../services/ai/types'
-import { useOpenPLCStore } from '../store'
-
-/**
- * Hook for AI inline completion requests.
- * Returns a function that streams completion tokens and collects them into a string.
- */
-export function useAICompletion() {
-  const { setAILoading, setAIError, setCredits } = useOpenPLCStore.useAiActions()
-  const model = useOpenPLCStore.useAi().model
-  const abortRef = useRef<AbortController | null>(null)
-
-  const complete = useCallback(
-    async (request: Omit<AICompleteRequest, 'model'>): Promise<string> => {
-      // Cancel any in-flight request
-      abortRef.current?.abort()
-      const controller = new AbortController()
-      abortRef.current = controller
-
-      setAILoading(true)
-      setAIError(null)
-
-      try {
-        let result = ''
-        const fullRequest: AICompleteRequest = { ...request, model }
-
-        for await (const token of streamAIRequest('/complete', fullRequest, controller.signal)) {
-          result += token
-        }
-
-        // Refresh credits after successful completion
-        try {
-          const credits = await fetchAICredits()
-          setCredits(credits.credits_used, credits.credits_total)
-        } catch {
-          // Non-critical, ignore credit refresh failure
-        }
-
-        return result
-      } catch (error) {
-        if (error instanceof AIRequestError) {
-          setAIError(error.message)
-        } else if ((error as Error).name !== 'AbortError') {
-          setAIError('An unexpected error occurred.')
-        }
-        return ''
-      } finally {
-        setAILoading(false)
-        if (abortRef.current === controller) {
-          abortRef.current = null
-        }
-      }
-    },
-    [model, setAILoading, setAIError, setCredits],
-  )
-
-  const cancel = useCallback(() => {
-    abortRef.current?.abort()
-    abortRef.current = null
-  }, [])
-
-  return { complete, cancel }
-}
-
-/**
- * Hook for AI chat requests.
- * Returns a function that streams chat response tokens via a callback.
- */
-export function useAIChat() {
-  const { setAILoading, setAIError, setCredits } = useOpenPLCStore.useAiActions()
-  const model = useOpenPLCStore.useAi().model
-  const abortRef = useRef<AbortController | null>(null)
-
-  const chat = useCallback(
-    async (request: Omit<AIChatRequest, 'model'>, onToken: (token: string) => void): Promise<void> => {
-      abortRef.current?.abort()
-      const controller = new AbortController()
-      abortRef.current = controller
-
-      setAILoading(true)
-      setAIError(null)
-
-      try {
-        const fullRequest: AIChatRequest = { ...request, model }
-
-        for await (const token of streamAIRequest('/chat', fullRequest, controller.signal)) {
-          onToken(token)
-        }
-
-        // Refresh credits after successful chat
-        try {
-          const credits = await fetchAICredits()
-          setCredits(credits.credits_used, credits.credits_total)
-        } catch {
-          // Non-critical
-        }
-      } catch (error) {
-        if (error instanceof AIRequestError) {
-          setAIError(error.message)
-        } else if ((error as Error).name !== 'AbortError') {
-          setAIError('An unexpected error occurred.')
-        }
-      } finally {
-        setAILoading(false)
-        if (abortRef.current === controller) {
-          abortRef.current = null
-        }
-      }
-    },
-    [model, setAILoading, setAIError, setCredits],
-  )
-
-  const cancel = useCallback(() => {
-    abortRef.current?.abort()
-    abortRef.current = null
-  }, [])
-
-  return { chat, cancel }
-}
-
-/**
- * Hook for fetching AI credit status with caching.
- */
-export function useAICredits() {
-  const { setCredits, setTier, setCurrentPeriodEnd } = useOpenPLCStore.useAiActions()
-  const aiState = useOpenPLCStore.useAi()
-
-  return useQuery({
-    queryKey: ['ai-credits'],
-    queryFn: async ({ signal }) => {
-      const credits = await fetchAICredits(signal)
-      setCredits(credits.credits_used, credits.credits_total)
-      setTier(credits.tier)
-      setCurrentPeriodEnd(credits.current_period_end)
-      return credits
-    },
-    staleTime: 30000,
-    enabled: aiState.isEnabled,
-    refetchOnWindowFocus: true,
-  })
-}
diff --git a/src2/frontend/hooks/useDebugSession.ts b/src2/frontend/hooks/useDebugSession.ts
deleted file mode 100644
index bb638d284..000000000
--- a/src2/frontend/hooks/useDebugSession.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-/**
- * Debug Session Hook
- *
- * Manages the debug session lifecycle: parse debug.c, build index/tree maps,
- * commit debug artifacts to the store, and delegate protocol operations to
- * the debugBridge singleton.
- *
- * This hook is transport-agnostic — it never calls simulatorService or
- * sendDebugMessage directly. The debugBridge handles all transport concerns.
- *
- * Mirrors the desktop editor's session management in debugger-session.ts
- * and workspace-screen.tsx.
- */
-
-import { useCallback, useRef } from 'react'
-
-import { useOpenPLCStore } from '../store'
-import { debugBridge } from '../services/debug/debug-bridge'
-import { parseDebugFile } from '../utils/debug-parser'
-import { hexToBytes } from '../utils/hex'
-import { buildDebugTree } from '../utils/debug-tree-builder'
-import { findInstanceName, buildDebugPathPrefix, type PLCInstanceMapping } from '../utils/debug-variable-finder'
-import { simulatorService } from '../services/simulator/simulator-service'
-import type { DebugTreeNode, FbInstanceInfo } from '../../middleware/shared/ports/types'
-
-export interface UseDebugSessionReturn {
-  /** Parse debug.c, build trees/indexes, commit to store, activate debugger.
-   *  Parameters deviceId/username/password are kept for API compatibility but unused
-   *  by the session hook — the caller sets up the transport on debugBridge first. */
-  startDebug: (deviceId: string, username: string, password: string, debugCContent: string, port?: number) => boolean
-  /** Stop the debug session and clean up all state. */
-  stopDebug: () => void
-  /** Force or release a variable via debugBridge. */
-  forceVariable: (index: number, force: boolean, valueHex?: string) => Promise<boolean>
-  /** Debug tree nodes built for each POU, keyed by pouName. */
-  debugTreesRef: React.MutableRefObject<Record<string, DebugTreeNode[]>>
-}
-
-export function useDebugSession(): UseDebugSessionReturn {
-  const {
-    project: { data: projectData },
-    workspace,
-    workspaceActions,
-    consoleActions,
-  } = useOpenPLCStore()
-
-  const localMd5Ref = useRef<string | null>(null)
-  const debugTreesRef = useRef<Record<string, DebugTreeNode[]>>({})
-
-  /**
-   * Start a debug session: parse debug.c, build index maps, commit to store.
-   * The caller is responsible for setting up the transport on debugBridge first.
-   */
-  const startDebug = useCallback(
-    (...[, , , debugCContent]: [string, string, string, string, number?]): boolean => {
-      if (!debugCContent) {
-        consoleActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'error',
-          message: 'No debug.c content available. Build the project first.',
-        })
-        return false
-      }
-
-      const { editingState } = useOpenPLCStore.getState().workspace
-      if (editingState === 'unsaved') {
-        consoleActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'warning',
-          message: 'Project has unsaved changes. The debugger will use the last compiled version.',
-        })
-      }
-
-      // Parse debug.c to extract variable indexes
-      const parsed = parseDebugFile(debugCContent)
-
-      // Build index map: path -> index
-      const indexMap = new Map<string, number>()
-      for (const v of parsed.variables) {
-        indexMap.set(v.name, v.index)
-      }
-
-      localMd5Ref.current = workspace.debugLocalMd5
-
-      // Build debug trees for each program POU
-      const instances: PLCInstanceMapping[] = (projectData.configurations?.resource?.instances || []).map((inst) => ({
-        name: inst.name,
-        program: inst.program,
-      }))
-
-      const trees: Record<string, DebugTreeNode[]> = {}
-
-      for (const pou of projectData.pous) {
-        if (pou.type !== 'program') continue
-
-        const instanceName = findInstanceName(pou.data.name, instances)
-        if (!instanceName) continue
-
-        const pouTrees: DebugTreeNode[] = []
-
-        for (const variable of pou.data.variables) {
-          const tree = buildDebugTree(variable, pou.data.name, instanceName, parsed.variables, projectData)
-          pouTrees.push(tree)
-        }
-
-        // Add compiler-generated _TMP_ variables (function block/function outputs)
-        // needed for painting block output edges in LD/FBD editors.
-        const instancePrefix = buildDebugPathPrefix(instanceName) + '.'
-        for (const dv of parsed.variables) {
-          if (!dv.name.startsWith(instancePrefix)) continue
-          const localName = dv.name.slice(instancePrefix.length)
-          if (!localName.startsWith('_TMP_')) continue
-
-          let typeName = dv.type
-          if (typeName.endsWith('_O_ENUM') || typeName.endsWith('_P_ENUM')) {
-            typeName = typeName.replace(/_(O|P)_ENUM$/, '')
-          } else if (typeName.endsWith('_ENUM')) {
-            typeName = typeName.replace(/_ENUM$/, '')
-          }
-
-          pouTrees.push({
-            name: localName,
-            fullPath: dv.name,
-            compositeKey: `${pou.data.name}:${localName}`,
-            type: typeName,
-            isComplex: false,
-            debugIndex: dv.index,
-          })
-        }
-
-        trees[pou.data.name] = pouTrees
-      }
-
-      debugTreesRef.current = trees
-
-      // Augment index map with composite keys from the debug tree
-      const addCompositeKeyIndexes = (node: DebugTreeNode) => {
-        if (node.debugIndex !== undefined) {
-          indexMap.set(node.compositeKey, node.debugIndex)
-        }
-        if (node.children) {
-          for (const child of node.children) {
-            addCompositeKeyIndexes(child)
-          }
-        }
-      }
-      for (const pouTrees of Object.values(trees)) {
-        for (const node of pouTrees) {
-          addCompositeKeyIndexes(node)
-        }
-      }
-      workspaceActions.setDebugVariableIndexes(indexMap)
-
-      // Flatten all trees into the store
-      const flatTree = new Map<string, DebugTreeNode>()
-      for (const pouTrees of Object.values(trees)) {
-        for (const node of pouTrees) {
-          flatTree.set(node.compositeKey, node)
-        }
-      }
-      workspaceActions.setDebugVariableTree(flatTree)
-
-      // Build FB instance maps from project data
-      const fbInstances = new Map<string, FbInstanceInfo[]>()
-      for (const pou of projectData.pous) {
-        if (pou.type !== 'function-block') continue
-        const fbTypeName = pou.data.name.toUpperCase()
-        const instanceList: FbInstanceInfo[] = []
-
-        for (const programPou of projectData.pous) {
-          if (programPou.type !== 'program') continue
-          const progInstanceName = findInstanceName(programPou.data.name, instances)
-          if (!progInstanceName) continue
-
-          for (const variable of programPou.data.variables) {
-            if (variable.type.definition === 'derived' && variable.type.value.toUpperCase() === fbTypeName) {
-              const key = `${programPou.data.name}:${variable.name}`
-              instanceList.push({
-                fbTypeName: pou.data.name,
-                programName: programPou.data.name,
-                programInstanceName: progInstanceName,
-                fbVariableName: variable.name,
-                key,
-              })
-            }
-          }
-        }
-
-        if (instanceList.length > 0) {
-          fbInstances.set(fbTypeName, instanceList)
-          workspaceActions.setFbSelectedInstance(fbTypeName, instanceList[0].key)
-        }
-      }
-      workspaceActions.setFbDebugInstances(fbInstances)
-
-      consoleActions.addLog({
-        id: crypto.randomUUID(),
-        level: 'info',
-        message: `Debug session starting: ${parsed.variables.length} variables indexed`,
-      })
-
-      // MD5 verification via debugBridge (transport-agnostic)
-      const localMd5Value = localMd5Ref.current
-      if (localMd5Value) {
-        void debugBridge
-          .verifyMd5(localMd5Value)
-          .then((result) => {
-            if (result.success && result.match === false) {
-              consoleActions.addLog({
-                id: crypto.randomUUID(),
-                level: 'warning',
-                message: `MD5 mismatch. Runtime: ${result.targetMd5}, Local: ${localMd5Value}`,
-              })
-              workspaceActions.setDebugMd5Mismatch({
-                runtimeMd5: result.targetMd5 ?? '',
-                localMd5: localMd5Value,
-              })
-            } else if (result.success) {
-              consoleActions.addLog({
-                id: crypto.randomUUID(),
-                level: 'info',
-                message: 'MD5 verification successful.',
-              })
-            }
-          })
-          .catch(() => {
-            consoleActions.addLog({
-              id: crypto.randomUUID(),
-              level: 'warning',
-              message: 'Could not verify MD5 hash. Continuing anyway.',
-            })
-          })
-      }
-
-      // Activate debugger
-      workspaceActions.setDebuggerVisible(true)
-      return true
-    },
-    [workspace.debugLocalMd5, projectData, workspaceActions, consoleActions],
-  )
-
-  /**
-   * Stop the debug session. Delegates disconnect to debugBridge.
-   */
-  const stopDebug = useCallback(() => {
-    // If simulator is running, stop it
-    if (simulatorService.isRunning()) {
-      simulatorService.stop()
-    }
-
-    // Disconnect transport via bridge
-    void debugBridge.disconnect()
-
-    workspaceActions.clearDebugState()
-    debugTreesRef.current = {}
-    localMd5Ref.current = null
-  }, [workspaceActions])
-
-  /**
-   * Force or release a variable via debugBridge (transport-agnostic).
-   */
-  const forceVariable = useCallback(
-    async (index: number, force: boolean, valueHex = '00'): Promise<boolean> => {
-      const valueBuffer = hexToBytes(valueHex)
-      const result = await debugBridge.setVariable(index, force, force ? valueBuffer : undefined)
-      if (result.success) {
-        consoleActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'info',
-          message: 'Variable force applied successfully',
-        })
-        return true
-      } else {
-        consoleActions.addLog({
-          id: crypto.randomUUID(),
-          level: 'error',
-          message: `Failed to set variable: ${result.error}`,
-        })
-        return false
-      }
-    },
-    [consoleActions],
-  )
-
-  return {
-    startDebug,
-    stopDebug,
-    forceVariable,
-    debugTreesRef,
-  }
-}
diff --git a/src2/frontend/hooks/useWebRTCConnection.ts b/src2/frontend/hooks/useWebRTCConnection.ts
deleted file mode 100644
index 0b6dace1f..000000000
--- a/src2/frontend/hooks/useWebRTCConnection.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-/**
- * WebRTC Connection Hook
- *
- * Thin React bridge over WebRTCConnectionManager. The hook creates a manager
- * instance, keeps its callbacks in sync with React props, and returns stable
- * method references that never change identity (empty dependency arrays).
- */
-
-import { useCallback, useEffect, useRef } from 'react'
-
-import { useOpenPLCStore } from '../store'
-import { WebRTCConnectionManager } from '../services/api/webrtc/webrtc-connection-manager'
-import type { WebRTCConnectionStatus } from '../store/slices/webrtc/types'
-
-export interface UseWebRTCConnectionOptions {
-  deviceId: string
-  deviceName: string
-  agentId: string
-  onStatusChange?: (status: WebRTCConnectionStatus) => void
-  onError?: (error: string) => void
-  onMessage?: (message: unknown) => void
-  onDebugMessage?: (message: unknown) => void
-}
-
-export interface UseWebRTCConnectionReturn {
-  status: WebRTCConnectionStatus
-  sessionId: string | null
-  connect: () => Promise<void>
-  disconnect: () => Promise<void>
-  sendMessage: (message: unknown) => void
-  sendDebugMessage: (message: unknown) => boolean
-  openDebugChannel: () => Promise<boolean>
-  closeDebugChannel: () => void
-}
-
-/**
- * Hook for managing WebRTC connection to a device.
- *
- * All returned methods are stable references (they never change identity),
- * so consumers don't need ref-forwarding workarounds.
- */
-export function useWebRTCConnection(options: UseWebRTCConnectionOptions): UseWebRTCConnectionReturn {
-  const { deviceId, deviceName, agentId, onStatusChange, onError, onMessage, onDebugMessage } = options
-
-  const { session, webrtcActions } = useOpenPLCStore()
-
-  const managerRef = useRef<WebRTCConnectionManager | null>(null)
-
-  // Create / recreate manager when device identity changes.
-  // The effect cleanup disposes the old manager (tears down connection + timers).
-  useEffect(() => {
-    if (!deviceId || !agentId) {
-      // No valid device — dispose any existing manager
-      if (managerRef.current) {
-        managerRef.current.dispose()
-        managerRef.current = null
-      }
-      return
-    }
-
-    managerRef.current = new WebRTCConnectionManager({
-      deviceId,
-      deviceName,
-      agentId,
-      webrtcActions,
-      callbacks: { onStatusChange, onError, onMessage, onDebugMessage },
-    })
-
-    return () => {
-      managerRef.current?.dispose()
-      managerRef.current = null
-    }
-    // Only recreate when the device/agent identity changes.
-    // webrtcActions is stable (defined in the Zustand slice creator).
-    // Callbacks are synced separately below.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [deviceId, agentId])
-
-  // Keep callbacks up to date without recreating the manager.
-  useEffect(() => {
-    managerRef.current?.updateCallbacks({ onStatusChange, onError, onMessage, onDebugMessage })
-  }, [onStatusChange, onError, onMessage, onDebugMessage])
-
-  // --- Stable method references (empty deps → never change identity) ---
-
-  const connect = useCallback(async () => {
-    if (!managerRef.current) throw new Error('WebRTCConnectionManager not initialized')
-    return managerRef.current.connect()
-  }, [])
-
-  const disconnect = useCallback(async () => {
-    if (!managerRef.current) return
-    return managerRef.current.disconnect()
-  }, [])
-
-  const sendMessage = useCallback((message: unknown) => {
-    managerRef.current?.sendMessage(message)
-  }, [])
-
-  const sendDebugMessage = useCallback((message: unknown): boolean => {
-    return managerRef.current?.sendDebugMessage(message) ?? false
-  }, [])
-
-  const openDebugChannel = useCallback((): Promise<boolean> => {
-    return managerRef.current?.openDebugChannel() ?? Promise.resolve(false)
-  }, [])
-
-  const closeDebugChannel = useCallback(() => {
-    managerRef.current?.closeDebugChannel()
-  }, [])
-
-  return {
-    status: session.status,
-    sessionId: session.sessionId,
-    connect,
-    disconnect,
-    sendMessage,
-    sendDebugMessage,
-    openDebugChannel,
-    closeDebugChannel,
-  }
-}
-
-export default useWebRTCConnection
diff --git a/src2/frontend/services/ai/api-client.ts b/src2/frontend/services/ai/api-client.ts
deleted file mode 100644
index 036d3ca13..000000000
--- a/src2/frontend/services/ai/api-client.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-import type { AIChatRequest, AICompleteRequest, AICreditStatus, AISSEEvent, AITelemetryEvent } from './types'
-
-const AI_BASE_URL = `${import.meta.env?.VITE_EDGE_API_URL ?? ''}/ai`
-
-/**
- * Parse a single SSE line into an AISSEEvent.
- * Returns null for non-data lines (comments, empty lines).
- */
-function parseSSELine(line: string): AISSEEvent | null {
-  if (!line.startsWith('data: ')) return null
-  const data = line.slice(6)
-  if (data === '[DONE]') return { type: 'message_stop' }
-  try {
-    return JSON.parse(data) as AISSEEvent
-  } catch {
-    return null
-  }
-}
-
-/**
- * Stream an AI request as an AsyncGenerator of string tokens.
- * Handles SSE parsing, AbortSignal, and error responses (429, 503).
- *
- * @param endpoint - API endpoint path (e.g., '/complete' or '/chat')
- * @param body - Request body
- * @param signal - Optional AbortSignal for cancellation
- * @yields string tokens as they arrive from the stream
- */
-export async function* streamAIRequest(
-  endpoint: string,
-  body: AICompleteRequest | AIChatRequest,
-  signal?: AbortSignal,
-): AsyncGenerator<string, void, unknown> {
-  const response = await fetch(`${AI_BASE_URL}${endpoint}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    credentials: 'include',
-    body: JSON.stringify(body),
-    signal,
-  })
-
-  if (!response.ok) {
-    if (response.status === 429) {
-      const retryAfter = response.headers.get('Retry-After')
-      throw new AIRequestError(
-        'Rate limited. Please wait before trying again.',
-        429,
-        retryAfter ? Number(retryAfter) : undefined,
-      )
-    }
-    if (response.status === 402) {
-      throw new AIRequestError('Credit limit reached.', 402)
-    }
-    if (response.status === 503) {
-      throw new AIRequestError('AI service temporarily unavailable.', 503)
-    }
-    const errorText = await response.text().catch(() => 'Unknown error')
-    throw new AIRequestError(errorText, response.status)
-  }
-
-  const reader = response.body?.getReader()
-  if (!reader) throw new AIRequestError('No response body', 0)
-
-  const decoder = new TextDecoder()
-  let buffer = ''
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-      const lines = buffer.split('\n')
-      // Keep the last potentially incomplete line in the buffer
-      buffer = lines.pop() ?? ''
-
-      for (const line of lines) {
-        const trimmed = line.trim()
-        if (!trimmed) continue
-
-        const event = parseSSELine(trimmed)
-        if (!event) continue
-
-        if (event.type === 'content_block_delta') {
-          yield event.delta
-        } else if (event.type === 'error') {
-          throw new AIRequestError(event.error, 0)
-        } else if (event.type === 'message_stop') {
-          return
-        }
-      }
-    }
-
-    // Flush any remaining data in the buffer after the stream ends
-    const remaining = buffer.trim()
-    if (remaining) {
-      const event = parseSSELine(remaining)
-      if (event) {
-        if (event.type === 'content_block_delta') {
-          yield event.delta
-        } else if (event.type === 'error') {
-          throw new AIRequestError(event.error, 0)
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-/**
- * Fetch AI credit status.
- */
-export async function fetchAICredits(signal?: AbortSignal): Promise<AICreditStatus> {
-  const response = await fetch(`${AI_BASE_URL}/credits`, {
-    method: 'GET',
-    credentials: 'include',
-    signal,
-  })
-
-  if (!response.ok) {
-    throw new AIRequestError('Failed to fetch credits', response.status)
-  }
-
-  return response.json() as Promise<AICreditStatus>
-}
-
-/**
- * Send a telemetry event (fire-and-forget).
- */
-export function sendTelemetry(event: AITelemetryEvent): void {
-  fetch(`${AI_BASE_URL}/telemetry`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    credentials: 'include',
-    body: JSON.stringify(event),
-  }).catch(() => {
-    // Telemetry is best-effort, silently ignore failures
-  })
-}
-
-/**
- * Custom error class for AI request failures.
- */
-export class AIRequestError extends Error {
-  constructor(
-    message: string,
-    public readonly status: number,
-    public readonly retryAfter?: number,
-  ) {
-    super(message)
-    this.name = 'AIRequestError'
-  }
-}
diff --git a/src2/frontend/services/ai/completion-cache.ts b/src2/frontend/services/ai/completion-cache.ts
deleted file mode 100644
index 95fd7f458..000000000
--- a/src2/frontend/services/ai/completion-cache.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * LRU completion cache for AI inline completions.
- * Serves instant results on undo/redo or cursor repositioning.
- */
-export class CompletionCache<V> {
-  private readonly maxSize: number
-  private readonly cache = new Map<string, V>()
-
-  constructor(maxSize = 16) {
-    this.maxSize = maxSize
-  }
-
-  get(key: string): V | undefined {
-    const value = this.cache.get(key)
-    if (value === undefined) return undefined
-
-    // Move to end (most recently used)
-    this.cache.delete(key)
-    this.cache.set(key, value)
-    return value
-  }
-
-  set(key: string, value: V): void {
-    // If key exists, delete so it moves to end
-    if (this.cache.has(key)) {
-      this.cache.delete(key)
-    }
-
-    // Evict least recently used if at capacity
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value
-      if (firstKey !== undefined) {
-        this.cache.delete(firstKey)
-      }
-    }
-
-    this.cache.set(key, value)
-  }
-
-  has(key: string): boolean {
-    return this.cache.has(key)
-  }
-
-  clear(): void {
-    this.cache.clear()
-  }
-
-  get size(): number {
-    return this.cache.size
-  }
-}
-
-/**
- * Build a cache key from file URI and cursor offset.
- * Uses a hash of the prefix text for deduplication.
- */
-export function buildCacheKey(fileUri: string, offset: number, prefixHash: string): string {
-  return `${fileUri}:${offset}:${prefixHash}`
-}
-
-/**
- * Simple string hash for cache key generation.
- * Uses djb2 algorithm — fast and good enough for cache keys.
- */
-export function hashString(str: string): string {
-  let hash = 5381
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash * 33) ^ str.charCodeAt(i)
-  }
-  return (hash >>> 0).toString(36)
-}
diff --git a/src2/frontend/services/ai/context-collector.ts b/src2/frontend/services/ai/context-collector.ts
deleted file mode 100644
index 0da2168e1..000000000
--- a/src2/frontend/services/ai/context-collector.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import type { openPLCStoreBase } from '../../store'
-
-type StoreState = ReturnType<typeof openPLCStoreBase.getState>
-
-/**
- * Collect project-level context for AI completion requests.
- * Gathers variables, globals, referenced FBs, data types, and sibling POUs
- * in priority order, truncating to fit within the token budget.
- *
- * ~4 chars ≈ 1 token, so maxChars = maxTokenBudget * 4
- */
-export function collectProjectContext(state: StoreState, currentPouName: string, maxTokenBudget: number): string {
-  const maxChars = maxTokenBudget * 4
-  const pous = state.project.data.pous
-  const pou = pous.find((p) => p.data.name === currentPouName)
-  if (!pou) return ''
-
-  const sections: string[] = []
-  let totalLength = 0
-
-  const addSection = (content: string): boolean => {
-    if (totalLength + content.length > maxChars) return false
-    sections.push(content)
-    totalLength += content.length
-    return true
-  }
-
-  // 1. Current POU variables (always included — most important context)
-  if (pou.data.variables.length > 0) {
-    const varLines = pou.data.variables
-      .map((v) => {
-        const cls = v.class ? `${v.class} ` : ''
-        return `  ${cls}${v.name} : ${v.type.value};`
-      })
-      .join('\n')
-    addSection(`(* Current POU: ${pou.data.name} [${pou.type}] *)\nVAR\n${varLines}\nEND_VAR`)
-  }
-
-  // 2. Global variables
-  const globals = state.project.data.configuration.resource['global-variables']
-  if (globals && globals.length > 0) {
-    const globalLines = globals.map((v) => `  ${v.name} : ${v.type.value};`).join('\n')
-    addSection(`(* Global Variables *)\nVAR_GLOBAL\n${globalLines}\nEND_VAR`)
-  }
-
-  // 3. Referenced function blocks — signatures only
-  const derivedTypeNames = pou.data.variables
-    .filter((v) => v.type.definition === 'user-data-type')
-    .map((v) => v.type.value)
-
-  if (derivedTypeNames.length > 0) {
-    const fbPous = pous.filter((p) => p.type === 'function-block' && derivedTypeNames.includes(p.data.name))
-    if (fbPous.length > 0) {
-      const fbSigs = fbPous.map((fb) => {
-        const vars = fb.data.variables
-          .filter((v) => v.class === 'input' || v.class === 'output' || v.class === 'inOut')
-          .map((v) => `${v.class?.toUpperCase()} ${v.name} : ${v.type.value}`)
-          .join(', ')
-        return `FUNCTION_BLOCK ${fb.data.name} (* ${vars} *)`
-      })
-      addSection(`(* Referenced Function Blocks *)\n${fbSigs.join('\n')}`)
-    }
-  }
-
-  // 4. User-defined data types
-  const dataTypes = state.project.data.dataTypes
-  if (dataTypes.length > 0) {
-    const dtLines = dataTypes
-      .slice(0, 10)
-      .map((dt) => {
-        if (dt.derivation === 'enumeration') {
-          return `TYPE ${dt.name} : (${dt.values.map((v) => v.value).join(', ')}); END_TYPE`
-        }
-        if (dt.derivation === 'structure') {
-          const fields = dt.variable.map((v) => `${v.name} : ${v.type.value}`).join('; ')
-          return `TYPE ${dt.name} : STRUCT ${fields}; END_STRUCT; END_TYPE`
-        }
-        if (dt.derivation === 'array') {
-          return `TYPE ${dt.name} : ARRAY [${dt.dimensions.map((d) => `${d.lower}..${d.upper}`).join(', ')}] OF ${dt.baseType.value}; END_TYPE`
-        }
-        return ''
-      })
-      .filter(Boolean)
-
-    if (dtLines.length > 0) {
-      addSection(`(* User Data Types *)\n${dtLines.join('\n')}`)
-    }
-  }
-
-  // 5. Sibling POU signatures (limited to 5)
-  const siblings = pous
-    .filter((p) => p.data.name !== currentPouName)
-    .slice(0, 5)
-    .map((p) => {
-      const params = p.data.variables
-        .filter((v) => v.class === 'input' || v.class === 'output')
-        .map((v) => `${v.class?.toUpperCase()} ${v.name} : ${v.type.value}`)
-        .join(', ')
-      return `${p.type.toUpperCase()} ${p.data.name}${params ? ` (* ${params} *)` : ''}`
-    })
-
-  if (siblings.length > 0) {
-    addSection(`(* Other POUs *)\n${siblings.join('\n')}`)
-  }
-
-  return sections.join('\n\n')
-}
diff --git a/src2/frontend/services/ai/index.ts b/src2/frontend/services/ai/index.ts
deleted file mode 100644
index 24fde1e95..000000000
--- a/src2/frontend/services/ai/index.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-export { AIRequestError, fetchAICredits, sendTelemetry, streamAIRequest } from './api-client'
-export { CompletionCache, buildCacheKey, hashString } from './completion-cache'
-export { collectProjectContext } from './context-collector'
-export {
-  startTimer,
-  trackChatMessage,
-  trackChatRating,
-  trackCompletionAccepted,
-  trackCompletionDismissed,
-  trackCompletionError,
-  trackCompletionRequested,
-  trackCompletionShown,
-  trackCompletionTimeout,
-} from './telemetry'
-export type { TelemetryTimer } from './telemetry'
-export type {
-  AIChatMessage,
-  AIChatRequest,
-  AICompleteRequest,
-  AICreditStatus,
-  AIErrorResponse,
-  AISSEEvent,
-  AITelemetryEvent,
-  AITelemetryEventName,
-} from './types'
diff --git a/src2/frontend/services/ai/telemetry.ts b/src2/frontend/services/ai/telemetry.ts
deleted file mode 100644
index d0931b40c..000000000
--- a/src2/frontend/services/ai/telemetry.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { sendTelemetry } from './api-client'
-import type { AITelemetryEventName } from './types'
-
-/**
- * Tracks an AI telemetry event with automatic timestamp enrichment.
- * All events are fire-and-forget — failures are silently ignored.
- */
-function track(event: AITelemetryEventName, data: Record<string, unknown>): void {
-  sendTelemetry({
-    event,
-    data: {
-      ...data,
-      timestamp: Date.now(),
-    },
-  })
-}
-
-/** A timing handle returned by `startTimer()` to measure elapsed time. */
-export type TelemetryTimer = {
-  /** Elapsed milliseconds since the timer was started. */
-  elapsed: () => number
-}
-
-/**
- * Start a high-resolution timer for measuring durations (e.g., time-to-first-token).
- * Uses `performance.now()` for sub-millisecond precision.
- */
-export function startTimer(): TelemetryTimer {
-  const start = performance.now()
-  return { elapsed: () => Math.round(performance.now() - start) }
-}
-
-/** Track that an inline completion was requested from the backend. */
-export function trackCompletionRequested(data: {
-  language: string
-  model: string
-  prefixLength: number
-  suffixLength: number
-  hasProjectContext: boolean
-}): void {
-  track('completion_requested', data)
-}
-
-/** Track that an inline completion was shown to the user (ghost text displayed). */
-export function trackCompletionShown(data: {
-  language: string
-  model: string
-  completionLength: number
-  latencyMs: number
-  source: 'network' | 'cache' | 'recycled'
-  /** Time-to-first-token in ms (only present for network requests). */
-  ttftMs?: number
-}): void {
-  track('completion_shown', data)
-}
-
-/** Track that the user accepted an inline completion (Tab/Enter). */
-export function trackCompletionAccepted(data: { language: string; completionLength: number }): void {
-  track('completion_accepted', data)
-}
-
-/** Track that the user dismissed an inline completion (Escape or kept typing). */
-export function trackCompletionDismissed(data: {
-  language: string
-  completionLength: number
-  shownDurationMs: number
-}): void {
-  track('completion_dismissed', data)
-}
-
-/** Track that an inline completion request failed. */
-export function trackCompletionError(data: {
-  language: string
-  model: string
-  errorType: string
-  statusCode?: number
-  latencyMs: number
-}): void {
-  track('completion_error', data)
-}
-
-/** Track that an inline completion request timed out. */
-export function trackCompletionTimeout(data: { language: string; model: string; timeoutMs: number }): void {
-  track('completion_timeout', data)
-}
-
-/** Track that a chat message was sent. */
-export function trackChatMessage(data: {
-  language: string
-  model: string
-  messageCount: number
-  pouName: string | null
-}): void {
-  track('chat_message', data)
-}
-
-/** Track that a chat response was rated. */
-export function trackChatRating(data: { messageId: string; rating: 'up' | 'down'; language: string }): void {
-  track('chat_rating', data)
-}
diff --git a/src2/frontend/services/ai/types.ts b/src2/frontend/services/ai/types.ts
deleted file mode 100644
index e42edb3fa..000000000
--- a/src2/frontend/services/ai/types.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-/** AI completion request sent to Edge API */
-export type AICompleteRequest = {
-  /** Code before cursor position */
-  prefix: string
-  /** Code after cursor position */
-  suffix: string
-  /** Programming language identifier */
-  language: 'st' | 'il' | 'python' | 'cpp'
-  /** Additional project context (variables, globals, referenced FBs) */
-  projectContext?: string
-  /** AI model to use */
-  model?: 'haiku' | 'sonnet'
-  /** Maximum tokens to generate */
-  maxTokens?: number
-}
-
-/** AI chat request sent to Edge API */
-export type AIChatRequest = {
-  /** Conversation messages */
-  messages: AIChatMessage[]
-  /** Current POU context */
-  pouContext?: string
-  /** Programming language of the current POU */
-  language?: 'st' | 'il' | 'python' | 'cpp' | 'ld' | 'fbd'
-  /** AI model to use */
-  model?: 'haiku' | 'sonnet'
-}
-
-/** Chat message format for API requests */
-export type AIChatMessage = {
-  role: 'user' | 'assistant'
-  content: string
-}
-
-/** SSE event types from the streaming API */
-export type AISSEEvent =
-  | { type: 'content_block_delta'; delta: string }
-  | { type: 'message_stop' }
-  | { type: 'error'; error: string }
-
-/** Credit status response from /api/ai/credits */
-export type AICreditStatus = {
-  credits_used: number
-  credits_total: number
-  tier: 'free' | 'pro'
-  current_period_end: string | null
-}
-
-/** All trackable telemetry event names */
-export type AITelemetryEventName =
-  | 'completion_requested'
-  | 'completion_shown'
-  | 'completion_accepted'
-  | 'completion_dismissed'
-  | 'completion_error'
-  | 'completion_timeout'
-  | 'chat_message'
-  | 'chat_rating'
-
-/** Telemetry event sent to /api/ai/telemetry */
-export type AITelemetryEvent = {
-  event: AITelemetryEventName
-  data: Record<string, unknown>
-}
-
-/** Error response from AI endpoints */
-export type AIErrorResponse = {
-  error: string
-  retry_after?: number
-}
diff --git a/src2/frontend/services/api/axios.ts b/src2/frontend/services/api/axios.ts
deleted file mode 100644
index 23cf65acf..000000000
--- a/src2/frontend/services/api/axios.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import axios, { AxiosError, InternalAxiosRequestConfig } from 'axios'
-
-const baseURL = import.meta.env?.VITE_EDGE_API_URL || 'http://localhost:3333'
-
-export const api = axios.create({
-  baseURL,
-  timeout: 30000,
-  withCredentials: true, // Required for cross-origin cookie handling
-  headers: {
-    'Content-Type': 'application/json',
-  },
-})
-
-// Request interceptor
-api.interceptors.request.use(
-  (config: InternalAxiosRequestConfig) => {
-    const fullURL = `${config.baseURL || ''}${config.url || ''}`
-    const cookies = typeof document !== 'undefined' ? document.cookie : 'unavailable'
-    const hasCookies = cookies && cookies.length > 0
-    const hasAccessTokenCookie = cookies.includes('accessToken=')
-
-    console.log('[Auth Debug] Axios Request Interceptor:', {
-      method: config.method?.toUpperCase(),
-      url: config.url,
-      baseURL: config.baseURL,
-      fullURL,
-      withCredentials: config.withCredentials,
-      hasCookies,
-      hasAccessTokenCookie,
-      cookiePreview: hasAccessTokenCookie ? cookies.substring(0, 100) + '...' : 'no accessToken cookie found',
-      authHeader: config.headers?.Authorization ? 'present (SHOULD NOT BE!)' : 'none (correct)',
-    })
-
-    return config
-  },
-  (error: AxiosError) => {
-    console.error('[Auth Debug] Request interceptor error:', error)
-    return Promise.reject(error)
-  },
-)
-
-// Response interceptor
-api.interceptors.response.use(
-  (response) => response,
-  (error: AxiosError) => {
-    if (error.response) {
-      const { status } = error.response
-
-      if (status === 401) {
-        // Handle unauthorized - could redirect to login or clear tokens
-        console.error('Unauthorized request')
-      }
-
-      if (status === 500) {
-        console.error('Server error')
-      }
-    }
-
-    return Promise.reject(error)
-  },
-)
-
-export default api
diff --git a/src2/frontend/services/api/debug-transport.ts b/src2/frontend/services/api/debug-transport.ts
deleted file mode 100644
index fdb00c434..000000000
--- a/src2/frontend/services/api/debug-transport.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Debug Transport -- HTTP fallback for debug commands
- *
- * When WebRTC DataChannel is unavailable, debug commands are sent via
- * the run_command HTTP endpoint with api="debug". The agent's
- * DebugSessionManager routes these to persistent Socket.IO sessions.
- */
-
-import { api } from './axios'
-
-/** Polling interval when using WebRTC debug DataChannel (fast, low latency). */
-export const WEBRTC_POLL_INTERVAL_MS = 200
-
-/** Polling interval when using HTTP via Edge API (slower, avoids server overload). */
-export const HTTP_POLL_INTERVAL_MS = 2000
-
-/**
- * Send a debug command via the HTTP run_command endpoint.
- *
- * Wraps the debug message in a run_command payload with api="debug"
- * and extracts the debug_response from the response.
- *
- * @param agentId - The orchestrator agent ID
- * @param deviceId - The runtime device ID
- * @param debugMessage - The debug message (same schema as WebRTC DataChannel)
- * @returns The debug response, or null on error
- */
-export async function sendDebugCommandViaHttp(
-  agentId: string,
-  deviceId: string,
-  debugMessage: Record<string, unknown>,
-): Promise<Record<string, unknown> | null> {
-  try {
-    const { data: result } = await api.post('/orchestrators/run-command', {
-      agent_id: agentId,
-      device_id: deviceId,
-      method: 'POST',
-      api: 'debug',
-      data: debugMessage,
-    })
-
-    const response = result.response
-    if (response?.status === 'success' && response.debug_response) {
-      return response.debug_response as Record<string, unknown>
-    }
-
-    if (response?.status === 'error') {
-      console.error('[DebugTransport] Agent returned error:', response.debug_response ?? response)
-      return response.debug_response as Record<string, unknown> | null
-    }
-
-    return null
-  } catch (err) {
-    console.error('[DebugTransport] HTTP debug command failed:', err)
-    return null
-  }
-}
diff --git a/src2/frontend/services/api/webrtc/index.ts b/src2/frontend/services/api/webrtc/index.ts
deleted file mode 100644
index 50cc43181..000000000
--- a/src2/frontend/services/api/webrtc/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './webrtc-signaling'
-export * from './webrtc-command'
-export { WebRTCConnectionManager } from './webrtc-connection-manager'
-export type { WebRTCManagerConfig, WebRTCManagerCallbacks } from './webrtc-connection-manager'
diff --git a/src2/frontend/services/api/webrtc/webrtc-chunked-message.ts b/src2/frontend/services/api/webrtc/webrtc-chunked-message.ts
deleted file mode 100644
index 1d5fb8ad2..000000000
--- a/src2/frontend/services/api/webrtc/webrtc-chunked-message.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-/**
- * WebRTC Chunked Message Protocol
- *
- * Transparently splits large messages into chunks for WebRTC data channel
- * transmission (which has a ~16KB per-message limit). Small messages are
- * sent directly with zero overhead.
- *
- * Chunk protocol:
- *   { type: "chunk_start", transfer_id, total_chunks, total_size }
- *   { type: "chunk_data",  transfer_id, sequence, data }
- *   { type: "chunk_end",   transfer_id }
- */
-
-/** Messages smaller than this (bytes) are sent directly */
-const CHUNK_THRESHOLD = 15_000
-
-/** Max payload per chunk_data message (bytes, leaves room for JSON wrapper) */
-const CHUNK_PAYLOAD_SIZE = 14_000
-
-/** Resume sending when bufferedAmount drops below this */
-const BUFFER_LOW_WATER_MARK = 65_536
-
-/** Safety limits to prevent memory exhaustion from malformed/buggy messages */
-const MAX_TOTAL_CHUNKS = 10_000
-const MAX_TOTAL_SIZE = 100_000_000 // 100 MB
-
-let transferCounter = 0
-
-function nextTransferId(): string {
-  transferCounter = (transferCounter + 1) % 1_000_000
-  return `${Date.now()}-${transferCounter}`
-}
-
-/**
- * Send a message string over a WebRTC data channel, automatically chunking
- * if the payload exceeds CHUNK_THRESHOLD.
- */
-export async function sendChunkedMessage(channel: RTCDataChannel, message: string): Promise<void> {
-  if (message.length < CHUNK_THRESHOLD) {
-    channel.send(message)
-    return
-  }
-
-  const transferId = nextTransferId()
-  const totalChunks = Math.ceil(message.length / CHUNK_PAYLOAD_SIZE)
-
-  // Send chunk_start
-  channel.send(
-    JSON.stringify({
-      type: 'chunk_start',
-      transfer_id: transferId,
-      total_chunks: totalChunks,
-      total_size: message.length,
-    }),
-  )
-
-  // Send chunk_data with backpressure management
-  for (let seq = 0; seq < totalChunks; seq++) {
-    const start = seq * CHUNK_PAYLOAD_SIZE
-    const data = message.slice(start, start + CHUNK_PAYLOAD_SIZE)
-
-    // Wait for buffer to drain if it's getting full
-    if (channel.bufferedAmount > BUFFER_LOW_WATER_MARK) {
-      await waitForBufferDrain(channel)
-    }
-
-    channel.send(
-      JSON.stringify({
-        type: 'chunk_data',
-        transfer_id: transferId,
-        sequence: seq,
-        data,
-      }),
-    )
-  }
-
-  // Send chunk_end
-  channel.send(
-    JSON.stringify({
-      type: 'chunk_end',
-      transfer_id: transferId,
-    }),
-  )
-}
-
-/**
- * Wait for the data channel's send buffer to drain below the low-water mark.
- */
-function waitForBufferDrain(channel: RTCDataChannel): Promise<void> {
-  return new Promise<void>((resolve) => {
-    channel.bufferedAmountLowThreshold = BUFFER_LOW_WATER_MARK
-    const onBufferLow = () => {
-      channel.removeEventListener('bufferedamountlow', onBufferLow)
-      resolve()
-    }
-    channel.addEventListener('bufferedamountlow', onBufferLow)
-
-    // Safety: if buffer is already below threshold, resolve immediately
-    if (channel.bufferedAmount <= BUFFER_LOW_WATER_MARK) {
-      channel.removeEventListener('bufferedamountlow', onBufferLow)
-      resolve()
-    }
-  })
-}
-
-interface InFlightTransfer {
-  chunks: string[]
-  received: number
-  totalChunks: number
-  totalSize: number
-  startedAt: number
-}
-
-/**
- * Reassembles chunked messages received over a WebRTC data channel.
- *
- * Feed each incoming parsed message via `handleChunkMessage()`.
- * Returns the complete reassembled string when `chunk_end` arrives,
- * or `null` if the message is a partial chunk.
- */
-export class ChunkReassembler {
-  private transfers = new Map<string, InFlightTransfer>()
-
-  /**
-   * Returns true if the message type is a chunk protocol message.
-   */
-  isChunkMessage(msgType: string): boolean {
-    return msgType === 'chunk_start' || msgType === 'chunk_data' || msgType === 'chunk_end'
-  }
-
-  /**
-   * Process a chunk protocol message.
-   *
-   * @returns The fully reassembled message string when complete, or null if still accumulating.
-   */
-  handleChunkMessage(msg: { type: string; transfer_id: string; [key: string]: unknown }): string | null {
-    const transferId = msg.transfer_id
-
-    if (msg.type === 'chunk_start') {
-      const totalChunks = msg.total_chunks as number
-      const totalSize = msg.total_size as number
-
-      if (totalChunks <= 0 || totalChunks > MAX_TOTAL_CHUNKS || totalSize <= 0 || totalSize > MAX_TOTAL_SIZE) {
-        console.warn(
-          `[WebRTC] Rejecting chunk transfer ${transferId}: invalid bounds (chunks=${totalChunks}, size=${totalSize})`,
-        )
-        return null
-      }
-
-      this.transfers.set(transferId, {
-        chunks: new Array(totalChunks),
-        received: 0,
-        totalChunks,
-        totalSize,
-        startedAt: Date.now(),
-      })
-      return null
-    }
-
-    if (msg.type === 'chunk_data') {
-      const transfer = this.transfers.get(transferId)
-      if (!transfer) {
-        console.warn(`[WebRTC] Received chunk_data for unknown transfer: ${transferId}`)
-        return null
-      }
-      const sequence = msg.sequence as number
-      if (sequence < 0 || sequence >= transfer.totalChunks) {
-        console.warn(
-          `[WebRTC] Out-of-range sequence ${sequence} for transfer ${transferId} (totalChunks=${transfer.totalChunks})`,
-        )
-        return null
-      }
-      if (transfer.chunks[sequence] === undefined) {
-        transfer.received++
-      }
-      transfer.chunks[sequence] = msg.data as string
-      return null
-    }
-
-    if (msg.type === 'chunk_end') {
-      const transfer = this.transfers.get(transferId)
-      if (!transfer) {
-        console.warn(`[WebRTC] Received chunk_end for unknown transfer: ${transferId}`)
-        return null
-      }
-
-      this.transfers.delete(transferId)
-
-      if (transfer.received !== transfer.totalChunks) {
-        console.warn(
-          `[WebRTC] Incomplete chunk transfer ${transferId}: expected ${transfer.totalChunks} chunks, received ${transfer.received}`,
-        )
-        return null
-      }
-
-      const assembled = transfer.chunks.join('')
-      return assembled
-    }
-
-    return null
-  }
-
-  /**
-   * Clean up any stale transfers older than the given timeout (ms).
-   */
-  cleanupStale(timeoutMs: number = 60_000): void {
-    const now = Date.now()
-    for (const [id, transfer] of this.transfers) {
-      if (now - transfer.startedAt > timeoutMs) {
-        console.warn(`[WebRTC] Cleaning up stale chunk transfer: ${id}`)
-        this.transfers.delete(id)
-      }
-    }
-  }
-}
diff --git a/src2/frontend/services/api/webrtc/webrtc-command.ts b/src2/frontend/services/api/webrtc/webrtc-command.ts
deleted file mode 100644
index cc12379e0..000000000
--- a/src2/frontend/services/api/webrtc/webrtc-command.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-/**
- * WebRTC Command Service
- *
- * Sends commands over WebRTC data channel with correlation ID matching.
- * Used as primary transport when WebRTC is connected, with HTTP fallback.
- */
-
-import { useOpenPLCStore } from '../../../store'
-
-import { sendChunkedMessage } from './webrtc-chunked-message'
-
-interface PendingRequest {
-  resolve: (response: CommandResponse) => void
-  reject: (error: Error) => void
-  timeout: number
-}
-
-export interface CommandResponse {
-  type: 'command_response'
-  correlation_id: number
-  status: 'success' | 'error'
-  http_response?: {
-    status_code: number
-    headers: Record<string, string>
-    body: unknown
-    ok: boolean
-    content_type: string
-  }
-  error?: string
-}
-
-export interface RunCommandPayload {
-  device_id: string
-  method: string
-  api: string
-  port?: number
-  headers?: Record<string, string>
-  data?: Record<string, unknown>
-  params?: Record<string, string>
-  files?: Record<string, unknown>
-}
-
-// Store for pending requests awaiting responses
-const pendingRequests = new Map<number, PendingRequest>()
-let correlationCounter = 0
-
-// Reference to the data channel (set by useWebRTCConnection)
-let dataChannelRef: RTCDataChannel | null = null
-
-/**
- * Set the data channel reference for sending commands.
- * Called by useWebRTCConnection when channel opens/closes.
- */
-export function setDataChannel(channel: RTCDataChannel | null): void {
-  dataChannelRef = channel
-  if (!channel) {
-    // Clear any pending requests when channel is unregistered
-    for (const pending of pendingRequests.values()) {
-      clearTimeout(pending.timeout)
-      pending.reject(new Error('WebRTC data channel closed'))
-    }
-    pendingRequests.clear()
-  }
-}
-
-/**
- * Generate a unique correlation ID for request/response matching.
- */
-export function generateCorrelationId(): number {
-  correlationCounter = (correlationCounter + 1) % 1000000
-  return Date.now() * 1000 + correlationCounter
-}
-
-/**
- * Handle incoming command response from the agent.
- * Called by useWebRTCConnection when receiving command_response messages.
- */
-export function handleCommandResponse(message: CommandResponse): void {
-  const pending = pendingRequests.get(message.correlation_id)
-  if (pending) {
-    clearTimeout(pending.timeout)
-    pendingRequests.delete(message.correlation_id)
-    pending.resolve(message)
-  } else {
-    console.warn('[WebRTC Command] Received response for unknown correlation_id:', message.correlation_id)
-  }
-}
-
-/**
- * Send a command over the WebRTC data channel.
- *
- * @param command - The command payload
- * @param timeoutMs - Timeout in milliseconds (default: 30000)
- * @returns Promise that resolves with the command response
- * @throws Error if data channel not available or timeout
- */
-export async function sendCommandViaWebRTC(
-  command: RunCommandPayload,
-  timeoutMs: number = 30000,
-): Promise<CommandResponse> {
-  if (!dataChannelRef || dataChannelRef.readyState !== 'open') {
-    throw new Error('WebRTC data channel not available')
-  }
-
-  const correlationId = generateCorrelationId()
-
-  const message = JSON.stringify({
-    type: 'run_command',
-    correlation_id: correlationId,
-    ...command,
-  })
-
-  // Set up response listener before sending to avoid race conditions
-  const responsePromise = new Promise<CommandResponse>((resolve, reject) => {
-    const timeout = window.setTimeout(() => {
-      pendingRequests.delete(correlationId)
-      reject(new Error('WebRTC command timeout'))
-    }, timeoutMs)
-
-    pendingRequests.set(correlationId, { resolve, reject, timeout })
-  })
-
-  try {
-    await sendChunkedMessage(dataChannelRef, message)
-  } catch (err) {
-    // Clean up pending request if send fails
-    const pending = pendingRequests.get(correlationId)
-    if (pending) {
-      clearTimeout(pending.timeout)
-      pendingRequests.delete(correlationId)
-    }
-    throw err
-  }
-
-  return responsePromise
-}
-
-/**
- * Check if WebRTC is connected to the specified orchestrator agent.
- *
- * @param agentId - The orchestrator agent ID to check
- * @returns true if connected to the specified agent
- */
-export function isWebRTCConnectedToAgent(agentId: string): boolean {
-  const { session } = useOpenPLCStore.getState()
-  return session.status === 'connected' && session.agentId === agentId
-}
-
-/**
- * Check if WebRTC data channel is currently available.
- */
-export function isWebRTCChannelAvailable(): boolean {
-  return dataChannelRef !== null && dataChannelRef.readyState === 'open'
-}
diff --git a/src2/frontend/services/api/webrtc/webrtc-connection-manager.ts b/src2/frontend/services/api/webrtc/webrtc-connection-manager.ts
deleted file mode 100644
index 67b0a8c27..000000000
--- a/src2/frontend/services/api/webrtc/webrtc-connection-manager.ts
+++ /dev/null
@@ -1,681 +0,0 @@
-/**
- * WebRTC Connection Manager
- *
- * A plain TypeScript class that owns the full WebRTC connection lifecycle:
- * - RTCPeerConnection creation with STUN configuration
- * - Data channel management (main + debug)
- * - SDP offer/answer exchange via the signaling service
- * - ICE candidate exchange
- * - Keep-alive ping/pong
- * - Reconnection state machine (3 attempts with 40s ICE timeout)
- *
- * This class has zero React dependencies. A thin hook (`useWebRTCConnection`)
- * creates an instance and bridges it to React state.
- */
-
-import type { WebRTCActions, WebRTCConnectionStatus } from '../../../store/slices/webrtc/types'
-
-import {
-  closeWebRTCSession,
-  createWebRTCSession,
-  sendIceCandidate,
-  subscribeToIceCandidates,
-} from './webrtc-signaling'
-import { setDataChannel, handleCommandResponse } from './webrtc-command'
-import { ChunkReassembler } from './webrtc-chunked-message'
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface WebRTCManagerCallbacks {
-  onStatusChange?: (status: WebRTCConnectionStatus) => void
-  onError?: (error: string) => void
-  onMessage?: (message: unknown) => void
-  onDebugMessage?: (message: unknown) => void
-}
-
-export interface WebRTCManagerConfig {
-  deviceId: string
-  deviceName: string
-  agentId: string
-  webrtcActions: WebRTCActions
-  callbacks: WebRTCManagerCallbacks
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const ICE_SERVERS: RTCIceServer[] = [
-  { urls: 'stun:stun.l.google.com:19302' },
-  { urls: 'stun:stun1.l.google.com:19302' },
-]
-
-const PING_INTERVAL_MS = 30000
-const MAX_RECONNECT_ATTEMPTS = 3
-const RECONNECT_DELAY_MS = 1000
-/** Time to wait for ICE to reach connected/completed state after signaling. */
-const ICE_TIMEOUT_MS = 40000
-
-// ---------------------------------------------------------------------------
-// Class
-// ---------------------------------------------------------------------------
-
-export class WebRTCConnectionManager {
-  // Configuration
-  private readonly deviceId: string
-  private readonly deviceName: string
-  private readonly agentId: string
-  private readonly webrtcActions: WebRTCActions
-
-  // Mutable callbacks — updated by the hook when React props change
-  private callbacks: WebRTCManagerCallbacks
-
-  // WebRTC objects
-  private pc: RTCPeerConnection | null = null
-  private channel: RTCDataChannel | null = null
-  private debugChannel: RTCDataChannel | null = null
-  private cleanupSse: (() => void) | null = null
-  private chunkReassembler: ChunkReassembler | null = null
-
-  // Timers
-  private pingInterval: number | null = null
-  private staleCleanupInterval: number | null = null
-  private reconnectTimeout: number | null = null
-  private iceTimeout: number | null = null
-
-  // Reconnection state machine
-  private reconnectAttempt = 0
-  private isReconnecting = false
-
-  // Session ID (stored locally so disconnect doesn't depend on React store)
-  private sessionId: string | null = null
-
-  // Lifecycle flag — guards async continuations after dispose
-  private disposed = false
-
-  constructor(config: WebRTCManagerConfig) {
-    this.deviceId = config.deviceId
-    this.deviceName = config.deviceName
-    this.agentId = config.agentId
-    this.webrtcActions = config.webrtcActions
-    this.callbacks = { ...config.callbacks }
-  }
-
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-
-  /**
-   * Replace callback references (called by the hook when React props change).
-   */
-  updateCallbacks(callbacks: Partial<WebRTCManagerCallbacks>): void {
-    Object.assign(this.callbacks, callbacks)
-  }
-
-  /**
-   * Connect to the device via WebRTC.
-   * @param isRetry — true when called from scheduleReconnect (preserves attempt counter)
-   */
-  async connect(isRetry = false): Promise<void> {
-    if (!this.deviceId || !this.agentId) {
-      console.error('[WebRTC] Missing required parameters — deviceId:', this.deviceId, 'agentId:', this.agentId)
-      throw new Error('Missing deviceId or agentId for WebRTC connection')
-    }
-
-    // Cancel any pending reconnection to prevent races
-    this.cancelReconnect()
-
-    // Reset reconnect counter only on fresh (non-retry) connection attempts
-    if (!isRetry) {
-      this.reconnectAttempt = 0
-      this.webrtcActions.setReconnectAttempt(0)
-    }
-
-    // Tear down any existing resources before creating new ones
-    this.cleanup()
-
-    try {
-      // Start session in store
-      this.webrtcActions.startSession({
-        deviceId: this.deviceId,
-        deviceName: this.deviceName,
-        agentId: this.agentId,
-      })
-      this.updateStatus('connecting')
-
-      // 1. Create peer connection with STUN servers
-      const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS })
-      this.pc = pc
-
-      // 2. Create data channel BEFORE creating offer (required by WebRTC spec)
-      const channel = pc.createDataChannel('data')
-      this.channel = channel
-
-      // 3. Set up data channel event handlers
-      channel.onopen = () => {
-        if (this.disposed) return
-        console.log('[WebRTC] Data channel opened successfully!')
-        // Clear ICE timeout — connection is established
-        this.clearIceTimeout()
-        // Reset reconnection counter on successful connection
-        this.reconnectAttempt = 0
-        this.webrtcActions.setReconnectAttempt(0)
-        this.updateStatus('connected')
-        setDataChannel(channel)
-        this.startPingInterval()
-      }
-
-      channel.onclose = () => {
-        if (this.disposed) return
-        console.log('[WebRTC] Data channel closed')
-        setDataChannel(null)
-        this.stopPingInterval()
-        this.updateStatus('disconnected')
-      }
-
-      channel.onerror = (event) => {
-        if (this.disposed) return
-        console.error('[WebRTC] Data channel error:', event)
-        this.handleError('Data channel error')
-      }
-
-      // Chunk reassembler for receiving large messages
-      this.chunkReassembler = new ChunkReassembler()
-
-      // Periodically clean up stale chunk transfers
-      this.staleCleanupInterval = window.setInterval(() => {
-        this.chunkReassembler?.cleanupStale()
-      }, PING_INTERVAL_MS)
-
-      channel.onmessage = (event) => {
-        try {
-          const msg = JSON.parse(event.data)
-
-          // Check for chunk protocol messages
-          if (this.chunkReassembler?.isChunkMessage(msg.type)) {
-            const assembled = this.chunkReassembler.handleChunkMessage(msg)
-            if (assembled) {
-              const fullMsg = JSON.parse(assembled)
-              this.dispatchMessage(fullMsg)
-            }
-            return
-          }
-
-          this.dispatchMessage(msg)
-        } catch (err) {
-          console.error('[WebRTC] Failed to parse message:', err)
-        }
-      }
-
-      // 4. Set up ICE connection state monitoring
-      pc.oniceconnectionstatechange = () => {
-        if (this.disposed) return
-        const state = pc.iceConnectionState
-        if (state === 'connected' || state === 'completed') {
-          // ICE connected — clear the timeout (data channel onopen will set status)
-          this.clearIceTimeout()
-        } else if (state === 'failed' || state === 'disconnected') {
-          console.error('[WebRTC] ICE connection failed or disconnected')
-          this.clearIceTimeout()
-          this.handleError('ICE connection failed')
-        }
-      }
-
-      pc.onconnectionstatechange = () => {
-        if (this.disposed) return
-        if (pc.connectionState === 'failed') {
-          console.error('[WebRTC] Peer connection failed')
-          this.clearIceTimeout()
-          this.handleError('Connection failed')
-        }
-      }
-
-      // 5. Create and set local description (SDP offer)
-      const offer = await pc.createOffer()
-      await pc.setLocalDescription(offer)
-
-      // 6. Wait for ICE gathering to complete (or timeout)
-      await waitForIceGathering(pc, 5000)
-
-      if (this.disposed) return
-
-      // 7. Send offer to backend and get answer
-      const response = await createWebRTCSession({
-        deviceId: this.deviceId,
-        sdp: pc.localDescription!.sdp,
-      })
-
-      if (this.disposed) return
-
-      if (response.status !== 'success' || !response.sdp) {
-        console.error('[WebRTC] Backend returned error or missing SDP')
-        throw new Error(response.error || 'Failed to create WebRTC session')
-      }
-
-      // Store session ID locally and in the store
-      this.sessionId = response.sessionId
-      this.webrtcActions.setSessionId(response.sessionId)
-
-      // 8. Set remote description (SDP answer from agent)
-      await pc.setRemoteDescription({
-        type: 'answer',
-        sdp: response.sdp,
-      })
-
-      if (this.disposed) return
-
-      // 9. Subscribe to ICE candidates from agent via SSE
-      this.cleanupSse = subscribeToIceCandidates(
-        response.sessionId,
-        async (event) => {
-          try {
-            if (pc.remoteDescription) {
-              await pc.addIceCandidate({
-                candidate: event.candidate,
-                sdpMid: event.sdpMid,
-                sdpMLineIndex: event.sdpMLineIndex,
-              })
-            } else {
-              console.warn('[WebRTC] Cannot add ICE candidate — no remote description yet')
-            }
-          } catch (err) {
-            console.warn('[WebRTC] Failed to add ICE candidate:', err)
-          }
-        },
-        (error) => {
-          console.error('[WebRTC] SSE error:', error)
-        },
-      )
-
-      // 10. Forward local ICE candidates to agent via backend
-      pc.onicecandidate = async (event) => {
-        if (event.candidate && response.sessionId) {
-          try {
-            await sendIceCandidate({
-              sessionId: response.sessionId,
-              candidate: event.candidate.candidate,
-              sdpMid: event.candidate.sdpMid || '0',
-              sdpMLineIndex: event.candidate.sdpMLineIndex || 0,
-            })
-          } catch (err) {
-            console.warn('[WebRTC] Failed to send ICE candidate:', err)
-          }
-        }
-      }
-
-      // 11. Start ICE timeout — if data channel doesn't open within ICE_TIMEOUT_MS, fail
-      this.startIceTimeout()
-    } catch (err) {
-      if (this.disposed) return
-      console.error('[WebRTC] Connection failed:', err)
-      this.clearIceTimeout()
-      const errorMessage = err instanceof Error ? err.message : 'Unknown error'
-      this.handleError(errorMessage)
-      throw err
-    }
-  }
-
-  /**
-   * Disconnect from the device (explicit user action).
-   */
-  async disconnect(): Promise<void> {
-    const sessionId = this.sessionId
-
-    // Cancel any pending reconnection attempts
-    this.cancelReconnect()
-    this.clearIceTimeout()
-
-    // Cleanup WebRTC resources
-    this.cleanup()
-
-    // Notify backend to close session
-    if (sessionId) {
-      try {
-        await closeWebRTCSession(sessionId)
-      } catch (err) {
-        console.warn('[WebRTC] Failed to close session on backend:', err)
-      }
-    }
-
-    // Update store
-    this.webrtcActions.endSession()
-    this.sessionId = null
-  }
-
-  /**
-   * Send a message over the main data channel.
-   */
-  sendMessage(message: unknown): void {
-    if (this.channel?.readyState === 'open') {
-      this.channel.send(JSON.stringify(message))
-    }
-  }
-
-  /**
-   * Send a message over the debug data channel.
-   * Returns true if the message was sent, false otherwise.
-   */
-  sendDebugMessage(message: unknown): boolean {
-    if (this.debugChannel?.readyState === 'open') {
-      this.debugChannel.send(JSON.stringify(message))
-      return true
-    }
-    return false
-  }
-
-  /**
-   * Open the debug data channel on the existing peer connection.
-   * Created lazily — only when the user starts debugging.
-   * Returns true when the channel opens, false on failure or timeout.
-   */
-  openDebugChannel(): Promise<boolean> {
-    // Already open
-    if (this.debugChannel?.readyState === 'open') {
-      return Promise.resolve(true)
-    }
-
-    // Close any existing channel in a non-open state
-    if (this.debugChannel) {
-      this.debugChannel.close()
-      this.debugChannel = null
-    }
-
-    // No peer connection available
-    const pc = this.pc
-    if (!pc || pc.connectionState === 'closed' || pc.connectionState === 'failed') {
-      console.warn('[WebRTC Debug] Cannot open debug channel: no active peer connection')
-      return Promise.resolve(false)
-    }
-
-    return new Promise<boolean>((resolve) => {
-      const timeout = setTimeout(() => {
-        console.error('[WebRTC Debug] Debug channel open timed out (5s)')
-        resolve(false)
-      }, 5000)
-
-      const debugChannel = pc.createDataChannel('debug')
-      this.debugChannel = debugChannel
-
-      debugChannel.onopen = () => {
-        clearTimeout(timeout)
-        console.log('[WebRTC Debug] Debug channel opened')
-        resolve(true)
-      }
-
-      debugChannel.onclose = () => {
-        console.log('[WebRTC Debug] Debug channel closed')
-        if (this.debugChannel === debugChannel) {
-          this.debugChannel = null
-        }
-      }
-
-      debugChannel.onerror = (event) => {
-        clearTimeout(timeout)
-        console.error('[WebRTC Debug] Debug channel error:', event)
-        if (this.debugChannel === debugChannel) {
-          this.debugChannel = null
-        }
-        resolve(false)
-      }
-
-      debugChannel.onmessage = (event) => {
-        try {
-          const msg = JSON.parse(event.data)
-          if (this.callbacks.onDebugMessage) {
-            this.callbacks.onDebugMessage(msg)
-          } else {
-            console.log('[WebRTC Debug]', msg.type, msg)
-          }
-        } catch (err) {
-          console.error('[WebRTC Debug] Failed to parse message:', err)
-        }
-      }
-    })
-  }
-
-  /**
-   * Close the debug data channel without affecting the main connection.
-   */
-  closeDebugChannel(): void {
-    if (this.debugChannel) {
-      this.debugChannel.close()
-      this.debugChannel = null
-      console.log('[WebRTC Debug] Debug channel closed by request')
-    }
-  }
-
-  /**
-   * Tear down everything. Called by the hook on unmount.
-   * After this, no async continuation will modify state.
-   */
-  dispose(): void {
-    this.disposed = true
-    this.cancelReconnect()
-    this.clearIceTimeout()
-    this.cleanup()
-  }
-
-  // -------------------------------------------------------------------------
-  // Private methods
-  // -------------------------------------------------------------------------
-
-  /**
-   * Dispatch a parsed message to the appropriate handler.
-   */
-  private dispatchMessage(msg: { type: string; [key: string]: unknown }): void {
-    if (msg.type === 'ready' || msg.type === 'pong') {
-      // No-op: routine protocol messages
-    } else if (msg.type === 'ping') {
-      this.channel?.send(JSON.stringify({ type: 'pong' }))
-    } else if (msg.type === 'command_response') {
-      handleCommandResponse(msg as Parameters<typeof handleCommandResponse>[0])
-    } else if (msg.type === 'error') {
-      this.handleError((msg.message as string) || 'Unknown error from agent')
-    } else {
-      this.callbacks.onMessage?.(msg)
-    }
-  }
-
-  /**
-   * Update status in the store and notify the callback.
-   */
-  private updateStatus(status: WebRTCConnectionStatus): void {
-    this.webrtcActions.setStatus(status)
-    this.callbacks.onStatusChange?.(status)
-  }
-
-  /**
-   * Handle an error: log it, update store, clean up resources, and
-   * optionally schedule a reconnection attempt.
-   */
-  private handleError(error: string, shouldReconnect: boolean = true): void {
-    console.error('[WebRTC] Error:', error)
-    this.webrtcActions.setError(error)
-    if (!shouldReconnect) {
-      this.webrtcActions.setStatus('error')
-    }
-    this.callbacks.onError?.(error)
-
-    // Clean up stale resources — connect() always creates fresh ones
-    this.cleanup()
-
-    // Schedule reconnection (unless disabled or already in progress)
-    if (shouldReconnect && !this.isReconnecting) {
-      this.scheduleReconnect()
-    }
-  }
-
-  /**
-   * Start ICE connection timeout.
-   * If the data channel doesn't open within ICE_TIMEOUT_MS, fail the attempt.
-   */
-  private startIceTimeout(): void {
-    this.clearIceTimeout()
-    this.iceTimeout = window.setTimeout(() => {
-      this.iceTimeout = null
-      if (this.disposed) return
-      // Only fire if we haven't connected yet
-      if (this.channel?.readyState !== 'open') {
-        console.error(`[WebRTC] ICE timeout: data channel did not open within ${ICE_TIMEOUT_MS / 1000}s`)
-        this.handleError('ICE connection timeout')
-      }
-    }, ICE_TIMEOUT_MS)
-  }
-
-  /**
-   * Clear the ICE timeout timer.
-   */
-  private clearIceTimeout(): void {
-    if (this.iceTimeout) {
-      clearTimeout(this.iceTimeout)
-      this.iceTimeout = null
-    }
-  }
-
-  /**
-   * Schedule a reconnection attempt.
-   * 3 attempts, 1 second apart. After 3 failures, give up permanently.
-   */
-  private scheduleReconnect(): void {
-    if (this.disposed) return
-    if (this.isReconnecting) return
-    if (this.reconnectTimeout) return
-
-    if (this.reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
-      console.log(`[WebRTC] Max reconnection attempts (${MAX_RECONNECT_ATTEMPTS}) reached, giving up permanently`)
-      this.webrtcActions.setStatus('failed')
-      this.webrtcActions.setError(`WebRTC connection failed after ${MAX_RECONNECT_ATTEMPTS} attempts`)
-      return
-    }
-
-    console.log(
-      `[WebRTC] Scheduling reconnection attempt ${this.reconnectAttempt + 1}/${MAX_RECONNECT_ATTEMPTS} in ${RECONNECT_DELAY_MS}ms`,
-    )
-
-    this.webrtcActions.setStatus('reconnecting')
-
-    this.reconnectTimeout = window.setTimeout(async () => {
-      this.reconnectTimeout = null
-      if (this.disposed) return
-
-      this.isReconnecting = true
-      this.reconnectAttempt++
-      this.webrtcActions.setReconnectAttempt(this.reconnectAttempt)
-
-      try {
-        await this.connect(true)
-        console.log('[WebRTC] Signaling completed, waiting for data channel...')
-      } catch (err) {
-        console.error('[WebRTC] Reconnection attempt failed:', err)
-        // connect() already called handleError → cleanup.
-        // handleError's scheduleReconnect was skipped because isReconnecting was true.
-        // Check if we should try again.
-        this.isReconnecting = false
-        if (this.reconnectAttempt < MAX_RECONNECT_ATTEMPTS) {
-          this.scheduleReconnect()
-        } else {
-          console.log(`[WebRTC] Max reconnection attempts (${MAX_RECONNECT_ATTEMPTS}) reached, giving up permanently`)
-          this.webrtcActions.setStatus('failed')
-          this.webrtcActions.setError(`WebRTC connection failed after ${MAX_RECONNECT_ATTEMPTS} attempts`)
-        }
-        return
-      }
-
-      this.isReconnecting = false
-    }, RECONNECT_DELAY_MS)
-  }
-
-  /**
-   * Cancel any pending reconnection attempts.
-   */
-  private cancelReconnect(): void {
-    this.isReconnecting = false
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout)
-      this.reconnectTimeout = null
-    }
-  }
-
-  /**
-   * Clean up WebRTC resources (peer connection, channels, SSE, timers).
-   * Does NOT cancel reconnection — use cancelReconnect() for that.
-   */
-  private cleanup(): void {
-    this.stopPingInterval()
-    this.clearIceTimeout()
-
-    if (this.staleCleanupInterval) {
-      clearInterval(this.staleCleanupInterval)
-      this.staleCleanupInterval = null
-    }
-
-    this.chunkReassembler = null
-
-    setDataChannel(null)
-
-    if (this.cleanupSse) {
-      this.cleanupSse()
-      this.cleanupSse = null
-    }
-
-    if (this.debugChannel) {
-      this.debugChannel.close()
-      this.debugChannel = null
-    }
-
-    if (this.channel) {
-      this.channel.close()
-      this.channel = null
-    }
-
-    if (this.pc) {
-      this.pc.close()
-      this.pc = null
-    }
-  }
-
-  private startPingInterval(): void {
-    this.stopPingInterval()
-    this.pingInterval = window.setInterval(() => {
-      if (this.channel?.readyState === 'open') {
-        this.channel.send(JSON.stringify({ type: 'ping' }))
-      }
-    }, PING_INTERVAL_MS)
-  }
-
-  private stopPingInterval(): void {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval)
-      this.pingInterval = null
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Wait for ICE gathering to complete or timeout.
- */
-function waitForIceGathering(pc: RTCPeerConnection, timeoutMs: number): Promise<void> {
-  return new Promise((resolve) => {
-    if (pc.iceGatheringState === 'complete') {
-      resolve()
-      return
-    }
-
-    const timeout = setTimeout(() => {
-      resolve()
-    }, timeoutMs)
-
-    pc.onicegatheringstatechange = () => {
-      if (pc.iceGatheringState === 'complete') {
-        clearTimeout(timeout)
-        resolve()
-      }
-    }
-  })
-}
diff --git a/src2/frontend/services/api/webrtc/webrtc-signaling.ts b/src2/frontend/services/api/webrtc/webrtc-signaling.ts
deleted file mode 100644
index 8114d3259..000000000
--- a/src2/frontend/services/api/webrtc/webrtc-signaling.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-/**
- * WebRTC Signaling Service
- *
- * Handles communication with the autonomy-edge-backend for WebRTC session management.
- * This service manages:
- * - Session creation (SDP offer/answer exchange)
- * - ICE candidate forwarding
- * - Session termination
- * - Server-Sent Events for receiving ICE candidates from the agent
- */
-
-import { api } from '../axios'
-
-export interface HttpResponse<T> {
-  statusCode: number
-  data: T
-}
-
-export interface CreateSessionParams {
-  deviceId: string
-  sdp: string
-}
-
-export interface CreateSessionResponse {
-  sessionId: string
-  sdp?: string
-  sdpType?: 'answer'
-  error?: string
-  status: 'success' | 'error'
-}
-
-export interface IceCandidateParams {
-  sessionId: string
-  candidate: string
-  sdpMid: string
-  sdpMLineIndex: number
-}
-
-export interface IceCandidateResponse {
-  success: boolean
-  message: string
-}
-
-export interface CloseSessionResponse {
-  success: boolean
-  message: string
-}
-
-export interface IceCandidateEvent {
-  type: 'ice-candidate'
-  candidate: string
-  sdpMid: string
-  sdpMLineIndex: number
-}
-
-/**
- * Create a new WebRTC session with the specified device.
- * This sends the browser's SDP offer to the backend, which forwards it to the
- * orchestrator agent. The agent creates its peer connection and returns an SDP answer.
- */
-export async function createWebRTCSession(params: CreateSessionParams): Promise<CreateSessionResponse> {
-  try {
-    const { data } = await api.post<HttpResponse<CreateSessionResponse>>('/webrtc/sessions', {
-      deviceId: params.deviceId,
-      sdp: params.sdp,
-    })
-    return data.data
-  } catch (err) {
-    console.error('[WebRTC Signaling] Failed to create session:', err)
-    throw err
-  }
-}
-
-/**
- * Forward an ICE candidate to the orchestrator agent via the backend.
- * ICE candidates are used to establish the peer-to-peer connection.
- */
-export async function sendIceCandidate(params: IceCandidateParams): Promise<IceCandidateResponse> {
-  try {
-    const { data } = await api.post<HttpResponse<IceCandidateResponse>>(`/webrtc/sessions/${params.sessionId}/ice`, {
-      candidate: params.candidate,
-      sdpMid: params.sdpMid,
-      sdpMLineIndex: params.sdpMLineIndex,
-    })
-    return data.data
-  } catch (err) {
-    console.error('[WebRTC Signaling] Failed to send ICE candidate:', err)
-    throw err
-  }
-}
-
-/**
- * Close a WebRTC session and notify the orchestrator agent.
- */
-export async function closeWebRTCSession(sessionId: string): Promise<CloseSessionResponse> {
-  const { data } = await api.delete<HttpResponse<CloseSessionResponse>>(`/webrtc/sessions/${sessionId}`)
-  return data.data
-}
-
-/**
- * Subscribe to ICE candidates from the orchestrator agent via Server-Sent Events.
- * Returns an EventSource that emits ice-candidate events.
- *
- * @param sessionId - The WebRTC session ID
- * @param onCandidate - Callback for receiving ICE candidates
- * @param onError - Callback for handling errors
- * @returns Cleanup function to close the EventSource
- */
-export function subscribeToIceCandidates(
-  sessionId: string,
-  onCandidate: (event: IceCandidateEvent) => void,
-  onError?: (error: Event) => void,
-): () => void {
-  const baseURL = import.meta.env?.VITE_EDGE_API_URL || 'http://localhost:3333'
-  const sseUrl = `${baseURL}/webrtc/sessions/${sessionId}/events`
-
-  const eventSource = new EventSource(sseUrl, {
-    withCredentials: true,
-  })
-
-  eventSource.onmessage = (event) => {
-    try {
-      const data = JSON.parse(event.data) as IceCandidateEvent
-      if (data.type === 'ice-candidate') {
-        onCandidate(data)
-      }
-    } catch (err) {
-      console.error('[WebRTC Signaling] Failed to parse ICE candidate event:', err)
-    }
-  }
-
-  eventSource.onerror = (error) => {
-    console.error('[WebRTC Signaling] SSE error:', error)
-    console.error('[WebRTC Signaling] SSE readyState:', eventSource.readyState)
-    if (onError) {
-      onError(error)
-    }
-  }
-
-  // Return cleanup function
-  return () => {
-    eventSource.close()
-  }
-}
diff --git a/src2/frontend/services/debug-session-controls.ts b/src2/frontend/services/debug-session-controls.ts
deleted file mode 100644
index 866bf5a81..000000000
--- a/src2/frontend/services/debug-session-controls.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-export type DebugSessionControls = {
-  startDebug:
-    | ((
-        deviceId: string,
-        username: string,
-        password: string,
-        debugCContent: string,
-        port?: number,
-      ) => Promise<boolean> | boolean)
-    | null
-  stopDebug: (() => void) | null
-  forceVariable: ((index: number, force: boolean, valueHex?: string) => Promise<boolean>) | null
-}
-
-const controls: DebugSessionControls = {
-  startDebug: null,
-  stopDebug: null,
-  forceVariable: null,
-}
-
-export function setDebugSessionControls(c: Partial<DebugSessionControls>): void {
-  Object.assign(controls, c)
-}
-
-export function getDebugSessionControls(): Readonly<DebugSessionControls> {
-  return controls
-}
-
-export function clearDebugSessionControls(): void {
-  controls.startDebug = null
-  controls.stopDebug = null
-  controls.forceVariable = null
-}
diff --git a/src2/frontend/services/debug/debug-bridge.ts b/src2/frontend/services/debug/debug-bridge.ts
deleted file mode 100644
index dc98ae78b..000000000
--- a/src2/frontend/services/debug/debug-bridge.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- * Debug Bridge — singleton orchestrator for debug transport management.
- *
- * Mirrors the debugger-related fields and methods of the desktop editor's
- * MainProcessBridge (src/main/modules/ipc/main.ts). The polling loop and
- * session management call debugBridge methods — they never know which
- * transport is active.
- *
- * Equivalent to `window.bridge.debugger*()` calls in the desktop editor.
- */
-
-import type { DebugConnectionType, DebugTransport, DebugTransportResult, DebugSetResult } from './types'
-
-type StopCallback = () => void
-
-class DebugBridge {
-  private activeTransport: DebugTransport | null = null
-  private connectionType: DebugConnectionType | null = null
-  private stopCallbacks: StopCallback[] = []
-
-  /**
-   * Set the active transport. Called when starting a debug session.
-   * Any previous transport is disconnected first.
-   */
-  setTransport(type: DebugConnectionType, transport: DebugTransport): void {
-    if (this.activeTransport) {
-      this.activeTransport.disconnect()
-    }
-    this.connectionType = type
-    this.activeTransport = transport
-  }
-
-  /**
-   * Clear the active transport without disconnecting it.
-   * Used when the transport was already disconnected externally.
-   */
-  clearTransport(): void {
-    this.connectionType = null
-    this.activeTransport = null
-  }
-
-  /**
-   * Get the current connection type (null if no active session).
-   */
-  getConnectionType(): DebugConnectionType | null {
-    return this.connectionType
-  }
-
-  /**
-   * Check if a transport is currently active.
-   */
-  isConnected(): boolean {
-    return this.activeTransport !== null
-  }
-
-  /**
-   * Connect the active transport.
-   * Caller must call setTransport() first.
-   */
-  async connect(): Promise<void> {
-    if (!this.activeTransport) {
-      throw new Error('No transport set')
-    }
-    await this.activeTransport.connect()
-  }
-
-  /**
-   * Disconnect the active transport and clear state.
-   * Mirrors handleDebuggerDisconnect in the desktop editor.
-   */
-  async disconnect(): Promise<void> {
-    if (this.activeTransport) {
-      this.activeTransport.disconnect()
-    }
-    this.activeTransport = null
-    this.connectionType = null
-
-    for (const cb of this.stopCallbacks) {
-      cb()
-    }
-  }
-
-  /**
-   * Verify the MD5 hash of the running firmware.
-   * Mirrors handleDebuggerVerifyMd5 in the desktop editor.
-   */
-  async verifyMd5(
-    expectedMd5: string,
-  ): Promise<{ success: boolean; match?: boolean; targetMd5?: string; error?: string }> {
-    if (!this.activeTransport) {
-      return { success: false, error: 'No transport connected' }
-    }
-
-    try {
-      const targetMd5 = await this.activeTransport.getMd5Hash()
-      const match = targetMd5.toLowerCase() === expectedMd5.toLowerCase()
-      return { success: true, match, targetMd5 }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error during MD5 verification',
-      }
-    }
-  }
-
-  /**
-   * Poll variable values from the runtime.
-   * Mirrors handleDebuggerGetVariablesList in the desktop editor.
-   */
-  async getVariablesList(indexes: number[]): Promise<DebugTransportResult> {
-    if (!this.activeTransport) {
-      return { success: false, error: 'No transport connected' }
-    }
-
-    return this.activeTransport.getVariablesList(indexes)
-  }
-
-  /**
-   * Force or release a variable in the runtime.
-   * Mirrors handleDebuggerSetVariable in the desktop editor.
-   */
-  async setVariable(index: number, force: boolean, valueBuffer?: Uint8Array): Promise<DebugSetResult> {
-    if (!this.activeTransport) {
-      return { success: false, error: 'No transport connected' }
-    }
-
-    return this.activeTransport.setVariable(index, force, valueBuffer)
-  }
-
-  /**
-   * Subscribe to debug session stop events. Returns an unsubscribe function.
-   */
-  onStopped(callback: StopCallback): () => void {
-    this.stopCallbacks.push(callback)
-    return () => {
-      this.stopCallbacks = this.stopCallbacks.filter((cb) => cb !== callback)
-    }
-  }
-}
-
-/** Singleton instance — the single source of truth for the active debug connection. */
-export const debugBridge = new DebugBridge()
diff --git a/src2/frontend/services/debug/index.ts b/src2/frontend/services/debug/index.ts
deleted file mode 100644
index 873491815..000000000
--- a/src2/frontend/services/debug/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export { debugBridge } from './debug-bridge'
-export type { DebugConnectionType, DebugTransport, DebugTransportResult, DebugSetResult } from './types'
-export { ModbusRtuTransport, WebRTCTransport } from './transports'
-export type { WebRTCTransportConfig } from './transports'
diff --git a/src2/frontend/services/debug/transports/index.ts b/src2/frontend/services/debug/transports/index.ts
deleted file mode 100644
index 39e285166..000000000
--- a/src2/frontend/services/debug/transports/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export { ModbusRtuTransport } from './modbus-rtu-transport'
-export { WebRTCTransport } from './webrtc-transport'
-export type { WebRTCTransportConfig } from './webrtc-transport'
diff --git a/src2/frontend/services/debug/transports/webrtc-transport.ts b/src2/frontend/services/debug/transports/webrtc-transport.ts
deleted file mode 100644
index 998051a6b..000000000
--- a/src2/frontend/services/debug/transports/webrtc-transport.ts
+++ /dev/null
@@ -1,388 +0,0 @@
-/**
- * WebRTC Debug Transport — wraps the existing JSON debug protocol.
- *
- * The WebRTC agent uses a JSON-based protocol (debug_get_list, debug_values_response,
- * etc.) that differs from the raw Modbus protocol used by other transports. This
- * transport encapsulates that protocol behind the standard DebugTransport interface
- * using a promise-based request/response queue (like the desktop editor's Modbus
- * sendRequestMutex).
- *
- * Supports automatic fallback to HTTP when the WebRTC DataChannel is unavailable.
- * The JSON translation layer is kept working as-is — when we later replace it with
- * direct Modbus-over-DataChannel, we simply swap this transport implementation.
- */
-
-import type { DebugTransport, DebugTransportResult, DebugSetResult } from '../types'
-import { sendDebugCommandViaHttp } from '../../api/debug-transport'
-import { hexToBytes, bytesToHex } from '../../../utils/hex'
-
-// Timeout for individual debug requests (matches desktop editor's 5000ms Modbus timeout)
-const REQUEST_TIMEOUT_MS = 5000
-// Timeout for connection handshake
-const CONNECT_TIMEOUT_MS = 10_000
-
-interface PendingRequest<T> {
-  resolve: (value: T) => void
-  reject: (error: Error) => void
-  timeout: ReturnType<typeof setTimeout>
-}
-
-export interface WebRTCTransportConfig {
-  /** Send a message via WebRTC DataChannel. Returns true if sent. */
-  sendViaDataChannel: (message: unknown) => boolean
-  /** Agent ID for HTTP fallback */
-  agentId: string
-  /** Device ID for HTTP fallback and debug_start */
-  deviceId: string
-  /** Username for debug_start authentication */
-  username: string
-  /** Password for debug_start authentication */
-  password: string
-  /** Port for debug_start (default: 8443) */
-  port?: number
-  /** Called when the agent sends debug_ready (e.g. after runtime restart) */
-  onReady?: () => void
-}
-
-export class WebRTCTransport implements DebugTransport {
-  private config: WebRTCTransportConfig
-  private disconnected = false
-
-  // Pending request queues — one per message type
-  private pendingConnect: PendingRequest<void> | null = null
-  private pendingMd5: PendingRequest<string> | null = null
-  private pendingGetList: PendingRequest<DebugTransportResult> | null = null
-  private pendingSetVariable: PendingRequest<DebugSetResult> | null = null
-
-  // Mutex to serialize getVariablesList calls (like desktop's sendRequestMutex)
-  private getListMutex: Promise<void> = Promise.resolve()
-
-  constructor(config: WebRTCTransportConfig) {
-    this.config = config
-  }
-
-  /**
-   * Connect to the debug session on the remote runtime.
-   * Sends debug_start and waits for debug_connected + debug_md5_response.
-   */
-  async connect(): Promise<void> {
-    this.disconnected = false
-
-    return new Promise<void>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingConnect = null
-        reject(new Error('Debug connection timed out'))
-      }, CONNECT_TIMEOUT_MS)
-
-      this.pendingConnect = { resolve, reject, timeout }
-
-      this.sendMessage({
-        type: 'debug_start',
-        device_id: this.config.deviceId,
-        username: this.config.username,
-        password: this.config.password,
-        port: this.config.port ?? 8443,
-      })
-    })
-  }
-
-  /**
-   * Disconnect the debug session.
-   */
-  disconnect(): void {
-    this.disconnected = true
-    this.sendMessage({ type: 'debug_stop' })
-    this.rejectAllPending(new Error('Transport disconnected'))
-  }
-
-  /**
-   * Get the MD5 hash from the runtime.
-   */
-  async getMd5Hash(): Promise<string> {
-    if (this.disconnected) {
-      throw new Error('Transport disconnected')
-    }
-
-    return new Promise<string>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingMd5 = null
-        reject(new Error('MD5 request timed out'))
-      }, REQUEST_TIMEOUT_MS)
-
-      this.pendingMd5 = { resolve, reject, timeout }
-
-      this.sendMessage({ type: 'debug_get_md5' })
-    })
-  }
-
-  /**
-   * Poll variable values. Serialized via mutex to prevent concurrent requests.
-   */
-  async getVariablesList(indexes: number[]): Promise<DebugTransportResult> {
-    if (this.disconnected) {
-      return { success: false, error: 'Transport disconnected' }
-    }
-
-    return new Promise<DebugTransportResult>((resolve, reject) => {
-      this.getListMutex = this.getListMutex.then(
-        () => this.getVariablesListImpl(indexes).then(resolve, reject),
-        () => this.getVariablesListImpl(indexes).then(resolve, reject),
-      )
-    })
-  }
-
-  private async getVariablesListImpl(indexes: number[]): Promise<DebugTransportResult> {
-    if (this.disconnected) {
-      return { success: false, error: 'Transport disconnected' }
-    }
-
-    return new Promise<DebugTransportResult>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingGetList = null
-        reject(new Error('Get variables list request timed out'))
-      }, REQUEST_TIMEOUT_MS)
-
-      this.pendingGetList = { resolve, reject, timeout }
-
-      this.sendMessage({
-        type: 'debug_get_list',
-        indexes,
-      })
-    })
-  }
-
-  /**
-   * Force or release a variable.
-   */
-  async setVariable(index: number, force: boolean, valueBuffer?: Uint8Array): Promise<DebugSetResult> {
-    if (this.disconnected) {
-      return { success: false, error: 'Transport disconnected' }
-    }
-
-    const valueHex = force && valueBuffer ? bytesToHex(valueBuffer) : '00'
-
-    return new Promise<DebugSetResult>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingSetVariable = null
-        reject(new Error('Set variable request timed out'))
-      }, REQUEST_TIMEOUT_MS)
-
-      this.pendingSetVariable = { resolve, reject, timeout }
-
-      this.sendMessage({
-        type: 'debug_set',
-        index,
-        force,
-        value: valueHex,
-      })
-    })
-  }
-
-  /**
-   * Handle an incoming debug message from the agent.
-   * Called by the WebRTC DataChannel onmessage handler or HTTP response.
-   * Resolves the appropriate pending promise.
-   */
-  onDebugMessage(rawMessage: unknown): void {
-    const message = rawMessage as Record<string, unknown>
-    const type = message.type as string
-
-    switch (type) {
-      case 'debug_connected':
-        // Connection established — resolve the connect promise
-        if (this.pendingConnect) {
-          clearTimeout(this.pendingConnect.timeout)
-          const pending = this.pendingConnect
-          this.pendingConnect = null
-          pending.resolve()
-        }
-        break
-
-      case 'debug_md5_response':
-        if (this.pendingMd5) {
-          clearTimeout(this.pendingMd5.timeout)
-          const pending = this.pendingMd5
-          this.pendingMd5 = null
-          pending.resolve(message.md5 as string)
-        }
-        break
-
-      case 'debug_values_response': {
-        if (this.pendingGetList) {
-          clearTimeout(this.pendingGetList.timeout)
-          const pending = this.pendingGetList
-          this.pendingGetList = null
-
-          const dataHex = message.data as string | undefined
-          const tick = message.tick as number | undefined
-
-          if (!dataHex) {
-            pending.resolve({ success: true, tick, data: new Uint8Array(0) })
-          } else {
-            pending.resolve({
-              success: true,
-              tick,
-              data: hexToBytes(dataHex),
-              // WebRTC JSON protocol doesn't include lastIndex — all requested variables are returned
-            })
-          }
-        }
-        break
-      }
-
-      case 'debug_set_response':
-        if (this.pendingSetVariable) {
-          clearTimeout(this.pendingSetVariable.timeout)
-          const pending = this.pendingSetVariable
-          this.pendingSetVariable = null
-          pending.resolve({ success: (message.success as boolean) ?? true })
-        }
-        break
-
-      case 'debug_error': {
-        const errorMsg = (message.error as string) || 'Unknown debug error'
-
-        // Memory errors resolve getVariablesList with error (don't reject)
-        if (errorMsg.includes('ERROR_OUT_OF_MEMORY') && this.pendingGetList) {
-          clearTimeout(this.pendingGetList.timeout)
-          const pending = this.pendingGetList
-          this.pendingGetList = null
-          pending.resolve({ success: false, error: 'ERROR_OUT_OF_MEMORY' })
-          break
-        }
-
-        // Connection-phase errors reject connect
-        if (this.pendingConnect) {
-          clearTimeout(this.pendingConnect.timeout)
-          const pending = this.pendingConnect
-          this.pendingConnect = null
-          pending.reject(new Error(errorMsg))
-          break
-        }
-
-        // Reject whichever request is pending (check all types)
-        if (this.pendingGetList) {
-          clearTimeout(this.pendingGetList.timeout)
-          const pending = this.pendingGetList
-          this.pendingGetList = null
-          pending.resolve({ success: false, error: errorMsg })
-        }
-        if (this.pendingMd5) {
-          clearTimeout(this.pendingMd5.timeout)
-          const pending = this.pendingMd5
-          this.pendingMd5 = null
-          pending.reject(new Error(errorMsg))
-        }
-        if (this.pendingSetVariable) {
-          clearTimeout(this.pendingSetVariable.timeout)
-          const pending = this.pendingSetVariable
-          this.pendingSetVariable = null
-          pending.resolve({ success: false, error: errorMsg })
-        }
-        break
-      }
-
-      case 'debug_disconnected':
-        this.rejectAllPending(new Error('Debug session disconnected by remote'))
-        break
-
-      case 'debug_ready':
-        // Auto-recovery: the remote agent restarted and is ready for a new debug session
-        if (this.config.onReady) {
-          this.config.onReady()
-        }
-        break
-
-      case 'debug_info_response':
-        // Informational — no pending request to resolve
-        break
-
-      default:
-        console.log('[WebRTCTransport] Unknown message type:', type)
-    }
-  }
-
-  /**
-   * Send a debug message via WebRTC DataChannel (preferred) or HTTP fallback.
-   */
-  private sendMessage(message: unknown): void {
-    const sent = this.config.sendViaDataChannel(message)
-    if (sent) return
-
-    // HTTP fallback — route response back through onDebugMessage,
-    // or reject the pending promise on failure.
-    void sendDebugCommandViaHttp(this.config.agentId, this.config.deviceId, message as Record<string, unknown>)
-      .then((response) => {
-        if (response) {
-          this.onDebugMessage(response)
-        }
-      })
-      .catch((err) => {
-        console.error('[WebRTCTransport] HTTP debug command failed:', err)
-        // Reject the pending promise that initiated this send so it doesn't hang until timeout
-        this.rejectFirstPending(new Error(`HTTP fallback failed: ${err instanceof Error ? err.message : err}`))
-      })
-  }
-
-  /**
-   * Reject all pending requests (e.g. on disconnect or remote disconnection).
-   */
-  private rejectAllPending(error: Error): void {
-    const pendingRequests = [
-      this.pendingConnect,
-      this.pendingMd5,
-      this.pendingGetList,
-      this.pendingSetVariable,
-    ] as const
-
-    for (const pending of pendingRequests) {
-      if (pending) {
-        clearTimeout(pending.timeout)
-        pending.reject(error)
-      }
-    }
-
-    this.pendingConnect = null
-    this.pendingMd5 = null
-    this.pendingGetList = null
-    this.pendingSetVariable = null
-  }
-
-  /**
-   * Reject the first pending promise found (used when HTTP fallback fails
-   * and we don't know which request type triggered the send).
-   */
-  private rejectFirstPending(error: Error): void {
-    // Order: getList is the most frequent (polling), then setVariable, md5, connect
-    const candidates = [
-      { ref: 'pendingGetList' as const, resolveWithError: true },
-      { ref: 'pendingSetVariable' as const, resolveWithError: true },
-      { ref: 'pendingMd5' as const, resolveWithError: false },
-      { ref: 'pendingConnect' as const, resolveWithError: false },
-    ]
-
-    for (const { ref, resolveWithError } of candidates) {
-      const pending = this[ref]
-      if (pending) {
-        clearTimeout(pending.timeout)
-        // For polling/set results, resolve with error (don't reject — the polling loop handles it)
-        // For md5/connect, reject (the caller has try/catch)
-        if (resolveWithError) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ;(pending as PendingRequest<any>).resolve({ success: false, error: error.message })
-        } else {
-          pending.reject(error)
-        }
-        this[ref] = null
-        break
-      }
-    }
-  }
-
-  /**
-   * Update the config (e.g. when WebRTC reconnects with new channel references).
-   */
-  updateConfig(partial: Partial<WebRTCTransportConfig>): void {
-    Object.assign(this.config, partial)
-  }
-}
diff --git a/src2/frontend/services/simulator/index.ts b/src2/frontend/services/simulator/index.ts
deleted file mode 100644
index e47b67873..000000000
--- a/src2/frontend/services/simulator/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { simulatorService } from './simulator-service'
diff --git a/src2/frontend/store/slices/ai/index.ts b/src2/frontend/store/slices/ai/index.ts
deleted file mode 100644
index 4bc28ea76..000000000
--- a/src2/frontend/store/slices/ai/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-export { createAISlice, createAISliceFactory } from './slice'
-export type {
-  AIActions,
-  AIModel,
-  AISlice,
-  AIState,
-  ChatConversation,
-  ChatMessage,
-  ChatMessageRole,
-} from './types'
-export { MAX_CONVERSATION_MESSAGES } from './types'
diff --git a/src2/frontend/store/slices/project/validation/variables.ts b/src2/frontend/store/slices/project/validation/variables.ts
deleted file mode 100644
index a010a131d..000000000
--- a/src2/frontend/store/slices/project/validation/variables.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import type { PLCVariable } from '../../../../../middleware/shared/ports/types'
-
-/**
- * This function extracts the number at the end of a string.
- */
-export const extractNumberAtEnd = (str: string): { number: number; string: string; length: number } => {
-  const match = str.match(/(\d+)$/)
-  const number = match ? parseInt(match[0], 10) : -1
-  return {
-    number,
-    string: match ? match[0] : '',
-    length: match ? match[0].length : 0,
-  }
-}
-
-const checkVariableNameUnit = (variables: PLCVariable[], variableName: string) => {
-  // Check if there is a variable with the same name when removing the number at the end
-  const variableNameWithoutNumber = variableName.substring(
-    0,
-    variableName.length - extractNumberAtEnd(variableName).length,
-  )
-  const filteredVariables = variables.filter((variable: PLCVariable) =>
-    variable.name.toLowerCase().includes(variableNameWithoutNumber.toLowerCase()),
-  )
-
-  // If there is a variable with the same name, sort the variables by the number at the end and get the biggest number
-  const sortedVariables = filteredVariables.sort((a, b) => {
-    const numberA = extractNumberAtEnd(a.name).number
-    const numberB = extractNumberAtEnd(b.name).number
-    if (numberA && numberB) {
-      return numberA - numberB
-    }
-    return 0
-  })
-
-  // Get the biggest number at the end of the variable name
-  // If there is no number at the end of the variable name, return -1 (because the number at the end of the variable name is 0)
-  const biggestVariable =
-    sortedVariables.length > 0 ? extractNumberAtEnd(sortedVariables[sortedVariables.length - 1].name) : { number: -1 }
-
-  return {
-    ok: filteredVariables.length > 0,
-    name: variableNameWithoutNumber,
-    number: biggestVariable.number + 1,
-  }
-}
-
-/**
- * This is a validation to check if the enumerated variable name is correct.
- *
- * The validation have to obey this rules:
- * - CamelCase, PascalCase or SnakeCase
- * - Can not be empty
- * - Can not be a reserved word
- */
-const enumeratedValidation = ({ value }: { value: string }) => {
-  const regex =
-    /^([a-zA-Z0-9]+(?:[A-Z][a-z0-9]*)*)|([A-Z][a-z0-9]*(?:[A-Z][a-z0-9]*)*)|([a-zA-Z0-9]+(?:_[a-zA-Z0-9]+)*)$/
-  if (value === '') {
-    return {
-      ok: false,
-      title: 'Invalid enumerated value',
-      message: `The enumerated value can not be empty.`,
-    }
-  }
-
-  if (!regex.test(value)) {
-    return {
-      ok: false,
-      title: 'Invalid enumerated value',
-      message: `The enumerated value "${value}" is invalid. Valid names: CamelCase, PascalCase or SnakeCase.`,
-    }
-  }
-  return { ok: true }
-}
-
-/**
- * This is a validation to check if the array variable is correct.
- *
- * The validation have to obey this rules:
- * 1. There CANNOT be space between the numeric values and dots
- * 2. The second number MUST always be greater than the first
- * 3. Only integer numbers can be used (shouldn't accept floating numbers or strings of any type)
- */
-const validateArrayValue = (value: string) => {
-  const [left, right] = value.split('..').map(Number)
-  return Number.isInteger(left) && Number.isInteger(right) && left < right
-}
-const arrayValidation = ({ value }: { value: string }) => {
-  const regex = /^(\d+)\.\.(\d+)$/
-  if (value === '') {
-    return {
-      ok: false,
-      title: 'Invalid array value',
-      message: `The array value can not be empty.`,
-    }
-  }
-  if (!regex.test(value) || !validateArrayValue(value)) {
-    return {
-      ok: false,
-      title: 'Invalid array value',
-      message: `The array value "${value}" is invalid. Pattern: "LEFT_number..RIGHT_number" and RIGHT must be GREATER than LEFT. Example: 0..10.`,
-    }
-  }
-  return { ok: true }
-}
-
-export { arrayValidation, checkVariableNameUnit, enumeratedValidation }
diff --git a/src2/frontend/store/slices/shared/slice.ts b/src2/frontend/store/slices/shared/slice.ts
deleted file mode 100644
index 7b33ef389..000000000
--- a/src2/frontend/store/slices/shared/slice.ts
+++ /dev/null
@@ -1,424 +0,0 @@
-import { produce } from 'immer'
-import { StateCreator } from 'zustand'
-
-import type { SharedRootState, SharedSlice } from './types'
-import { CreateEditorObjectFromTab } from '../tabs/utils'
-import {
-  createDatatypeObject,
-  createEditorObjectForDatatype,
-  createEditorObjectForPou,
-  createEditorObjectForRemoteDevice,
-  createEditorObjectForServer,
-  createPouObject,
-} from './utils'
-
-const MAX_HISTORY_SIZE = 50
-
-const createSharedSlice: StateCreator<SharedRootState, [], [], SharedSlice> = (setState, getState) => ({
-  undoRedo: {},
-
-  pouActions: {
-    create: ({ type, name, language }) => {
-      const state = getState()
-      const existing = state.project.data.pous.find((p) => p.name === name)
-      if (existing) return { ok: false, message: 'POU already exists' }
-
-      const pouDto = createPouObject({ type, name, language })
-      const result = state.projectActions.createPou(pouDto)
-      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
-      if (!result.ok) return { ok: false, message: result.message }
-
-      const editorModel = createEditorObjectForPou(name, type, language)
-      state.editorActions.addModel(editorModel)
-
-      state.fileActions.addFile({ name, type, filePath: name, isNew: true })
-
-      state.tabsActions.updateTabs({
-        name,
-        elementType: { type, language },
-      })
-      state.tabsActions.setSelectedTab(name)
-      state.editorActions.setEditor(editorModel)
-
-      state.libraryActions.addLibrary(name, type === 'program' ? 'function' : type)
-
-      return { ok: true }
-    },
-
-    deleteRequest: (name) => {
-      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'pou' })
-    },
-
-    delete: (name) => {
-      const state = getState()
-      state.projectActions.deletePou(name)
-      state.editorActions.removeModel(name)
-      state.fileActions.removeFile({ name })
-      state.tabsActions.removeTab(name)
-      state.libraryActions.removeUserLibrary(name)
-
-      // Reset editor if current editor was deleted
-      const currentEditor = state.editor
-      if (currentEditor.type !== 'available' && currentEditor.meta.name === name) {
-        state.editorActions.clearEditor()
-      }
-
-      return { ok: true }
-    },
-
-    rename: (oldName, newName) => {
-      const state = getState()
-      const existing = state.project.data.pous.find((p) => p.name === newName)
-      if (existing) return { ok: false, message: 'POU name already exists' }
-
-      state.projectActions.updatePouName(oldName, newName)
-      state.editorActions.updateEditorName(oldName, newName)
-      state.fileActions.updateFile({ name: oldName, newName })
-      state.tabsActions.updateTabName(oldName, newName)
-      state.libraryActions.updateLibraryName(oldName, newName)
-
-      return { ok: true }
-    },
-
-    duplicate: (sourceName, newName) => {
-      const state = getState()
-      const sourcePou = state.project.data.pous.find((p) => p.name === sourceName)
-      if (!sourcePou) return { ok: false, message: 'Source POU not found' }
-
-      const existing = state.project.data.pous.find((p) => p.name === newName)
-      if (existing) return { ok: false, message: 'POU name already exists' }
-
-      // Create a copy of the POU with the new name
-      const language = sourcePou.body.language as 'il' | 'st' | 'ld' | 'sfc' | 'fbd' | 'python' | 'cpp'
-      const pouDto = createPouObject({ type: sourcePou.pouType, name: newName, language })
-
-      // Copy the source POU's content into the new DTO
-      pouDto.data.body = { ...sourcePou.body }
-      pouDto.data.variables = sourcePou.interface?.variables ? [...sourcePou.interface.variables] : []
-      pouDto.data.documentation = sourcePou.documentation ?? ''
-      if (sourcePou.pouType === 'function' && 'returnType' in pouDto.data) {
-        pouDto.data.returnType = sourcePou.interface?.returnType ?? 'BOOL'
-      }
-
-      const result = state.projectActions.createPou(pouDto)
-      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
-      if (!result.ok) return { ok: false, message: result.message }
-
-      const editorModel = createEditorObjectForPou(newName, sourcePou.pouType, language)
-      state.editorActions.addModel(editorModel)
-      state.fileActions.addFile({ name: newName, type: sourcePou.pouType, filePath: newName, isNew: true })
-
-      return { ok: true }
-    },
-  },
-
-  datatypeActions: {
-    create: ({ name, derivation }) => {
-      const state = getState()
-      const existing = state.project.data.dataTypes.find((d) => d.name === name)
-      if (existing) return { ok: false, message: 'Data type already exists' }
-
-      const datatype = createDatatypeObject({ name, derivation })
-      const result = state.projectActions.createDatatype({ data: datatype })
-      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
-      if (!result.ok) return { ok: false, message: result.message }
-
-      const editorModel = createEditorObjectForDatatype(name, derivation)
-      state.editorActions.addModel(editorModel)
-      state.fileActions.addFile({ name, type: 'data-type', filePath: name, isNew: true })
-
-      state.tabsActions.updateTabs({
-        name,
-        elementType: { type: 'data-type', derivation },
-      })
-      state.tabsActions.setSelectedTab(name)
-      state.editorActions.setEditor(editorModel)
-
-      return { ok: true }
-    },
-
-    deleteRequest: (name) => {
-      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'datatype' })
-    },
-
-    delete: (name) => {
-      const state = getState()
-      state.projectActions.deleteDatatype(name)
-      state.editorActions.removeModel(name)
-      state.fileActions.removeFile({ name })
-      state.tabsActions.removeTab(name)
-
-      const currentEditor = state.editor
-      if (currentEditor.type !== 'available' && currentEditor.meta.name === name) {
-        state.editorActions.clearEditor()
-      }
-
-      return { ok: true }
-    },
-
-    rename: (oldName, newName) => {
-      const state = getState()
-      const existing = state.project.data.dataTypes.find((d) => d.name === newName)
-      if (existing) return { ok: false, message: 'Data type name already exists' }
-
-      const datatype = state.project.data.dataTypes.find((d) => d.name === oldName)
-      if (!datatype) return { ok: false, message: 'Data type not found' }
-
-      const updatedDatatype = { ...datatype, name: newName }
-      state.projectActions.updateDatatype(oldName, updatedDatatype)
-
-      state.editorActions.updateEditorName(oldName, newName)
-      state.fileActions.updateFile({ name: oldName, newName })
-      state.tabsActions.updateTabName(oldName, newName)
-
-      return { ok: true }
-    },
-
-    duplicate: (sourceName, newName) => {
-      const state = getState()
-      const source = state.project.data.dataTypes.find((d) => d.name === sourceName)
-      if (!source) return { ok: false, message: 'Data type not found' }
-
-      const existing = state.project.data.dataTypes.find((d) => d.name === newName)
-      if (existing) return { ok: false, message: 'Data type name already exists' }
-
-      const copy = { ...source, name: newName }
-      const result = state.projectActions.createDatatype({ data: copy })
-      /* istanbul ignore next -- defensive: shared slice already validates name uniqueness */
-      if (!result.ok) return { ok: false, message: result.message }
-
-      const editorModel = createEditorObjectForDatatype(newName, source.derivation)
-      state.editorActions.addModel(editorModel)
-      state.fileActions.addFile({ name: newName, type: 'data-type', filePath: newName, isNew: true })
-
-      return { ok: true }
-    },
-  },
-
-  serverActions: {
-    deleteRequest: (name) => {
-      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'server' })
-    },
-
-    delete: (name) => {
-      const state = getState()
-      state.projectActions.deleteServer(name)
-      state.editorActions.removeModel(name)
-      state.fileActions.removeFile({ name })
-      state.tabsActions.removeTab(name)
-
-      const currentEditor = state.editor
-      if (currentEditor.type !== 'available' && currentEditor.meta.name === name) {
-        state.editorActions.clearEditor()
-      }
-
-      return { ok: true }
-    },
-
-    rename: (oldName, newName) => {
-      const state = getState()
-      const result = state.projectActions.updateServerName(oldName, newName)
-      if (!result.ok) return { ok: false, message: result.message }
-
-      state.editorActions.updateEditorName(oldName, newName)
-      state.fileActions.updateFile({ name: oldName, newName })
-      state.tabsActions.updateTabName(oldName, newName)
-
-      return { ok: true }
-    },
-  },
-
-  remoteDeviceActions: {
-    deleteRequest: (name) => {
-      getState().modalActions.openModal('confirm-delete-element', { name, elementType: 'remote-device' })
-    },
-
-    delete: (name) => {
-      const state = getState()
-      state.projectActions.deleteRemoteDevice(name)
-      state.editorActions.removeModel(name)
-      state.fileActions.removeFile({ name })
-      state.tabsActions.removeTab(name)
-
-      const currentEditor = state.editor
-      if (currentEditor.type !== 'available' && currentEditor.meta.name === name) {
-        state.editorActions.clearEditor()
-      }
-
-      return { ok: true }
-    },
-
-    rename: (oldName, newName) => {
-      const state = getState()
-      const result = state.projectActions.updateRemoteDeviceName(oldName, newName)
-      if (!result.ok) return { ok: false, message: result.message }
-
-      state.editorActions.updateEditorName(oldName, newName)
-      state.fileActions.updateFile({ name: oldName, newName })
-      state.tabsActions.updateTabName(oldName, newName)
-
-      return { ok: true }
-    },
-  },
-
-  sharedWorkspaceActions: {
-    handleFileAndWorkspaceSavedState: (name) => {
-      const { file } = getState().fileActions.getFile({ name })
-      if (!file) {
-        console.warn(`File with name ${name} does not exist.`)
-        return
-      }
-
-      if (file.saved) {
-        getState().fileActions.updateFile({ name, saved: false })
-      }
-
-      if (getState().workspace.editingState !== 'unsaved') {
-        getState().workspaceActions.setEditingState('unsaved')
-      }
-    },
-
-    forceCloseFile: (name) => {
-      getState().tabsActions.removeTab(name)
-
-      const filteredTabs = getState().tabs
-      const nextTab = filteredTabs[filteredTabs.length - 1]
-      if (!nextTab) {
-        getState().editorActions.setEditor({ type: 'available', meta: { name: '' } })
-        getState().tabsActions.setSelectedTab('')
-        getState().workspaceActions.setSelectedProjectTreeLeaf({ label: '', type: null })
-        return { success: true }
-      }
-
-      const editor =
-        getState().editorActions.getEditorFromEditors(nextTab.name) || CreateEditorObjectFromTab(nextTab)
-      getState().editorActions.setEditor(editor)
-      getState().tabsActions.setSelectedTab(nextTab.name)
-      getState().workspaceActions.setSelectedProjectTreeLeaf({
-        label: nextTab.name,
-        type: nextTab.elementType.type,
-      })
-
-      return { success: true }
-    },
-
-    closeProject: () => {
-      const editingState = getState().workspace.editingState
-      const isFilesSaved = getState().fileActions.checkIfAllFilesAreSaved()
-
-      if (!isFilesSaved || editingState === 'unsaved') {
-        getState().modalActions.openModal('save-changes-project', {
-          validationContext: 'close-project',
-        })
-        return
-      }
-      getState().sharedWorkspaceActions.clearStatesOnCloseProject()
-    },
-
-    clearStatesOnCloseProject: () => {
-      getState().editorActions.clearEditor()
-      getState().tabsActions.clearTabs()
-      getState().libraryActions.clearUserLibraries()
-      getState().fbdFlowActions.clearFBDFlows()
-      getState().ladderFlowActions.clearLadderFlows()
-      getState().projectActions.clearProjects()
-      getState().deviceActions.clearDeviceDefinitions()
-      getState().workspaceActions.clearWorkspace()
-      getState().fileActions.clearFiles()
-      getState().consoleActions.clearLogs()
-      getState().historyActions.clearHistory()
-      getState().searchActions.clearSearch()
-      getState().modalActions.closeModal()
-    },
-  },
-
-  snapshotActions: {
-    pushToHistory: (pouName, snapshot) => {
-      setState(
-        produce((state: SharedRootState) => {
-          if (!state.undoRedo[pouName]) {
-            state.undoRedo[pouName] = { past: [], future: [] }
-          }
-          const history = state.undoRedo[pouName]
-          history.past.push(snapshot)
-          if (history.past.length > MAX_HISTORY_SIZE) {
-            history.past.shift()
-          }
-          history.future = []
-        }),
-      )
-    },
-
-    undo: (pouName) => {
-      const state = getState()
-      const history = state.undoRedo[pouName]
-      if (!history || history.past.length === 0) return
-
-      const snapshot = history.past[history.past.length - 1]
-      const pou = state.project.data.pous.find((p) => p.name === pouName)
-      if (!pou) return
-
-      // Save current state to future
-      const currentSnapshot = {
-        variables: pou.interface?.variables ?? [],
-        body: pou.body.value,
-        globalVariables: state.project.data.configurations.resource.globalVariables,
-      }
-
-      setState(
-        produce((s: SharedRootState) => {
-          const h = s.undoRedo[pouName]
-          /* istanbul ignore next -- defensive: history verified above before produce */
-          if (!h) return
-          h.past.pop()
-          h.future.push(currentSnapshot)
-        }),
-      )
-
-      state.projectActions.applyPouSnapshot(pouName, snapshot.variables, {
-        language: pou.body.language,
-        value: snapshot.body,
-      })
-      if (snapshot.globalVariables) {
-        state.projectActions.setGlobalVariables({ variables: snapshot.globalVariables })
-      }
-    },
-
-    redo: (pouName) => {
-      const state = getState()
-      const history = state.undoRedo[pouName]
-      if (!history || history.future.length === 0) return
-
-      const snapshot = history.future[history.future.length - 1]
-      const pou = state.project.data.pous.find((p) => p.name === pouName)
-      if (!pou) return
-
-      // Save current state to past
-      const currentSnapshot = {
-        variables: pou.interface?.variables ?? [],
-        body: pou.body.value,
-        globalVariables: state.project.data.configurations.resource.globalVariables,
-      }
-
-      setState(
-        produce((s: SharedRootState) => {
-          const h = s.undoRedo[pouName]
-          /* istanbul ignore next -- defensive: history verified above before produce */
-          if (!h) return
-          h.future.pop()
-          h.past.push(currentSnapshot)
-        }),
-      )
-
-      state.projectActions.applyPouSnapshot(pouName, snapshot.variables, {
-        language: pou.body.language,
-        value: snapshot.body,
-      })
-      if (snapshot.globalVariables) {
-        state.projectActions.setGlobalVariables({ variables: snapshot.globalVariables })
-      }
-    },
-  },
-})
-
-export { createSharedSlice }
diff --git a/src2/frontend/store/slices/workspace/index.ts b/src2/frontend/store/slices/workspace/index.ts
deleted file mode 100644
index 7d4450e11..000000000
--- a/src2/frontend/store/slices/workspace/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export { createWorkspaceSlice } from './slice'
-export type { PlcFilters, SystemConfigs, WorkspaceActions, WorkspaceResponse, WorkspaceSlice, WorkspaceState } from './types'
diff --git a/src2/globals.d.ts b/src_old/globals.d.ts
similarity index 57%
rename from src2/globals.d.ts
rename to src_old/globals.d.ts
index e84c01bba..3390eaa0c 100644
--- a/src2/globals.d.ts
+++ b/src_old/globals.d.ts
@@ -14,10 +14,3 @@ declare const APP_VERSION: string
  * @example "2026-01-26"
  */
 declare const BUILD_DATE: string
-
-/**
- * Vitest-compatible `vi` global — aliased to `jest` in Jest via jest-vi-shim.ts
- * so shared test files can use `vi.spyOn()` in both Jest and Vitest.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-declare const vi: typeof jest
diff --git a/src2/i18next.d.ts b/src_old/i18next.d.ts
similarity index 68%
rename from src2/i18next.d.ts
rename to src_old/i18next.d.ts
index daf5ee68d..03713e2be 100644
--- a/src2/i18next.d.ts
+++ b/src_old/i18next.d.ts
@@ -1,4 +1,4 @@
-import { defaultNS, resources } from './frontend/locales/i18n'
+import { defaultNS, resources } from './utils/i18n'
 
 declare module 'i18next' {
   interface CustomTypeOptions {
diff --git a/src2/frontend/locales/en/controls.json b/src_old/locales/en/controls.json
similarity index 100%
rename from src2/frontend/locales/en/controls.json
rename to src_old/locales/en/controls.json
diff --git a/src2/frontend/locales/en/createPOU.json b/src_old/locales/en/createPOU.json
similarity index 100%
rename from src2/frontend/locales/en/createPOU.json
rename to src_old/locales/en/createPOU.json
diff --git a/src2/frontend/locales/en/createProject.json b/src_old/locales/en/createProject.json
similarity index 100%
rename from src2/frontend/locales/en/createProject.json
rename to src_old/locales/en/createProject.json
diff --git a/src2/frontend/locales/en/editorTools.json b/src_old/locales/en/editorTools.json
similarity index 100%
rename from src2/frontend/locales/en/editorTools.json
rename to src_old/locales/en/editorTools.json
diff --git a/src2/frontend/locales/en/getProject.json b/src_old/locales/en/getProject.json
similarity index 100%
rename from src2/frontend/locales/en/getProject.json
rename to src_old/locales/en/getProject.json
diff --git a/src2/frontend/locales/en/index.ts b/src_old/locales/en/index.ts
similarity index 100%
rename from src2/frontend/locales/en/index.ts
rename to src_old/locales/en/index.ts
diff --git a/src2/frontend/locales/en/menu.json b/src_old/locales/en/menu.json
similarity index 100%
rename from src2/frontend/locales/en/menu.json
rename to src_old/locales/en/menu.json
diff --git a/src2/frontend/locales/en/navigation.json b/src_old/locales/en/navigation.json
similarity index 100%
rename from src2/frontend/locales/en/navigation.json
rename to src_old/locales/en/navigation.json
diff --git a/src2/frontend/locales/en/openProject.json b/src_old/locales/en/openProject.json
similarity index 100%
rename from src2/frontend/locales/en/openProject.json
rename to src_old/locales/en/openProject.json
diff --git a/src2/frontend/locales/en/powerRail.json b/src_old/locales/en/powerRail.json
similarity index 100%
rename from src2/frontend/locales/en/powerRail.json
rename to src_old/locales/en/powerRail.json
diff --git a/src2/frontend/locales/en/powerRailProperties.json b/src_old/locales/en/powerRailProperties.json
similarity index 100%
rename from src2/frontend/locales/en/powerRailProperties.json
rename to src_old/locales/en/powerRailProperties.json
diff --git a/src2/frontend/locales/en/projectServiceResponses.json b/src_old/locales/en/projectServiceResponses.json
similarity index 100%
rename from src2/frontend/locales/en/projectServiceResponses.json
rename to src_old/locales/en/projectServiceResponses.json
diff --git a/src2/frontend/locales/en/saveProject.json b/src_old/locales/en/saveProject.json
similarity index 100%
rename from src2/frontend/locales/en/saveProject.json
rename to src_old/locales/en/saveProject.json
diff --git a/src2/frontend/locales/en/settings.json b/src_old/locales/en/settings.json
similarity index 100%
rename from src2/frontend/locales/en/settings.json
rename to src_old/locales/en/settings.json
diff --git a/src2/frontend/locales/en/tools.json b/src_old/locales/en/tools.json
similarity index 100%
rename from src2/frontend/locales/en/tools.json
rename to src_old/locales/en/tools.json
diff --git a/src2/frontend/locales/en/translation.json b/src_old/locales/en/translation.json
similarity index 100%
rename from src2/frontend/locales/en/translation.json
rename to src_old/locales/en/translation.json
diff --git a/src2/frontend/locales/en/variables.json b/src_old/locales/en/variables.json
similarity index 100%
rename from src2/frontend/locales/en/variables.json
rename to src_old/locales/en/variables.json
diff --git a/src_old/main/contracts/dtos/index.ts b/src_old/main/contracts/dtos/index.ts
new file mode 100644
index 000000000..3de680005
--- /dev/null
+++ b/src_old/main/contracts/dtos/index.ts
@@ -0,0 +1,3 @@
+export { CreateProjectRequestData, CreateProjectResponse } from './services/project/create-project.dto'
+export { OpenProjectRequestData, OpenProjectResponse } from './services/project/open-project.dto'
+export { SaveProjectRequestData, SaveProjectResponse } from './services/project/save-project.dto'
diff --git a/src_old/main/contracts/dtos/services/base-response.dto.ts b/src_old/main/contracts/dtos/services/base-response.dto.ts
new file mode 100644
index 000000000..0ee04d69c
--- /dev/null
+++ b/src_old/main/contracts/dtos/services/base-response.dto.ts
@@ -0,0 +1,27 @@
+/**
+ * Represents the response format for service operations.
+ * @template T - The type of data included in the response.
+ */
+export type BaseResponse<T = unknown> = {
+  /**
+   * Indicates the success status of the service operation.
+   */
+  ok: boolean
+  /**
+   * Optional details about the failure reason, if applicable.
+   */
+  reason?: {
+    /**
+     * Title describing the reason for failure.
+     */
+    title: string
+    /**
+     * Additional description providing context about the failure.
+     */
+    description?: string
+  }
+  /**
+   * Optional data returned from the service operation.
+   */
+  data?: T
+}
diff --git a/src_old/main/contracts/dtos/services/project/create-project.dto.ts b/src_old/main/contracts/dtos/services/project/create-project.dto.ts
new file mode 100644
index 000000000..4b45a4268
--- /dev/null
+++ b/src_old/main/contracts/dtos/services/project/create-project.dto.ts
@@ -0,0 +1,8 @@
+import { TXmlProject } from '../../../../../shared/contracts/types'
+import { BaseResponse } from '../base-response.dto'
+
+export type CreateProjectRequestData = never
+export type CreateProjectResponse = BaseResponse<{
+  path: string
+  xmlAsObject: TXmlProject
+}>
diff --git a/src_old/main/contracts/dtos/services/project/open-project.dto.ts b/src_old/main/contracts/dtos/services/project/open-project.dto.ts
new file mode 100644
index 000000000..e40daab59
--- /dev/null
+++ b/src_old/main/contracts/dtos/services/project/open-project.dto.ts
@@ -0,0 +1,8 @@
+import { TXmlProject } from '../../../../../shared/contracts/types'
+import { BaseResponse } from '../base-response.dto'
+
+export type OpenProjectRequestData = never
+export type OpenProjectResponse = BaseResponse<{
+  path: string
+  xmlAsObject: TXmlProject
+}>
diff --git a/src_old/main/contracts/dtos/services/project/save-project.dto.ts b/src_old/main/contracts/dtos/services/project/save-project.dto.ts
new file mode 100644
index 000000000..cb29113ea
--- /dev/null
+++ b/src_old/main/contracts/dtos/services/project/save-project.dto.ts
@@ -0,0 +1,8 @@
+import { TXmlProject } from '../../../../../shared/contracts/types'
+import { BaseResponse } from '../base-response.dto'
+
+export type SaveProjectRequestData = {
+  projectPath: string
+  projectAsObj: TXmlProject
+}
+export type SaveProjectResponse = BaseResponse
diff --git a/src_old/main/contracts/dtos/theme.dto.ts b/src_old/main/contracts/dtos/theme.dto.ts
new file mode 100644
index 000000000..7fc7b2fad
--- /dev/null
+++ b/src_old/main/contracts/dtos/theme.dto.ts
@@ -0,0 +1,3 @@
+import { TThemeType } from '../types/theme'
+
+export type ThemeDto = TThemeType
diff --git a/src/main/contracts/types/child-window.ts b/src_old/main/contracts/types/child-window.ts
similarity index 100%
rename from src/main/contracts/types/child-window.ts
rename to src_old/main/contracts/types/child-window.ts
diff --git a/src/main/contracts/types/modules/ipc/main.ts b/src_old/main/contracts/types/modules/ipc/main.ts
similarity index 100%
rename from src/main/contracts/types/modules/ipc/main.ts
rename to src_old/main/contracts/types/modules/ipc/main.ts
diff --git a/src_old/main/contracts/types/modules/ipc/toast.ts b/src_old/main/contracts/types/modules/ipc/toast.ts
new file mode 100644
index 000000000..000ab7b4a
--- /dev/null
+++ b/src_old/main/contracts/types/modules/ipc/toast.ts
@@ -0,0 +1,9 @@
+import { z } from 'zod'
+
+export const ToastSchema = z.object({
+  type: z.enum(['success', 'error', 'warning', 'info']),
+  title: z.string(),
+  description: z.string().optional(),
+})
+
+export type ToastProps = z.infer<typeof ToastSchema>
diff --git a/src_old/main/contracts/types/modules/store.ts b/src_old/main/contracts/types/modules/store.ts
new file mode 100644
index 000000000..4ef6e035f
--- /dev/null
+++ b/src_old/main/contracts/types/modules/store.ts
@@ -0,0 +1,5 @@
+import { z } from 'zod'
+
+import { StoreSchema } from '../../validations'
+
+export type TStoreType = z.infer<typeof StoreSchema>
diff --git a/src_old/main/contracts/types/services/project.service.d.ts b/src_old/main/contracts/types/services/project.service.d.ts
new file mode 100644
index 000000000..a5a3f48ab
--- /dev/null
+++ b/src_old/main/contracts/types/services/project.service.d.ts
@@ -0,0 +1,12 @@
+import { ResponseService } from './response'
+
+type Service = object
+export type ProjectDto = {
+  projectPath: string
+  projectAsObj?: object
+}
+
+export type TProjectService = Service & {
+  createProject: () => Promise<ResponseService<ProjectDto>>
+  saveProject: (data: ProjectDto) => Promise<ResponseService>
+}
diff --git a/src_old/main/contracts/types/services/response.d.ts b/src_old/main/contracts/types/services/response.d.ts
new file mode 100644
index 000000000..ad71c92e3
--- /dev/null
+++ b/src_old/main/contracts/types/services/response.d.ts
@@ -0,0 +1,27 @@
+/**
+ * Represents the response format for service operations.
+ * @template T - The type of data included in the response.
+ */
+export type ResponseService<T = unknown> = {
+  /**
+   * Indicates the success status of the service operation.
+   */
+  ok: boolean
+  /**
+   * Optional details about the failure reason, if applicable.
+   */
+  reason?: {
+    /**
+     * Title describing the reason for failure.
+     */
+    title: string
+    /**
+     * Additional description providing context about the failure.
+     */
+    description?: string
+  }
+  /**
+   * Optional data returned from the service operation.
+   */
+  data?: T
+}
diff --git a/src_old/main/contracts/types/theme.ts b/src_old/main/contracts/types/theme.ts
new file mode 100644
index 000000000..4cda1dcb5
--- /dev/null
+++ b/src_old/main/contracts/types/theme.ts
@@ -0,0 +1,7 @@
+import { z } from 'zod'
+
+import { ThemeSchema } from '../validations'
+
+export type TThemeType = z.infer<typeof ThemeSchema>
+
+export { ThemeSchema }
diff --git a/src_old/main/contracts/types/toast.ts b/src_old/main/contracts/types/toast.ts
new file mode 100644
index 000000000..0d1439b5e
--- /dev/null
+++ b/src_old/main/contracts/types/toast.ts
@@ -0,0 +1,9 @@
+import { z } from 'zod'
+
+export const toastSchema = z.object({
+  type: z.enum(['success', 'error', 'warning', 'info']),
+  title: z.string(),
+  description: z.string().optional(),
+})
+
+export type ToastProps = z.infer<typeof toastSchema>
diff --git a/src_old/main/contracts/validations/index.ts b/src_old/main/contracts/validations/index.ts
new file mode 100644
index 000000000..87a7331b0
--- /dev/null
+++ b/src_old/main/contracts/validations/index.ts
@@ -0,0 +1,2 @@
+export { default as StoreSchema } from './store-validation'
+export { default as ThemeSchema } from './theme-validation'
diff --git a/src_old/main/contracts/validations/store-validation.ts b/src_old/main/contracts/validations/store-validation.ts
new file mode 100644
index 000000000..ff92f1c12
--- /dev/null
+++ b/src_old/main/contracts/validations/store-validation.ts
@@ -0,0 +1,16 @@
+import z from 'zod'
+
+const StoreSchema = z.object({
+  last_projects: z.array(z.string()),
+  theme: z.string(),
+  window: z.object({
+    bounds: z.object({
+      width: z.number(),
+      height: z.number(),
+      x: z.number(),
+      y: z.number(),
+    }),
+  }),
+})
+
+export default StoreSchema
diff --git a/src/main/contracts/validations/theme-validation.ts b/src_old/main/contracts/validations/theme-validation.ts
similarity index 100%
rename from src/main/contracts/validations/theme-validation.ts
rename to src_old/main/contracts/validations/theme-validation.ts
diff --git a/src_old/main/main.ts b/src_old/main/main.ts
new file mode 100644
index 000000000..a448eb19e
--- /dev/null
+++ b/src_old/main/main.ts
@@ -0,0 +1,413 @@
+/**
+ * This module executes inside of electron's main process. You can start
+ * electron renderer process from here and communicate with the other processes
+ * through IPC.
+ *
+ * When running `npm run build` or `npm run build:main`, this file is compiled to
+ * `./src/main.js` using webpack. This gives us some performance wins.
+ */
+import { app, BrowserWindow, ipcMain, Menu, shell } from 'electron'
+import Installer from 'electron-devtools-installer'
+import log from 'electron-log'
+import { autoUpdater } from 'electron-updater'
+import { enableMapSet } from 'immer'
+import { platform, release } from 'os'
+import { join, resolve } from 'path'
+
+// TODO: Refactor this type declaration
+import { MainIpcModuleConstructor } from './contracts/types/modules/ipc/main'
+import MenuBuilder from './menu'
+import { CompilerModule } from './modules/compiler'
+import { HardwareModule } from './modules/hardware'
+import MainProcessBridge from './modules/ipc/main'
+import { store } from './modules/store'
+import { PouService, ProjectService, UserService } from './services'
+import { resolveHtmlPath } from './utils'
+
+enableMapSet()
+
+class AppUpdater {
+  constructor() {
+    log.transports.file.level = 'info'
+    autoUpdater.logger = log
+    void autoUpdater.checkForUpdatesAndNotify()
+  }
+}
+
+Menu.setApplicationMenu(null)
+
+export let mainWindow: BrowserWindow | null = null
+export let splash: BrowserWindow | null = null
+
+if (process.env.NODE_ENV === 'production') {
+  async function loadSourceMapSupport(): Promise<void> {
+    const sourceMapSupport = await import('source-map-support')
+    sourceMapSupport.install()
+  }
+
+  void loadSourceMapSupport()
+}
+
+// Create the user service instance to initialize the user settings and history files.
+new UserService()
+
+// Retrieves the system information
+const systemInfo = platform()
+// The options to use when creating the titlebar. Type comes from electron.
+type OptTitlebar = {
+  titleBarStyle?: 'hidden' | 'default' | 'hiddenInset' | 'customButtonsOnHover'
+  titlebarOverlay: boolean
+  frame: boolean
+}
+
+const titlebarOptionsMap: Record<string, OptTitlebar> = {
+  darwin: {
+    titleBarStyle: 'hidden',
+    titlebarOverlay: true,
+    frame: false,
+  },
+  win32: {
+    titleBarStyle: 'hidden',
+    titlebarOverlay: false,
+    frame: false,
+  },
+  // Default for everything else (including other Unix variants)
+  default: {
+    titleBarStyle: 'default',
+    titlebarOverlay: true,
+    frame: true,
+  },
+}
+
+const titlebarStyles = titlebarOptionsMap[systemInfo] || titlebarOptionsMap.default
+
+const isDebug = process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true'
+
+if (isDebug) {
+  void import('electron-debug')
+}
+
+const installExtensions = async () => {
+  const installer = await import('electron-devtools-installer')
+  const forceDownload = !!process.env.UPGRADE_EXTENSIONS
+  const extensions = ['REACT_DEVELOPER_TOOLS']
+
+  return installer
+    .default(
+      extensions.map((name) => installer[name as keyof typeof Installer]),
+      forceDownload,
+    )
+    .catch(console.log)
+}
+
+const createMainWindow = async () => {
+  // Check if the application is on debug method, install the extensions
+  if (isDebug) {
+    await installExtensions()
+  }
+  // Create a string with the resources folder path based on app environment;
+  const RESOURCES_PATH = app.isPackaged ? join(process.resourcesPath, 'assets') : join(__dirname, '../../assets')
+
+  /**
+   * Create a function that return the asset that the name was given;
+   */
+  const getAssetPath = (...paths: string[]): string => join(RESOURCES_PATH, ...paths)
+
+  /**
+   * Get the window bounds from the store.
+   */
+  const { bounds } = store.get('window')
+
+  /**
+   * Splash window configuration
+   */
+
+  splash = new BrowserWindow({
+    width: 580,
+    height: 366,
+    resizable: false,
+    frame: false,
+    show: false,
+    webPreferences: {
+      sandbox: true,
+    },
+  })
+
+  const splashPath = app.isPackaged
+    ? resolve(__dirname, '../main/splash.html')
+    : 'src/main/modules/preload/splash-screen/splash.html'
+  splash
+    .loadFile(splashPath)
+    .then(() => console.log('Splash screen loaded successfully'))
+    .catch((error) => console.error('Error loading splash screen:', error))
+
+  splash.setIgnoreMouseEvents(false)
+
+  splash.once('ready-to-show', () => {
+    splash?.show()
+  })
+
+  splash.on('closed', () => (splash = null))
+
+  /**
+   * Main window configuration
+   */
+
+  // Create the main window instance.
+  mainWindow = new BrowserWindow({
+    minWidth: 1124,
+    minHeight: 628,
+    show: false,
+    icon: getAssetPath('icon.png'),
+    ...titlebarStyles,
+    webPreferences: {
+      sandbox: true,
+      preload: app.isPackaged ? join(__dirname, 'preload.js') : join(__dirname, '../../configs/dll/preload.js'),
+    },
+  })
+
+  // Load the Url or index.html file;
+  void mainWindow.loadURL(resolveHtmlPath('index.html'))
+
+  // Save window bounds on resize, close, and move events
+  const saveBounds = () => {
+    store.set('window.bounds', mainWindow?.getBounds())
+  }
+
+  const isMaximizedWindow = () => {
+    mainWindow?.webContents.send('window-controls:toggle-maximized')
+  }
+
+  /**
+   * -> Ready to show event (https://www.electronjs.org/docs/latest/api/browser-window#event-ready-to-show)
+   * Emitted when the web page has been rendered (while not being shown) and window can be displayed without a visual flash.
+   */
+  mainWindow.once('ready-to-show', () => {
+    if (!mainWindow) {
+      throw new Error('"mainWindow" is not defined')
+    }
+    mainWindow.maximize()
+    if (process.env.START_MINIMIZED) {
+      mainWindow.minimize()
+    }
+    setTimeout(() => {
+      if (splash === null) {
+        mainWindow?.destroy()
+        return
+      }
+      splash.close()
+      mainWindow?.show()
+    }, 3000)
+  })
+
+  /**
+   * -> Close event (https://www.electronjs.org/docs/latest/api/browser-window#event-close)
+   * Emitted when the window is going to be closed. It's emitted before the beforeunload and unload event of the DOM.
+   * Calling event.preventDefault() will cancel the close.
+   */
+  mainWindow.on('close', saveBounds)
+  mainWindow.on('close', () => {
+    console.log('mainWindow close')
+    mainWindow?.webContents.send('window-controls:is-closing')
+  })
+
+  /**
+   * -> Closed event (https://www.electronjs.org/docs/latest/api/browser-window#event-closed)
+   * Emitted when the window is closed. After you have received this event you should remove the reference to the window
+   * and avoid using it any more.
+   */
+  mainWindow.on('closed', () => {
+    console.log('mainWindow closed')
+    mainWindow = null
+  })
+
+  /**
+   * -> Move event (https://www.electronjs.org/docs/latest/api/browser-window#event-move)
+   * Emitted when the window is being moved to a new position.
+   */
+  mainWindow.on('move', saveBounds)
+
+  /**
+   * -> Maximize event (https://www.electronjs.org/docs/latest/api/browser-window#event-maximize)
+   * Emitted when the window is maximized.
+   */
+  mainWindow.on('maximize', () => {
+    isMaximizedWindow()
+  })
+
+  /**
+   * -> Unmaximize event (https://www.electronjs.org/docs/latest/api/browser-window#event-unmaximize)
+   * Emitted when the window exits from a maximized state.
+   */
+  mainWindow.on('unmaximize', () => {
+    isMaximizedWindow()
+  })
+
+  /**
+   * -> Resize event (https://www.electronjs.org/docs/latest/api/browser-window#event-resize)
+   */
+  // Emitted after the window has been resized.
+  mainWindow.on('resize', saveBounds)
+
+  // Maximize the window if bounds are not set
+  if (!bounds) {
+    mainWindow.maximize()
+  }
+
+  // Open devtools if the app is not packaged;
+  if (isDebug) {
+    mainWindow.webContents.openDevTools()
+  }
+
+  // Open urls in the user's browser
+  mainWindow.webContents.setWindowOpenHandler((edata) => {
+    void shell.openExternal(edata.url)
+    return { action: 'deny' }
+  })
+
+  /**
+   * Add event listeners...
+   */
+
+  // mainWindow.webContents.send('editor:getBaseTypes', _editorService.getBaseTypes())
+
+  // Handles the creation of the menu
+  const menuBuilder = new MenuBuilder(mainWindow)
+  void menuBuilder.buildMenu()
+
+  /**
+   * Creates a singleton instance for project service, which will be used across the entire application
+   */
+  const projectService = new ProjectService(mainWindow)
+
+  /**
+   * Creates a singleton instance for POU service, which will be used across the entire application
+   */
+  const pouService = new PouService()
+
+  /**
+   * Creates a singleton instance for compiler service, which will be used across the entire application
+   */
+
+  const compilerModule = new CompilerModule()
+
+  const hardwareModule = new HardwareModule()
+
+  const mainIpcModule = new MainProcessBridge({
+    mainWindow,
+    ipcMain,
+    projectService,
+    store,
+    menuBuilder,
+    pouService,
+    compilerModule,
+    hardwareModule,
+  } as unknown as MainIpcModuleConstructor)
+  mainIpcModule.setupMainIpcListener()
+
+  // Remove this if your app does not use auto updates;
+  new AppUpdater()
+}
+
+// Disable GPU Acceleration for Windows 7;
+if (release().startsWith('6.1')) app.disableHardwareAcceleration()
+
+// Set application name for Windows 10+ notifications;
+if (process.platform === 'win32') app.setAppUserModelId(app.getName())
+
+// Ensure only one instance of the application is running;
+if (!app.requestSingleInstanceLock()) {
+  app.quit()
+  process.exit(0)
+}
+
+/**
+ * App event listeners
+ */
+
+/**
+ * -> Active event #MACOS (https://www.electronjs.org/docs/latest/api/app#event-activate-macos)
+ * emitted when the application is activated. Various actions can trigger this event, such as launching the
+ * application for the first time, attempting to re-launch the application when it's already running, or clicking on
+ * the application's dock or taskbar icon.
+ */
+app.on('activate', () => {
+  if (mainWindow === null) {
+    void createMainWindow()
+  } else {
+    mainWindow.show()
+  }
+})
+
+/**
+ * -> Before-quit event (https://www.electronjs.org/docs/latest/api/app#event-before-quit)
+ * Emitted before the application starts closing its windows. Calling event.preventDefault() will prevent the default behavior,
+ * which is terminating the application.
+ */
+app.on('before-quit', () => {
+  console.log('before-quit')
+  if (process.platform === 'darwin' && process.env.NODE_ENV === 'production') {
+    mainWindow?.webContents.send('app:darwin-is-closing')
+    return
+  }
+  mainWindow?.destroy()
+})
+
+/**
+ * -> Will-quit event (https://www.electronjs.org/docs/latest/api/app#event-will-quit)
+ * Emitted when all windows have been closed and the application will quit. Calling event.preventDefault() will prevent the default
+ * behavior, which is terminating the application.
+ */
+app.on('will-quit', () => {
+  console.log('will-quit')
+})
+
+/**
+ * -> Quit event (https://www.electronjs.org/docs/latest/api/app#event-quit)
+ */
+// Emitted when the application is quitting.
+app.on('quit', () => {
+  console.log('quit')
+})
+
+/**
+ * -> Will-quit event (https://www.electronjs.org/docs/latest/api/app#event-will-quit)
+ * If you do not subscribe to this event and all windows are closed, the default behavior is to quit the app; however, if you subscribe,
+ * you control whether the app quits or not. If the user pressed Cmd + Q, or the developer called app.quit(), Electron will first try to
+ * close all the windows and then emit the will-quit event, and in this case the window-all-closed event would not be emitted.
+ */
+// --> Quit the app when all windows are closed except on macOS. There, it's common for applications and their menu bar to stay active;
+app.on('window-all-closed', () => {
+  console.log('window-all-closed')
+  // Respect the OSX convention of having the application in memory even
+  // after all windows have been closed
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+/**
+ * -> Second-instance event (https://www.electronjs.org/docs/latest/api/app#event-second-instance)
+ */
+// Handle second instance of the app;
+app.on('second-instance', () => {
+  if (mainWindow) {
+    // Focus on the main window if the user tried to open another
+    if (mainWindow.isMinimized()) mainWindow.restore()
+    mainWindow.focus()
+  }
+})
+
+// Create the main window when the app is ready;
+app
+  .whenReady()
+  .then(() => {
+    void createMainWindow()
+    // Handle the app activation event;
+    app.on('activate', () => {
+      // On macOS it's common to re-create a window in the app when the
+      // dock icon is clicked and there are no other windows open.
+      if (mainWindow === null) void createMainWindow()
+    })
+  })
+  .catch(console.log)
diff --git a/src_old/main/menu.ts b/src_old/main/menu.ts
new file mode 100644
index 000000000..f2bde2c96
--- /dev/null
+++ b/src_old/main/menu.ts
@@ -0,0 +1,687 @@
+import { BrowserWindow, Menu, MenuItemConstructorOptions, nativeTheme, shell } from 'electron'
+
+import { i18n } from '../utils/i18n'
+import { store } from './modules/store'
+import { ProjectService } from './services'
+
+/**
+ * Wip: Interface for mac machines menu.
+ */
+interface DarwinMenuItemConstructorOptions extends MenuItemConstructorOptions {
+  selector?: string
+  submenu?: DarwinMenuItemConstructorOptions[] | Menu
+}
+
+/**
+ * Class to manage the creation of menu.
+ * @class MenuBuilder
+ */
+export default class MenuBuilder {
+  private mainWindow: BrowserWindow
+  private projectService: ProjectService
+
+  developOptions: MenuItemConstructorOptions[] = [
+    { type: 'separator' },
+    { role: 'reload' },
+    { role: 'forceReload' },
+    { role: 'toggleDevTools' },
+  ]
+
+  constructor(mainWindow: BrowserWindow) {
+    this.mainWindow = mainWindow
+    this.projectService = new ProjectService(mainWindow)
+  }
+
+  async buildMenu(): Promise<Menu> {
+    if (process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true') {
+      this.setupDevelopmentEnvironment()
+    }
+
+    // Todo: Can be used to construct a different menu for mac machines.
+    const template =
+      process.platform === 'darwin' ? await this.buildDarwinTemplate() : await this.buildDefaultTemplate()
+
+    const menu = Menu.buildFromTemplate(template)
+    Menu.setApplicationMenu(menu)
+
+    return menu
+  }
+
+  handleCreateProject() {
+    this.mainWindow.webContents.send('project:create-accelerator')
+  }
+
+  sendOpenRequest() {
+    this.mainWindow.webContents.send('project:open-project-request')
+  }
+
+  handleSaveProject() {
+    this.mainWindow.webContents.send('project:save-accelerator')
+  }
+
+  handleSaveFile() {
+    this.mainWindow.webContents.send('project:save-file-accelerator')
+  }
+
+  handleExportProjectRequest(xmlFormatTarget: 'old-editor' | 'codesys') {
+    this.mainWindow.webContents.send('compiler:export-project-request', xmlFormatTarget)
+  }
+
+  async handleGetRecent() {
+    const response = await this.projectService.readProjectHistory(this.projectService.getHistoryProjectsFilePath())
+    return response
+  }
+
+  async handleOpenProjectByPath(projectPath: string) {
+    const response = await this.projectService.openProjectByPath(projectPath)
+    this.mainWindow.webContents.send('project:open-recent-accelerator', response)
+  }
+
+  handleCloseTab() {
+    this.mainWindow.webContents.send('workspace:close-tab-accelerator')
+  }
+
+  handleCloseProject() {
+    this.mainWindow.webContents.send('workspace:close-project-accelerator')
+  }
+
+  handleDeletePou() {
+    this.mainWindow.webContents.send('workspace:delete-file-accelerator')
+  }
+
+  handleSwitchPerspective() {
+    this.mainWindow.webContents.send('workspace:switch-perspective-accelerator')
+  }
+
+  async handleOpenExternalLink(link: string) {
+    try {
+      await shell.openExternal(link)
+    } catch (error) {
+      console.error('Failed to open external link:', error)
+      this.mainWindow.webContents.send('error:external-link', {
+        message: 'Failed to open external link',
+        error,
+      })
+    }
+  }
+
+  handleOpenAboutModal() {
+    this.mainWindow.webContents.send('about:open-accelerator')
+  }
+
+  handleFindInProject() {
+    this.mainWindow.webContents.send('project:find-in-project-accelerator')
+  }
+
+  handleQuitAppRequest() {
+    this.mainWindow.webContents.send('window-controls:request-close')
+  }
+
+  handleUndoRequest() {
+    this.mainWindow.webContents.send('edit:undo-request')
+  }
+  handleRedoRequest() {
+    this.mainWindow.webContents.send('edit:redo-request')
+  }
+
+  /**
+   * --------------------------------------------------------------------------------------------
+   */
+
+  setupDevelopmentEnvironment(): void {
+    this.mainWindow.webContents.on('context-menu', (_, props) => {
+      const { x, y } = props
+
+      Menu.buildFromTemplate([
+        {
+          label: 'Inspect element',
+          click: () => {
+            this.mainWindow.webContents.inspectElement(x, y)
+          },
+        },
+      ]).popup({ window: this.mainWindow })
+    })
+  }
+
+  updateAppTheme() {
+    const newTheme = nativeTheme.shouldUseDarkColors ? 'light' : 'dark'
+    nativeTheme.themeSource = newTheme
+    store.set('theme', newTheme)
+    this.mainWindow.webContents.send('system:update-theme')
+    void this.buildMenu()
+  }
+
+  /**
+   * Menu construction -------------------------------------------------------
+   */
+  /**
+   * Construct a menu instance for OXS.
+   */
+  async buildDarwinTemplate(): Promise<MenuItemConstructorOptions[]> {
+    const recent = await this.handleGetRecent()
+    const homeDir = process.env.HOME || ''
+    const defaultDarwinMenu: MenuItemConstructorOptions = {
+      role: 'appMenu',
+    }
+
+    const subMenuFile: DarwinMenuItemConstructorOptions = {
+      label: i18n.t('menu:file.label'),
+      submenu: [
+        {
+          label: i18n.t('menu:file.submenu.newProject'),
+          accelerator: 'Cmd+N',
+          click: () => void this.handleCreateProject(),
+        },
+        {
+          label: i18n.t('menu:file.submenu.openProject'),
+          accelerator: 'Cmd+O',
+          click: () => this.sendOpenRequest(),
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:file.submenu.save'),
+          accelerator: 'Cmd+S',
+          click: () => this.handleSaveFile(),
+        },
+        {
+          label: i18n.t('menu:file.submenu.saveProject'),
+          accelerator: 'Cmd+Shift+S',
+          click: () => this.handleSaveProject(),
+        },
+        {
+          label: i18n.t('menu:file.submenu.saveAs'),
+          accelerator: 'Cmd+Shift+A',
+          click: () => {},
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:file.submenu.closeTab'),
+          accelerator: 'Cmd+W',
+          click: () => this.handleCloseTab(),
+        },
+        {
+          label: i18n.t('menu:file.submenu.closeProject'),
+          accelerator: 'Cmd+Shift+W',
+          click: () => this.handleCloseProject(),
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:file.submenu.exportToPLCOpenXml'),
+          click: () => this.handleExportProjectRequest('old-editor'),
+        },
+        {
+          label: i18n.t('menu:file.submenu.exportToCodesysXml'),
+          click: () => this.handleExportProjectRequest('codesys'),
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:file.submenu.pageSetup'),
+          accelerator: 'Cmd+Option+P',
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:file.submenu.preview'),
+          accelerator: 'Cmd+Shift+P',
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:file.submenu.print'),
+          accelerator: 'Cmd+P',
+          enabled: false,
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:file.submenu.updates'),
+          accelerator: 'Cmd+U',
+          enabled: false,
+        },
+      ],
+    }
+
+    const subMenuEdit: DarwinMenuItemConstructorOptions = {
+      label: i18n.t('menu:edit.label'),
+      submenu: [
+        {
+          label: i18n.t('menu:edit.submenu.undo'),
+          accelerator: 'Cmd+Z',
+          click: () => this.handleUndoRequest(),
+        },
+        {
+          label: i18n.t('menu:edit.submenu.redo'),
+          accelerator: 'Cmd+Shift+Z',
+          click: () => this.handleRedoRequest(),
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:edit.submenu.cut'),
+          accelerator: 'Cmd+X',
+          selector: 'cut:',
+          enabled: true,
+        },
+        {
+          label: i18n.t('menu:edit.submenu.copy'),
+          accelerator: 'Cmd+C',
+          selector: 'copy:',
+          enabled: true,
+        },
+        {
+          label: i18n.t('menu:edit.submenu.paste'),
+          accelerator: 'Cmd+V',
+          selector: 'paste:',
+          enabled: true,
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:edit.submenu.find'),
+          accelerator: 'Cmd+F',
+          selector: 'find:',
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:edit.submenu.findNext'),
+          accelerator: 'Cmd+K',
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:edit.submenu.findPrevious'),
+          accelerator: 'Cmd+Shift+K',
+          enabled: false,
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:edit.submenu.findInProject'),
+          accelerator: '',
+          click: () => this.handleFindInProject(),
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:edit.submenu.addElement.label'),
+          enabled: false,
+          submenu: [
+            {
+              label: i18n.t('menu:edit.submenu.addElement.submenu.functionBlock'),
+            },
+            {
+              label: i18n.t('menu:edit.submenu.addElement.submenu.function'),
+            },
+            {
+              label: i18n.t('menu:edit.submenu.addElement.submenu.program'),
+            },
+            {
+              label: i18n.t('menu:edit.submenu.addElement.submenu.dataType'),
+            },
+          ],
+        },
+        {
+          label: i18n.t('menu:edit.submenu.selectAll'),
+          accelerator: 'Cmd+A',
+          selector: 'selectAll:',
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:edit.submenu.deletePou'),
+          accelerator: 'Cmd+backspace',
+          // role: 'delete',
+          click: () => this.handleDeletePou(),
+        },
+      ],
+    }
+
+    const subMenuDisplay: DarwinMenuItemConstructorOptions = {
+      label: i18n.t('menu:display.label'),
+      submenu: [
+        {
+          label: i18n.t('menu:display.submenu.refresh'),
+          accelerator: 'Cmd+R',
+          selector: 'reload:',
+          enabled: false,
+        },
+        {
+          label: i18n.t('menu:display.submenu.clearErrors'),
+          accelerator: '',
+          enabled: false,
+        },
+        { type: 'separator' },
+        {
+          label: 'Zoom', // Todo: i18n.t('menu:display.submenu.zoom') have to be added
+          enabled: false,
+          submenu: [
+            {
+              label: i18n.t('menu:display.submenu.zoomIn'),
+              accelerator: 'Cmd+Plus',
+            },
+            {
+              label: i18n.t('menu:display.submenu.zoomOut'),
+              accelerator: 'Cmd+-',
+            },
+          ],
+        },
+        { type: 'separator' },
+        {
+          label: i18n.t('menu:display.submenu.switchPerspective'),
+          accelerator: 'F12',
+          click: () => this.handleSwitchPerspective(),
+        },
+        {
+          label: i18n.t('menu:display.submenu.fullScreen'),
+          accelerator: 'Shift+F12',
+          role: 'togglefullscreen',
+        },
+        {
+          label: i18n.t('menu:display.submenu.sortAlpha'),
+          enabled: false,
+        },
+        {
+          type: 'separator',
+        },
+        {
+          label: i18n.t('menu:display.submenu.theme'),
+          sublabel: nativeTheme.shouldUseDarkColors ? 'Dark' : 'Light',
+          click: () => this.updateAppTheme(),
+        },
+      ],
+    }
+
+    const subMenuRecent: DarwinMenuItemConstructorOptions = {
+      label: i18n.t('menu:recent'),
+      submenu: recent.map((projectEntry) => {
+        const projectPath = projectEntry.path.startsWith(homeDir)
+          ? projectEntry.path.replace(homeDir, '~')
+          : projectEntry.path
+        const projectName = projectEntry.name
+
+        return {
+          label: `${projectName} (${projectPath})`,
+          click: () => {
+            void this.handleOpenProjectByPath(projectEntry.path)
+          },
+        }
+      }),
+    }
+
+    const subMenuHelp: DarwinMenuItemConstructorOptions = {
+      label: i18n.t('menu:help.label'),
+      submenu: [
+        {
+          label: i18n.t('menu:help.submenu.communitySupport'),
+          click: () => void this.handleOpenExternalLink('https://openplc.discussion.community/'),
+        },
+        {
+          label: i18n.t('menu:help.submenu.about'),
+          accelerator: 'F1',
+          click: () => void this.handleOpenAboutModal(),
+        },
+      ],
+    }
+
+    return [defaultDarwinMenu, subMenuFile, subMenuEdit, subMenuDisplay, subMenuHelp, subMenuRecent]
+  }
+
+  /**
+   * Construct a default menu instance.
+   */
+  async buildDefaultTemplate() {
+    const recent = await this.handleGetRecent()
+    const homeDir = process.env.HOME || ''
+    const templateDefault: MenuItemConstructorOptions[] = [
+      {
+        label: i18n.t('menu:file.label'),
+        visible: false,
+        submenu: [
+          {
+            label: i18n.t('menu:file.submenu.newProject'),
+            accelerator: 'Ctrl+N',
+            click: () => this.handleCreateProject(),
+          },
+          {
+            label: i18n.t('menu:file.submenu.openProject'),
+            accelerator: 'Ctrl+O',
+            click: () => this.sendOpenRequest(),
+          },
+          {
+            type: 'separator',
+          },
+          {
+            label: i18n.t('menu:file.submenu.save'),
+            accelerator: 'Ctrl+S',
+            click: () => this.handleSaveFile(),
+          },
+          {
+            label: i18n.t('menu:file.submenu.saveProject'),
+            accelerator: 'Ctrl+Shift+S',
+            click: () => this.handleSaveProject(),
+          },
+          {
+            label: i18n.t('menu:file.submenu.saveAs'),
+            accelerator: 'Ctrl+Shift+A',
+            enabled: false,
+          },
+          {
+            label: i18n.t('menu:file.submenu.closeTab'),
+            accelerator: 'Ctrl+W',
+            click: () => this.handleCloseTab(),
+          },
+          {
+            label: i18n.t('menu:file.submenu.closeProject'),
+            accelerator: 'Ctrl+Shift+W',
+            click: () => this.handleCloseProject(),
+          },
+          {
+            type: 'separator',
+          },
+          {
+            label: i18n.t('menu:file.submenu.exportToPLCOpenXml'),
+            click: () => this.handleExportProjectRequest('old-editor'),
+          },
+          {
+            label: i18n.t('menu:file.submenu.exportToCodesysXml'),
+            click: () => this.handleExportProjectRequest('codesys'),
+          },
+          {
+            type: 'separator',
+          },
+          {
+            label: i18n.t('menu:file.submenu.pageSetup'),
+            enabled: false,
+            accelerator: 'Ctrl+Alt+P',
+          },
+          {
+            label: i18n.t('menu:file.submenu.preview'),
+            enabled: false,
+            accelerator: 'Ctrl+Shift+P',
+          },
+          {
+            label: i18n.t('menu:file.submenu.print'),
+            accelerator: 'Ctrl+P',
+            enabled: false,
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:file.submenu.updates'),
+            enabled: false,
+            accelerator: 'Ctrl+U',
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:file.submenu.quit'),
+            // role: 'quit',
+            accelerator: 'Ctrl+Q',
+            click: () => this.handleQuitAppRequest(),
+          },
+        ],
+      },
+      {
+        label: i18n.t('menu:edit.label'),
+        submenu: [
+          {
+            label: i18n.t('menu:edit.submenu.undo'),
+            accelerator: 'Ctrl+Z',
+            click: () => this.handleUndoRequest(),
+          },
+          {
+            label: i18n.t('menu:edit.submenu.redo'),
+            accelerator: 'Ctrl+Shift+Z',
+            click: () => this.handleRedoRequest(),
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:edit.submenu.cut'),
+            enabled: true,
+            accelerator: 'Ctrl+X',
+            role: 'cut',
+          },
+          {
+            label: i18n.t('menu:edit.submenu.copy'),
+            enabled: true,
+            accelerator: 'Ctrl+C',
+            role: 'copy',
+          },
+          {
+            label: i18n.t('menu:edit.submenu.paste'),
+            enabled: true,
+            accelerator: 'Ctrl+V',
+            role: 'paste',
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:edit.submenu.find'),
+            enabled: false,
+            accelerator: 'Ctrl+F',
+          },
+          {
+            label: i18n.t('menu:edit.submenu.findNext'),
+            accelerator: 'Ctrl+K',
+            enabled: false,
+          },
+          {
+            label: i18n.t('menu:edit.submenu.findPrevious'),
+            accelerator: 'Ctrl+Shift+K',
+            enabled: false,
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:edit.submenu.findInProject'),
+            accelerator: 'Ctrl+Shift+F',
+            click: () => this.handleFindInProject(),
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:edit.submenu.addElement.label'),
+            enabled: false,
+            submenu: [
+              {
+                label: i18n.t('menu:edit.submenu.addElement.submenu.functionBlock'),
+              },
+              {
+                label: i18n.t('menu:edit.submenu.addElement.submenu.function'),
+              },
+              {
+                label: i18n.t('menu:edit.submenu.addElement.submenu.program'),
+              },
+              {
+                label: i18n.t('menu:edit.submenu.addElement.submenu.dataType'),
+              },
+            ],
+          },
+          {
+            label: i18n.t('menu:edit.submenu.selectAll'),
+            enabled: false,
+            accelerator: 'Ctrl+A',
+            role: 'selectAll',
+          },
+          {
+            label: i18n.t('menu:edit.submenu.deletePou'),
+            accelerator: 'Ctrl+Shift+delete',
+            click: () => this.handleDeletePou(),
+          },
+        ],
+      },
+      {
+        label: i18n.t('menu:display.label'),
+        submenu: [
+          {
+            label: i18n.t('menu:display.submenu.refresh'),
+            role: 'reload',
+            enabled: false,
+          },
+          {
+            label: i18n.t('menu:display.submenu.clearErrors'),
+            enabled: false,
+            accelerator: '',
+          },
+          { type: 'separator' },
+          {
+            label: 'Zoom',
+            enabled: false,
+            submenu: [
+              {
+                label: i18n.t('menu:display.submenu.zoomIn'),
+                accelerator: 'Ctrl+Plus',
+              },
+              {
+                label: i18n.t('menu:display.submenu.zoomOut'),
+                accelerator: 'Ctrl+-',
+              },
+            ],
+          },
+          { type: 'separator' },
+          {
+            label: i18n.t('menu:display.submenu.switchPerspective'),
+            accelerator: 'F12',
+            click: () => this.handleSwitchPerspective(),
+          },
+          {
+            label: i18n.t('menu:display.submenu.fullScreen'),
+            role: 'togglefullscreen',
+          },
+          {
+            label: i18n.t('menu:display.submenu.sortAlpha'),
+            enabled: false,
+          },
+          {
+            type: 'separator',
+          },
+          {
+            label: i18n.t('menu:display.submenu.theme'),
+            sublabel: nativeTheme.shouldUseDarkColors ? 'Dark' : 'Light',
+            click: () => this.updateAppTheme(),
+          },
+        ],
+      },
+      {
+        label: i18n.t('menu:help.label'),
+        role: 'help',
+        submenu: [
+          {
+            label: i18n.t('menu:help.submenu.communitySupport'),
+            click: () => void this.handleOpenExternalLink('https://openplc.discussion.community/'),
+          },
+          {
+            label: i18n.t('menu:help.submenu.about'),
+            accelerator: 'F1',
+            click: () => this.handleOpenAboutModal(),
+          },
+        ],
+      },
+
+      {
+        label: i18n.t('menu:recent'),
+        submenu: recent.map((projectEntry) => {
+          const projectPath = projectEntry.path.startsWith(homeDir)
+            ? projectEntry.path.replace(homeDir, '~')
+            : projectEntry.path
+          const projectName = projectEntry.name
+
+          return {
+            label: `${projectName} (${projectPath})`,
+            click: () => {
+              void this.handleOpenProjectByPath(projectEntry.path)
+            },
+          }
+        }),
+      },
+    ]
+
+    return templateDefault
+  }
+}
diff --git a/src_old/main/modules/compiler/compiler-module.spec.ts b/src_old/main/modules/compiler/compiler-module.spec.ts
new file mode 100644
index 000000000..c41cb7dd2
--- /dev/null
+++ b/src_old/main/modules/compiler/compiler-module.spec.ts
@@ -0,0 +1,40 @@
+import { CompilerModule } from './compiler-module'
+
+describe('CompilerModule', () => {
+  let compilerModule: CompilerModule
+
+  beforeEach(() => {
+    compilerModule = new CompilerModule()
+  })
+
+  it('should be defined and instantiated successfully', () => {
+    expect(compilerModule).toBeDefined()
+    expect(compilerModule).toBeInstanceOf(CompilerModule)
+  })
+
+  it('should have expected static properties', () => {
+    expect(typeof CompilerModule.HOST_PLATFORM).toBe('string')
+    expect(['x64', 'arm64', 'ia32', 'arm']).toContain(CompilerModule.HOST_ARCHITECTURE)
+    expect(typeof CompilerModule.DEVELOPMENT_MODE).toBe('boolean')
+    expect(Array.isArray(CompilerModule.GLOBAL_LIBRARIES)).toBe(true)
+    expect(CompilerModule.GLOBAL_LIBRARIES.length).toBeGreaterThan(0)
+  })
+
+  it('should initialize directory and binary paths', () => {
+    expect(typeof compilerModule.binaryDirectoryPath).toBe('string')
+    expect(typeof compilerModule.sourceDirectoryPath).toBe('string')
+    expect(typeof compilerModule.arduinoCliBinaryPath).toBe('string')
+    expect(typeof compilerModule.arduinoCliConfigurationFilePath).toBe('string')
+    expect(Array.isArray(compilerModule.arduinoCliBaseParameters)).toBe(true)
+    expect(typeof compilerModule.xml2stBinaryPath).toBe('string')
+    expect(typeof compilerModule.iec2cBinaryPath).toBe('string')
+  })
+
+  it('getHostHardwareInfo should return a string containing hardware info', () => {
+    const info = compilerModule.getHostHardwareInfo()
+    expect(typeof info).toBe('string')
+    expect(info).toContain('System Architecture')
+    expect(info).toContain('Operating System')
+    expect(info).toContain('Logical CPU Cores')
+  })
+})
diff --git a/src/main/modules/compiler/compiler-module.ts b/src_old/main/modules/compiler/compiler-module.ts
similarity index 100%
rename from src/main/modules/compiler/compiler-module.ts
rename to src_old/main/modules/compiler/compiler-module.ts
diff --git a/src_old/main/modules/compiler/compiler-types.ts b/src_old/main/modules/compiler/compiler-types.ts
new file mode 100644
index 000000000..2d3bdea8f
--- /dev/null
+++ b/src_old/main/modules/compiler/compiler-types.ts
@@ -0,0 +1,50 @@
+import { z } from 'zod/v4'
+
+const ArduinoCliConfigSchema = z.object({
+  board_manager: z.object({
+    additional_urls: z.array(z.string()),
+  }),
+  output: z.object({
+    no_color: z.boolean(),
+  }),
+})
+
+type ArduinoCliConfig = z.infer<typeof ArduinoCliConfigSchema>
+
+const ArduinoCoreControlSchema = z.array(z.record(z.string(), z.string()))
+
+type ArduinoCoreControl = z.infer<typeof ArduinoCoreControlSchema>
+
+const BoardInfoSchema = z.object({
+  compiler: z.enum(['arduino-cli', 'openplc-compiler', 'simulator']),
+  core: z.string(),
+  default_ain: z.string(),
+  default_aout: z.string(),
+  default_din: z.string(),
+  default_dout: z.string(),
+  updatedAt: z.number(),
+  platform: z.string(),
+  source: z.string(),
+  version: z.string(),
+  board_manager_url: z.string().optional(),
+  extra_libraries: z.array(z.string()).optional(),
+  define: z.union([z.string(), z.array(z.string())]).optional(),
+  user_ain: z.string().optional(),
+  user_aout: z.string().optional(),
+  user_din: z.string().optional(),
+  user_dout: z.string().optional(),
+  c_flags: z.array(z.string()).optional(),
+  cxx_flags: z.array(z.string()).optional(),
+  ld_flags: z.array(z.string()).optional(),
+  arch: z.string().optional(),
+})
+
+type BoardInfo = z.infer<typeof BoardInfoSchema>
+
+const HalsFileSchema = z.record(z.string(), BoardInfoSchema)
+
+type HalsFile = z.infer<typeof HalsFileSchema>
+
+export { ArduinoCliConfigSchema, ArduinoCoreControlSchema, BoardInfoSchema, HalsFileSchema }
+
+export type { ArduinoCliConfig, ArduinoCoreControl, BoardInfo, HalsFile }
diff --git a/src_old/main/modules/compiler/index.ts b/src_old/main/modules/compiler/index.ts
new file mode 100644
index 000000000..444d07545
--- /dev/null
+++ b/src_old/main/modules/compiler/index.ts
@@ -0,0 +1,2 @@
+export * from './compiler-module'
+export * from './compiler-types'
diff --git a/src_old/main/modules/compiler/utils/formatters.ts b/src_old/main/modules/compiler/utils/formatters.ts
new file mode 100644
index 000000000..9f828ccb4
--- /dev/null
+++ b/src_old/main/modules/compiler/utils/formatters.ts
@@ -0,0 +1,6 @@
+const FormatMacAddress = (rawMacAddress: string) => {
+  const macParts = rawMacAddress.split(':')
+  const formattedMac = macParts.map((part) => `0x${part.toUpperCase()}`).join(', ')
+  return formattedMac
+}
+export { FormatMacAddress }
diff --git a/src_old/main/modules/hardware/hardware-module.ts b/src_old/main/modules/hardware/hardware-module.ts
new file mode 100644
index 000000000..ad8c2695f
--- /dev/null
+++ b/src_old/main/modules/hardware/hardware-module.ts
@@ -0,0 +1,209 @@
+import { exec } from 'node:child_process'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+
+import { app as electronApp } from 'electron'
+import { produce } from 'immer'
+
+import type { AvailableBoards, HalsFile, SerialPort } from './hardware-types'
+
+// interface MethodsResult<T> {
+//   success: boolean
+//   data?: T
+// }
+
+class HardwareModule {
+  binaryDirectoryPath: string
+  sourcesDirectoryPath: string
+
+  arduinoCliBinaryPath: string
+  arduinoCliConfigurationFilePath: string
+  arduinoCliBaseParameters: string[]
+  arduinoCoreFilePath: string
+
+  // ############################################################################
+  // =========================== Static properties ==============================
+  // ############################################################################
+  static readonly HOST_PLATFORM = process.platform
+  static readonly HOST_ARCHITECTURE = process.arch
+  static readonly DEVELOPMENT_MODE = process.env.NODE_ENV === 'development'
+
+  constructor() {
+    this.binaryDirectoryPath = this.#constructBinaryDirectoryPath()
+    this.sourcesDirectoryPath = this.#constructSourceDirectoryPath()
+
+    this.arduinoCliBinaryPath = this.#constructArduinoCliBinaryPath()
+    this.arduinoCliConfigurationFilePath = join(electronApp.getPath('userData'), 'User', 'arduino-cli.yaml')
+    // INFO: We use this approach because some commands can receive additional parameters as a string array.
+    this.arduinoCliBaseParameters = ['--config-file', this.arduinoCliConfigurationFilePath]
+    this.arduinoCoreFilePath = this.#constructArduinoCoreFilePath()
+  }
+
+  // ############################################################################
+  // =========================== Static methods =================================
+  // ############################################################################
+
+  static async readJSONFile<T>(filePath: string): Promise<T> {
+    const data = await readFile(filePath, 'utf-8')
+    return JSON.parse(data) as T
+  }
+
+  // ############################################################################
+  // =========================== Private methods ================================
+  // ############################################################################
+
+  // Initialize paths based on the environment
+  #constructBinaryDirectoryPath(): string {
+    if (HardwareModule.HOST_ARCHITECTURE !== 'x64' && HardwareModule.HOST_ARCHITECTURE !== 'arm64') return ''
+    const platformSpecificPath = join(HardwareModule.HOST_PLATFORM, HardwareModule.HOST_ARCHITECTURE)
+    return join(
+      HardwareModule.DEVELOPMENT_MODE ? process.cwd() : process.resourcesPath,
+      HardwareModule.DEVELOPMENT_MODE ? 'resources' : '',
+      'bin',
+      HardwareModule.DEVELOPMENT_MODE ? platformSpecificPath : '',
+    )
+  }
+
+  #constructSourceDirectoryPath(): string {
+    return join(
+      HardwareModule.DEVELOPMENT_MODE ? process.cwd() : process.resourcesPath,
+      HardwareModule.DEVELOPMENT_MODE ? 'resources' : '',
+      'sources',
+    )
+  }
+
+  // TODO: Validate the path.
+  #constructArduinoCliBinaryPath(): string {
+    return join(this.binaryDirectoryPath, 'arduino-cli')
+  }
+
+  #constructArduinoCoreFilePath(): string {
+    return join(electronApp.getPath('userData'), 'User', 'Runtime', 'arduino-core-control.json')
+  }
+
+  // ############################################################################
+  // =========================== Public methods =================================
+  // ############################################################################
+
+  // ++ ============================= Getters ================================ ++
+  async getAvailableSerialPorts(): Promise<SerialPort[]> {
+    let xml2stBinaryPath = join(
+      this.binaryDirectoryPath,
+      'xml2st',
+      HardwareModule.HOST_PLATFORM === 'darwin' ? 'xml2st' : '',
+    )
+    if (HardwareModule.HOST_PLATFORM === 'win32') {
+      xml2stBinaryPath += '.exe'
+    }
+    const executeCommand = promisify(exec)
+
+    try {
+      const { stdout, stderr } = await executeCommand(`"${xml2stBinaryPath}" --list-ports`)
+
+      if (stderr) {
+        console.warn('xml2st stderr output:', stderr)
+      }
+
+      let normalizedOutputString: SerialPort[] = [{ name: '', address: 'fallback' }]
+
+      if (stdout) {
+        try {
+          const parsedOutput = JSON.parse(stdout) as {
+            ports: {
+              name: string
+              address: string
+            }[]
+          }
+          normalizedOutputString = parsedOutput.ports.map((port) => ({
+            name: port.name ?? port.address,
+            address: port.address,
+          }))
+        } catch (parseError: unknown) {
+          console.error('Failed to parse xml2st output:', parseError)
+          return []
+        }
+      }
+
+      return normalizedOutputString
+    } catch (execError: unknown) {
+      console.error('Failed to execute xml2st:', execError)
+      return []
+    }
+  }
+
+  async getAvailableBoards(): Promise<AvailableBoards> {
+    // Construct the path to the hals.json file
+    const halsFilePath = join(this.sourcesDirectoryPath, 'boards', 'hals.json')
+
+    // Read the content of the necessary files - hals.json and arduino-core-control.json
+    const halsFileContent = await HardwareModule.readJSONFile<HalsFile>(halsFilePath)
+    const arduinoCoreFileContent = await HardwareModule.readJSONFile<{ [core: string]: string }[]>(
+      this.arduinoCoreFilePath,
+    )
+
+    // Create a Map to store the available boards, which will be returned
+    let availableBoards: AvailableBoards = new Map()
+
+    for (const [board, boardData] of Object.entries(halsFileContent)) {
+      const coreVersion = arduinoCoreFileContent.find((core) => Object.keys(core)[0] === boardData.core)?.[
+        boardData.core
+      ]
+
+      availableBoards = produce(availableBoards, (draft) => {
+        draft.set(board, {
+          compiler: boardData.compiler,
+          core: boardData.core,
+          preview: boardData.preview,
+          specs: boardData.specs,
+          coreVersion: coreVersion ?? undefined,
+          pins: {
+            defaultAin:
+              boardData.default_ain
+                ?.split(',')
+                .map((pin) => pin.trim())
+                .filter(Boolean) ?? [],
+            defaultAout:
+              boardData.default_aout
+                ?.split(',')
+                .map((pin) => pin.trim())
+                .filter(Boolean) ?? [],
+            defaultDin:
+              boardData.default_din
+                ?.split(',')
+                .map((pin) => pin.trim())
+                .filter(Boolean) ?? [],
+            defaultDout:
+              boardData.default_dout
+                ?.split(',')
+                .map((pin) => pin.trim())
+                .filter(Boolean) ?? [],
+          },
+        })
+      })
+    }
+    // Sort boards alphabetically by name
+    const sortedBoards: AvailableBoards = new Map([...availableBoards.entries()].sort(([a], [b]) => a.localeCompare(b)))
+    return sortedBoards
+  }
+
+  async getBoardImagePreview(image: string) {
+    const imagePath = join(this.sourcesDirectoryPath, 'boards', 'previews', image)
+
+    const imageBuffer = await readFile(imagePath)
+
+    const base64Image = imageBuffer.toString('base64')
+
+    return `data:image/png;base64,${base64Image}`
+  }
+
+  async getDeviceConfigurationOptions() {
+    const [communicationPorts, availableBoards] = await Promise.allSettled([
+      this.getAvailableSerialPorts(),
+      this.getAvailableBoards(),
+    ])
+    return { ports: communicationPorts, boards: availableBoards }
+  }
+}
+
+export { HardwareModule }
diff --git a/src_old/main/modules/hardware/hardware-types.ts b/src_old/main/modules/hardware/hardware-types.ts
new file mode 100644
index 000000000..6d69ec4c1
--- /dev/null
+++ b/src_old/main/modules/hardware/hardware-types.ts
@@ -0,0 +1,94 @@
+import { z } from 'zod/v4'
+
+const SerialPortSchema = z.object({
+  name: z.string(),
+  address: z.string(),
+})
+
+type SerialPort = z.infer<typeof SerialPortSchema>
+
+const BoardInfoSchema = z.object({
+  board_manager_url: z.string().optional(),
+  compiler: z.string(),
+  core: z.string(),
+  c_flags: z.array(z.string()).optional(),
+  cxx_flags: z.array(z.string()).optional(),
+  ld_flags: z.array(z.string()).optional(),
+  default_ain: z.string(),
+  default_aout: z.string(),
+  default_din: z.string(),
+  default_dout: z.string(),
+  define: z.string().or(z.array(z.string())).optional(),
+  extra_libraries: z.array(z.string()).optional(),
+  platform: z.string(),
+  preview: z.string(),
+  source: z.string(),
+  specs: z.object({
+    CPU: z.string(),
+    RAM: z.string(),
+    Flash: z.string(),
+    DigitalPins: z.string(),
+    AnalogPins: z.string(),
+    PWMPins: z.string(),
+    WiFi: z.string(),
+    Bluetooth: z.string(),
+    Ethernet: z.string(),
+  }),
+  user_ain: z.string().optional(),
+  user_aout: z.string().optional(),
+  user_din: z.string().optional(),
+  user_dout: z.string().optional(),
+})
+
+type BoardInfo = z.infer<typeof BoardInfoSchema>
+
+const HalsFileSchema = z.record(z.string(), BoardInfoSchema)
+
+type HalsFile = z.infer<typeof HalsFileSchema>
+
+const availableBoardsSchema = z.map(
+  z.string(),
+  z.object({
+    coreVersion: z.string().optional(),
+    pins: z.object({
+      defaultAin: z.array(z.string()).optional(),
+      defaultAout: z.array(z.string()).optional(),
+      defaultDin: z.array(z.string()).optional(),
+      defaultDout: z.array(z.string()).optional(),
+    }),
+    ...BoardInfoSchema.pick({ compiler: true, core: true, preview: true, specs: true }),
+  }),
+)
+
+// !! We're not able to infer the type of the Map directly from the schema, so we define it manually.
+// !! This is a workaround to ensure type safety when using the schema.
+type AvailableBoards = Map<
+  string,
+  {
+    compiler: string
+    core: string
+    preview: string
+    specs: {
+      CPU: string
+      RAM: string
+      Flash: string
+      DigitalPins: string
+      AnalogPins: string
+      PWMPins: string
+      WiFi: string
+      Bluetooth: string
+      Ethernet: string
+    }
+    // Optional properties
+    coreVersion?: string
+    pins: {
+      defaultAin?: string[]
+      defaultAout?: string[]
+      defaultDin?: string[]
+      defaultDout?: string[]
+    }
+  }
+>
+
+export { availableBoardsSchema, BoardInfoSchema, HalsFileSchema, SerialPortSchema }
+export type { AvailableBoards, BoardInfo, HalsFile, SerialPort }
diff --git a/src_old/main/modules/hardware/index.ts b/src_old/main/modules/hardware/index.ts
new file mode 100644
index 000000000..b25e3f6d2
--- /dev/null
+++ b/src_old/main/modules/hardware/index.ts
@@ -0,0 +1,2 @@
+export * from './hardware-module'
+export * from './hardware-types'
diff --git a/src_old/main/modules/ipc/main.ts b/src_old/main/modules/ipc/main.ts
new file mode 100644
index 000000000..ae73dde85
--- /dev/null
+++ b/src_old/main/modules/ipc/main.ts
@@ -0,0 +1,1489 @@
+import { getProjectPath } from '@root/main/utils'
+import { CreatePouFileProps } from '@root/types/IPC/pou-service'
+import { CreateProjectFileProps } from '@root/types/IPC/project-service'
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { RuntimeLogEntry } from '@root/types/PLC/runtime-logs'
+import { getRuntimeHttpsOptions } from '@root/utils/runtime-https-config'
+import type { IpcMainEvent, IpcMainInvokeEvent } from 'electron'
+import { app, nativeTheme, shell } from 'electron'
+import { readFile, realpathSync, stat, statSync, unwatchFile, watchFile } from 'fs'
+import type { IncomingMessage } from 'http'
+import https from 'https'
+import { join, resolve, sep } from 'path'
+import { platform } from 'process'
+
+import { ProjectState } from '../../../renderer/store/slices'
+import { PLCPou, PLCProject } from '../../../types/PLC/open-plc'
+import { MainIpcModule, MainIpcModuleConstructor } from '../../contracts/types/modules/ipc/main'
+import { logger } from '../../services'
+import { ModbusTcpClient } from '../modbus/modbus-client'
+import { ModbusRtuClient } from '../modbus/modbus-rtu-client'
+import { SimulatorModule } from '../simulator/simulator-module'
+import { VirtualSerialPort } from '../simulator/virtual-serial-port'
+import { WebSocketDebugClient } from '../websocket/websocket-debug-client'
+
+type IDataToWrite = {
+  projectPath: string
+  content: {
+    pous: PLCPou[]
+    projectData: PLCProject
+    deviceConfiguration: DeviceConfiguration
+    devicePinMapping: DevicePin[]
+  }
+}
+
+class MainProcessBridge implements MainIpcModule {
+  ipcMain
+  mainWindow
+  projectService
+  store
+  menuBuilder
+  pouService
+  compilerModule
+  hardwareModule
+  private debuggerModbusClient: ModbusTcpClient | ModbusRtuClient | null = null
+  private debuggerWebSocketClient: WebSocketDebugClient | null = null
+  private debuggerTargetIp: string | null = null
+  private debuggerReconnecting: boolean = false
+  private debuggerConnectionType: 'tcp' | 'rtu' | 'websocket' | 'simulator' | null = null
+  private debuggerRtuPort: string | null = null
+  private debuggerRtuBaudRate: number | null = null
+  private debuggerRtuSlaveId: number | null = null
+  private debuggerJwtToken: string | null = null
+  private runtimeCredentials: { ipAddress: string; username: string; password: string } | null = null
+  private tokenRefreshInFlight: Promise<{ success: boolean; accessToken?: string; error?: string }> | null = null
+  // Current project root path used to validate file-watcher IPC calls
+  private currentProjectPath: string | null = null
+  // File watchers for auto-reload functionality (using watchFile for better macOS compatibility)
+  private fileWatchers: Map<string, { lastMtime: number }> = new Map()
+  // avr8js ATmega2560 emulator instance for the built-in simulator
+  private simulatorModule = new SimulatorModule()
+
+  constructor({
+    ipcMain,
+    mainWindow,
+    projectService,
+    store,
+    menuBuilder,
+    pouService,
+    compilerModule,
+    hardwareModule,
+  }: MainIpcModuleConstructor) {
+    this.ipcMain = ipcMain
+    this.mainWindow = mainWindow
+    this.projectService = projectService
+    this.store = store
+    this.menuBuilder = menuBuilder
+    this.pouService = pouService
+    this.compilerModule = compilerModule
+    this.hardwareModule = hardwareModule
+  }
+
+  // ===================== RUNTIME API HANDLERS =====================
+  private readonly RUNTIME_API_PORT = 8443
+  private readonly RUNTIME_CONNECTION_TIMEOUT_MS = 5000 // 5 seconds (important-comment)
+
+  handleRuntimeGetUsersInfo = async (_event: IpcMainInvokeEvent, ipAddress: string) => {
+    try {
+      const url = `https://${ipAddress}:${this.RUNTIME_API_PORT}/api/get-users-info`
+
+      return new Promise((resolve) => {
+        const req = https.get(
+          url,
+          {
+            ...getRuntimeHttpsOptions(),
+          },
+          (res: IncomingMessage) => {
+            let data = ''
+            res.on('data', (chunk: Buffer) => {
+              data += chunk.toString()
+            })
+            res.on('end', () => {
+              // Extract runtime version from response header
+              const runtimeVersion = res.headers['x-openplc-runtime-version'] as string | undefined
+
+              if (res.statusCode === 404) {
+                resolve({ hasUsers: false, runtimeVersion })
+              } else if (res.statusCode === 200) {
+                resolve({ hasUsers: true, runtimeVersion })
+              } else {
+                resolve({ hasUsers: false, error: data || `Unexpected status: ${res.statusCode}`, runtimeVersion })
+              }
+            })
+          },
+        )
+        req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
+          req.destroy()
+          resolve({ hasUsers: false, error: 'Connection timeout' })
+        })
+        req.on('error', (error: Error) => {
+          resolve({ hasUsers: false, error: error.message })
+        })
+      })
+    } catch (error) {
+      return { hasUsers: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeCreateUser = async (
+    _event: IpcMainInvokeEvent,
+    ipAddress: string,
+    username: string,
+    password: string,
+  ) => {
+    try {
+      const postData = JSON.stringify({ username, password, role: 'user' })
+
+      return new Promise((resolve) => {
+        const req = https.request(
+          {
+            hostname: ipAddress,
+            port: this.RUNTIME_API_PORT,
+            path: '/api/create-user',
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Content-Length': Buffer.byteLength(postData),
+            },
+            ...getRuntimeHttpsOptions(),
+          },
+          (res: IncomingMessage) => {
+            let data = ''
+            res.on('data', (chunk: Buffer) => {
+              data += chunk.toString()
+            })
+            res.on('end', () => {
+              if (res.statusCode === 201) {
+                resolve({ success: true })
+              } else {
+                resolve({ success: false, error: data })
+              }
+            })
+          },
+        )
+        req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
+          req.destroy()
+          resolve({ success: false, error: 'Connection timeout' })
+        })
+        req.on('error', (error: Error) => {
+          resolve({ success: false, error: error.message })
+        })
+        req.write(postData)
+        req.end()
+      })
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  private async performAuthentication(
+    ipAddress: string,
+    username: string,
+    password: string,
+  ): Promise<{ success: boolean; accessToken?: string; error?: string }> {
+    try {
+      const postData = JSON.stringify({ username, password })
+
+      return new Promise((resolve) => {
+        const req = https.request(
+          {
+            hostname: ipAddress,
+            port: this.RUNTIME_API_PORT,
+            path: '/api/login',
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Content-Length': Buffer.byteLength(postData),
+            },
+            ...getRuntimeHttpsOptions(),
+          },
+          (res: IncomingMessage) => {
+            let data = ''
+            res.on('data', (chunk: Buffer) => {
+              data += chunk.toString()
+            })
+            res.on('end', () => {
+              if (res.statusCode === 200) {
+                try {
+                  const response = JSON.parse(data) as { access_token: string }
+                  resolve({ success: true, accessToken: response.access_token })
+                } catch {
+                  resolve({ success: false, error: 'Invalid response format' })
+                }
+              } else {
+                resolve({ success: false, error: data })
+              }
+            })
+          },
+        )
+        req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
+          req.destroy()
+          resolve({ success: false, error: 'Connection timeout' })
+        })
+        req.on('error', (error: Error) => {
+          resolve({ success: false, error: error.message })
+        })
+        req.write(postData)
+        req.end()
+      })
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeLogin = async (_event: IpcMainInvokeEvent, ipAddress: string, username: string, password: string) => {
+    const result = await this.performAuthentication(ipAddress, username, password)
+    if (result.success && result.accessToken) {
+      this.runtimeCredentials = { ipAddress, username, password }
+    }
+    return result
+  }
+
+  private async attemptTokenRefresh(): Promise<{ success: boolean; accessToken?: string; error?: string }> {
+    if (this.tokenRefreshInFlight) {
+      return this.tokenRefreshInFlight
+    }
+
+    if (!this.runtimeCredentials) {
+      return { success: false, error: 'No stored credentials available for token refresh' }
+    }
+
+    const { ipAddress, username, password } = this.runtimeCredentials
+
+    this.tokenRefreshInFlight = this.performAuthentication(ipAddress, username, password).finally(() => {
+      this.tokenRefreshInFlight = null
+    })
+
+    return this.tokenRefreshInFlight
+  }
+
+  private isTokenExpiredError(statusCode: number | undefined, errorMessage: string): boolean {
+    if (statusCode === 401 || statusCode === 403) {
+      return true
+    }
+    const lowerError = errorMessage.toLowerCase()
+    return (
+      lowerError.includes('unauthorized') ||
+      lowerError.includes('token') ||
+      lowerError.includes('expired') ||
+      lowerError.includes('invalid token')
+    )
+  }
+
+  makeRuntimeApiRequest<T = void>(
+    ipAddress: string,
+    jwtToken: string,
+    endpoint: string,
+    responseParser?: (data: string) => T,
+  ): Promise<{ success: true; data?: T } | { success: false; error: string }> {
+    return new Promise((resolve) => {
+      const req = https.get(
+        `https://${ipAddress}:${this.RUNTIME_API_PORT}${endpoint}`,
+        {
+          headers: {
+            Authorization: `Bearer ${jwtToken}`,
+          },
+          ...getRuntimeHttpsOptions(),
+        },
+        (res: IncomingMessage) => {
+          let data = ''
+          res.on('data', (chunk: Buffer) => {
+            data += chunk.toString()
+          })
+          res.on('end', () => {
+            if (res.statusCode === 200) {
+              if (responseParser) {
+                try {
+                  const parsedData = responseParser(data)
+                  resolve({ success: true, data: parsedData })
+                } catch {
+                  resolve({ success: false, error: 'Invalid response format' })
+                }
+              } else {
+                resolve({ success: true })
+              }
+            } else if (this.isTokenExpiredError(res.statusCode, data)) {
+              void this.attemptTokenRefresh().then((refreshResult) => {
+                if (refreshResult.success && refreshResult.accessToken) {
+                  if (this.mainWindow && this.mainWindow.webContents) {
+                    this.mainWindow.webContents.send('runtime:token-refreshed', refreshResult.accessToken)
+                  }
+                  const retryReq = https.get(
+                    `https://${ipAddress}:${this.RUNTIME_API_PORT}${endpoint}`,
+                    {
+                      headers: {
+                        Authorization: `Bearer ${refreshResult.accessToken}`,
+                      },
+                      ...getRuntimeHttpsOptions(),
+                    },
+                    (retryRes: IncomingMessage) => {
+                      let retryData = ''
+                      retryRes.on('data', (chunk: Buffer) => {
+                        retryData += chunk.toString()
+                      })
+                      retryRes.on('end', () => {
+                        if (retryRes.statusCode === 200) {
+                          if (responseParser) {
+                            try {
+                              const parsedData = responseParser(retryData)
+                              resolve({ success: true, data: parsedData })
+                            } catch {
+                              resolve({ success: false, error: 'Invalid response format' })
+                            }
+                          } else {
+                            resolve({ success: true })
+                          }
+                        } else {
+                          resolve({ success: false, error: retryData })
+                        }
+                      })
+                    },
+                  )
+                  retryReq.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
+                    retryReq.destroy()
+                    resolve({ success: false, error: 'Connection timeout' })
+                  })
+                  retryReq.on('error', (error: Error) => {
+                    resolve({ success: false, error: error.message })
+                  })
+                } else {
+                  resolve({
+                    success: false,
+                    error: refreshResult.error ? `Token refresh failed: ${refreshResult.error}` : data,
+                  })
+                }
+              })
+            } else {
+              resolve({ success: false, error: data })
+            }
+          })
+        },
+      )
+      req.setTimeout(this.RUNTIME_CONNECTION_TIMEOUT_MS, () => {
+        req.destroy()
+        resolve({ success: false, error: 'Connection timeout' })
+      })
+      req.on('error', (error: Error) => {
+        resolve({ success: false, error: error.message })
+      })
+    })
+  }
+
+  handleRuntimeGetStatus = async (
+    _event: IpcMainInvokeEvent,
+    ipAddress: string,
+    jwtToken: string,
+    includeStats?: boolean,
+  ) => {
+    try {
+      // Build the endpoint path with optional include_stats query parameter
+      const endpoint = includeStats ? '/api/status?include_stats=true' : '/api/status'
+
+      const result = await this.makeRuntimeApiRequest<{
+        status: string
+        timing_stats?: {
+          scan_count: number
+          scan_time_min: number | null
+          scan_time_max: number | null
+          scan_time_avg: number | null
+          cycle_time_min: number | null
+          cycle_time_max: number | null
+          cycle_time_avg: number | null
+          cycle_latency_min: number | null
+          cycle_latency_max: number | null
+          cycle_latency_avg: number | null
+          overruns: number
+        }
+      }>(ipAddress, jwtToken, endpoint, (data: string) => {
+        const response = JSON.parse(data) as {
+          status: string
+          timing_stats?: {
+            scan_count: number
+            scan_time_min: number | null
+            scan_time_max: number | null
+            scan_time_avg: number | null
+            cycle_time_min: number | null
+            cycle_time_max: number | null
+            cycle_time_avg: number | null
+            cycle_latency_min: number | null
+            cycle_latency_max: number | null
+            cycle_latency_avg: number | null
+            overruns: number
+          }
+        }
+        return response
+      })
+
+      if (result.success && result.data) {
+        return {
+          success: true,
+          status: result.data.status,
+          timingStats: result.data.timing_stats,
+        }
+      } else {
+        return { success: false, error: !result.success ? result.error : 'Unknown error' }
+      }
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeStartPlc = async (_event: IpcMainInvokeEvent, ipAddress: string, jwtToken: string) => {
+    try {
+      return await this.makeRuntimeApiRequest(ipAddress, jwtToken, '/api/start-plc')
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeStopPlc = async (_event: IpcMainInvokeEvent, ipAddress: string, jwtToken: string) => {
+    try {
+      return await this.makeRuntimeApiRequest(ipAddress, jwtToken, '/api/stop-plc')
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeGetCompilationStatus = async (_event: IpcMainInvokeEvent, ipAddress: string, jwtToken: string) => {
+    try {
+      const result = await this.makeRuntimeApiRequest<{ status: string; logs: string[]; exit_code: number | null }>(
+        ipAddress,
+        jwtToken,
+        '/api/compilation-status',
+        (data: string) => {
+          const response = JSON.parse(data) as { status: string; logs: string[]; exit_code: number | null }
+          return response
+        },
+      )
+      return result
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeGetLogs = async (_event: IpcMainInvokeEvent, ipAddress: string, jwtToken: string, minId?: number) => {
+    try {
+      const endpoint = minId !== undefined ? `/api/runtime-logs?id=${minId}` : '/api/runtime-logs'
+      const result = await this.makeRuntimeApiRequest<string | RuntimeLogEntry[]>(
+        ipAddress,
+        jwtToken,
+        endpoint,
+        (data: string) => {
+          const response = JSON.parse(data) as { 'runtime-logs': string | RuntimeLogEntry[] }
+          return response['runtime-logs']
+        },
+      )
+      if (result.success) {
+        return { success: true, logs: result.data }
+      } else {
+        return { success: false, error: result.error }
+      }
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleRuntimeClearCredentials = (_event: IpcMainInvokeEvent) => {
+    this.runtimeCredentials = null
+    return { success: true }
+  }
+
+  handleRuntimeGetSerialPorts = async (
+    _event: IpcMainInvokeEvent,
+    ipAddress: string,
+    jwtToken: string,
+  ): Promise<{ success: boolean; ports?: Array<{ device: string; description?: string }>; error?: string }> => {
+    try {
+      const result = await this.makeRuntimeApiRequest<{ ports: Array<{ device: string; description?: string }> }>(
+        ipAddress,
+        jwtToken,
+        '/api/serial-ports',
+        (data: string) => {
+          const response = JSON.parse(data) as {
+            ports?: Array<{ device: string; description?: string }>
+            error?: string
+          }
+          if (response.error) {
+            throw new Error(response.error)
+          }
+          return { ports: response.ports || [] }
+        },
+      )
+      if (result.success && result.data) {
+        return { success: true, ports: result.data.ports }
+      } else {
+        return { success: false, error: result.success ? 'No data returned' : result.error }
+      }
+    } catch (error) {
+      return { success: false, error: String(error) }
+    }
+  }
+
+  // ===================== IPC HANDLER REGISTRATION =====================
+  setupMainIpcListener() {
+    // Project-related handlers
+    this.ipcMain.handle('project:create', this.handleProjectCreate)
+    this.ipcMain.handle('project:open', this.handleProjectOpen)
+    this.ipcMain.handle('project:path-picker', this.handleProjectPathPicker)
+    this.ipcMain.handle('project:save', this.handleProjectSave)
+    this.ipcMain.handle('project:save-file', this.handleFileSave)
+    this.ipcMain.handle('project:open-by-path', this.handleProjectOpenByPath)
+
+    // Pou-related handlers
+    this.ipcMain.handle('pou:create', this.handleCreatePouFile)
+    this.ipcMain.handle('pou:delete', this.handleDeletePouFile)
+    this.ipcMain.handle('pou:rename', this.handleRenamePouFile)
+
+    // App and system handlers
+    this.ipcMain.handle('open-external-link', this.handleOpenExternalLink)
+    this.ipcMain.handle('system:get-system-info', this.handleGetSystemInfo)
+    this.ipcMain.handle('app:store-retrieve-recent', this.handleStoreRetrieveRecent)
+    this.ipcMain.on('app:quit', this.handleAppQuit)
+    // this.ipcMain.on('app:reply-if-app-is-closing', (_, shouldQuit) => { ... })
+
+    // Theme and store handlers
+    this.ipcMain.on('system:update-theme', this.mainIpcEventHandlers.handleUpdateTheme)
+    // this.ipcMain.handle('app:store-get', this.mainIpcEventHandlers.getStoreValue)
+
+    // ===================== COMPILER SERVICE =====================
+    // TODO: This handle should be refactored to use MessagePortMain for better performance.
+    this.ipcMain.handle('compiler:export-project-xml', this.handleCompilerExportProjectXml)
+    this.ipcMain.on('compiler:run-compile-program', this.handleRunCompileProgram)
+    this.ipcMain.on('compiler:run-debug-compilation', this.handleRunDebugCompilation)
+
+    // +++ !! Deprecated: These handlers are outdated and should be removed. +++
+
+    // this.ipcMain.on('compiler:setup-environment', this.handleCompilerSetupEnvironment)
+    // this.ipcMain.handle('compiler:create-build-directory', this.handleCompilerCreateBuildDirectory)
+    // this.ipcMain.handle('compiler:build-xml-file', this.handleCompilerBuildXmlFile)
+    // this.ipcMain.on('compiler:build-st-program', this.handleCompilerBuildStProgram)
+    // this.ipcMain.on('compiler:generate-c-files', this.handleCompilerGenerateCFiles)
+
+    // ===================== WINDOW CONTROLS =====================
+    this.ipcMain.on('window-controls:close', this.handleWindowControlsClose)
+    this.ipcMain.on('window-controls:closed', this.handleWindowControlsClosed)
+    this.ipcMain.on('window-controls:hide', this.handleWindowControlsHide)
+    this.ipcMain.on('window-controls:minimize', this.handleWindowControlsMinimize)
+    this.ipcMain.on('window-controls:maximize', this.handleWindowControlsMaximize)
+    this.ipcMain.on('window:reload', this.handleWindowReload)
+    this.ipcMain.on('window:rebuild-menu', this.handleWindowRebuildMenu)
+
+    // ===================== HARDWARE =====================
+    this.ipcMain.handle('hardware:get-available-communication-ports', this.handleHardwareGetAvailableCommunicationPorts)
+    this.ipcMain.handle('hardware:get-available-boards', this.handleHardwareGetAvailableBoards)
+    this.ipcMain.handle('hardware:refresh-communication-ports', this.handleHardwareRefreshCommunicationPorts)
+    this.ipcMain.handle('hardware:refresh-available-boards', this.handleHardwareRefreshAvailableBoards)
+
+    // ===================== UTILITIES =====================
+    this.ipcMain.handle('util:get-preview-image', this.handleUtilGetPreviewImage)
+    this.ipcMain.on('util:log', this.handleUtilLog)
+    this.ipcMain.handle('util:read-debug-file', this.handleReadDebugFile)
+
+    // ===================== DEBUGGER =====================
+    this.ipcMain.handle('debugger:verify-md5', this.handleDebuggerVerifyMd5)
+    this.ipcMain.handle('debugger:read-program-st-md5', this.handleReadProgramStMd5)
+    this.ipcMain.handle('debugger:get-variables-list', this.handleDebuggerGetVariablesList)
+    this.ipcMain.handle('debugger:set-variable', this.handleDebuggerSetVariable)
+    this.ipcMain.handle('debugger:connect', this.handleDebuggerConnect)
+    this.ipcMain.handle('debugger:disconnect', this.handleDebuggerDisconnect)
+
+    // ===================== RUNTIME API =====================
+    this.ipcMain.handle('runtime:get-users-info', this.handleRuntimeGetUsersInfo)
+    this.ipcMain.handle('runtime:create-user', this.handleRuntimeCreateUser)
+    this.ipcMain.handle('runtime:login', this.handleRuntimeLogin)
+    this.ipcMain.handle('runtime:get-status', this.handleRuntimeGetStatus)
+    this.ipcMain.handle('runtime:start-plc', this.handleRuntimeStartPlc)
+    this.ipcMain.handle('runtime:stop-plc', this.handleRuntimeStopPlc)
+    this.ipcMain.handle('runtime:get-compilation-status', this.handleRuntimeGetCompilationStatus)
+    this.ipcMain.handle('runtime:get-logs', this.handleRuntimeGetLogs)
+    this.ipcMain.handle('runtime:clear-credentials', this.handleRuntimeClearCredentials)
+    this.ipcMain.handle('runtime:get-serial-ports', this.handleRuntimeGetSerialPorts)
+
+    // ===================== SIMULATOR =====================
+    this.ipcMain.handle('simulator:load-firmware', this.handleSimulatorLoadFirmware)
+    this.ipcMain.handle('simulator:stop', this.handleSimulatorStop)
+    this.ipcMain.handle('simulator:is-running', this.handleSimulatorIsRunning)
+
+    // ===================== FILE WATCHER =====================
+    this.ipcMain.handle('file:watch-start', this.handleFileWatchStart)
+    this.ipcMain.handle('file:watch-stop', this.handleFileWatchStop)
+    this.ipcMain.handle('file:watch-stop-all', this.handleFileWatchStopAll)
+    this.ipcMain.handle('file:read-content', this.handleFileReadContent)
+  }
+
+  // ===================== HANDLER METHODS =====================
+  // Project-related handlers
+  handleProjectCreate = async (_event: IpcMainInvokeEvent, data: CreateProjectFileProps) => {
+    this.stopSimulatorAndNotify()
+    const response = await this.projectService.createProject(data)
+    return response
+  }
+  handleProjectOpen = async () => {
+    this.stopSimulatorAndNotify()
+    const response = await this.projectService.openProject()
+    if (response.success && response.data?.meta.path) {
+      this.currentProjectPath = response.data.meta.path
+    }
+    return response
+  }
+  handleProjectPathPicker = async (_event: IpcMainInvokeEvent) => {
+    const windowManager = this.mainWindow
+    try {
+      if (windowManager) {
+        const res = await getProjectPath(windowManager)
+        return res
+      }
+      console.error('Window object not defined')
+    } catch (error) {
+      console.error('Error getting project path:', error)
+    }
+  }
+  handleFileSave = async (_event: IpcMainInvokeEvent, filePath: string, content: unknown) => {
+    const result = await this.projectService.saveFile(filePath, content)
+    if (result.success) {
+      // Update lastMtime for the saved file's watcher to suppress self-trigger
+      const watcherData = this.fileWatchers.get(filePath)
+      if (watcherData) {
+        try {
+          const stats = statSync(filePath)
+          if (stats.mtimeMs > watcherData.lastMtime) {
+            watcherData.lastMtime = stats.mtimeMs
+          }
+        } catch {
+          /* file may not exist */
+        }
+      }
+    }
+    return result
+  }
+  handleProjectSave = (_event: IpcMainInvokeEvent, { projectPath, content }: IDataToWrite) =>
+    this.projectService.saveProject({ projectPath, content })
+  handleProjectOpenByPath = async (_event: IpcMainInvokeEvent, projectPath: string) => {
+    this.stopSimulatorAndNotify()
+    try {
+      const response = await this.projectService.openProjectByPath(projectPath)
+      if (response.success && response.data?.meta.path) {
+        this.currentProjectPath = response.data.meta.path
+      }
+      return response
+    } catch (_error) {
+      return {
+        success: false,
+        error: {
+          title: 'Error opening project',
+          description: 'Please try again',
+        },
+      }
+    }
+  }
+
+  // Pou-related handlers
+  handleCreatePouFile = async (_event: IpcMainInvokeEvent, props: CreatePouFileProps) => {
+    try {
+      const response = await this.pouService.createPouFile(props)
+      return response
+    } catch (error) {
+      console.error('Error creating POU file:', error)
+      return {
+        success: false,
+        error: {
+          title: 'Error creating POU file',
+          description: 'Please try again',
+          error,
+        },
+      }
+    }
+  }
+  handleDeletePouFile = async (_event: IpcMainInvokeEvent, filePath: string) => {
+    try {
+      const response = await this.pouService.deletePouFile(filePath)
+      return response
+    } catch (error) {
+      console.error('Error deleting POU file:', error)
+      return {
+        success: false,
+        error: {
+          title: 'Error deleting POU file',
+          description: 'Please try again',
+          error,
+        },
+      }
+    }
+  }
+  handleRenamePouFile = async (
+    _event: IpcMainInvokeEvent,
+    data: {
+      filePath: string
+      newFileName: string
+      fileContent?: unknown
+    },
+  ) => {
+    try {
+      const response = await this.pouService.renamePouFile(data)
+      return response
+    } catch (error) {
+      console.error('Error renaming POU file:', error)
+      return {
+        success: false,
+        error: {
+          title: 'Error renaming POU file',
+          description: 'Please try again',
+          error,
+        },
+      }
+    }
+  }
+
+  // App and system handlers
+  handleOpenExternalLink = async (_event: IpcMainInvokeEvent, url: string) => {
+    try {
+      await shell.openExternal(url)
+      return { success: true }
+    } catch (error) {
+      console.error('Error opening external link:', error)
+      return { success: false, error }
+    }
+  }
+  handleGetSystemInfo = () => {
+    const appStore = this.store as unknown as { get: (key: string) => unknown }
+    const savedTheme = appStore.get('theme')
+    if (savedTheme === 'dark' || savedTheme === 'light') {
+      nativeTheme.themeSource = savedTheme
+    }
+
+    return {
+      OS: platform,
+      architecture: 'x64',
+      prefersDarkMode: nativeTheme.shouldUseDarkColors,
+      isWindowMaximized: this.mainWindow?.isMaximized(),
+    }
+  }
+  handleStoreRetrieveRecent = async () => {
+    const pathToUserDataFolder = join(app.getPath('userData'), 'User')
+    const pathToUserHistoryFolder = join(pathToUserDataFolder, 'History')
+    const projectsFilePath = join(pathToUserHistoryFolder, 'projects.json')
+    const response = await this.projectService.readProjectHistory(projectsFilePath)
+    try {
+      return response
+    } catch (error) {
+      console.error('Error reading history file:', error)
+      return []
+    }
+  }
+  handleAppQuit = () => {
+    this.simulatorModule.stop()
+    if (this.mainWindow) {
+      this.mainWindow.destroy()
+    }
+    app.quit()
+  }
+
+  // Compiler service handlers
+  // TODO: This handle should be refactored to use a new approach on module implementation.
+  handleCompilerExportProjectXml = (
+    _ev: IpcMainInvokeEvent,
+    pathToUserProject: string,
+    dataToCreateXml: ProjectState['data'],
+    xmlFormatTarget: 'old-editor' | 'codesys',
+  ) => this.compilerModule.createXmlFile(pathToUserProject, dataToCreateXml, xmlFormatTarget)
+
+  handleRunCompileProgram = (event: IpcMainEvent, args: Array<string | ProjectState['data']>) => {
+    const mainProcessPort = event.ports[0]
+    void this.compilerModule.compileProgram(args, mainProcessPort, this)
+  }
+
+  handleRunDebugCompilation = (event: IpcMainEvent, args: Array<string | ProjectState['data']>) => {
+    const mainProcessPort = event.ports[0]
+    void this.compilerModule.compileForDebugger(args, mainProcessPort)
+  }
+
+  // TODO: These handlers are outdated and should be removed.
+  // handleCompilerSetupEnvironment = (event: IpcMainEvent) => {
+  //   const replyPort = Array.isArray(event.ports) && event.ports.length > 0 ? event.ports[0] : undefined
+  //   if (replyPort) {
+  //     void this.compilerService.setupEnvironment(replyPort)
+  //   }
+  // }
+  // handleCompilerCreateBuildDirectory = (_ev: IpcMainInvokeEvent, pathToUserProject: string) =>
+  //   this.compilerService.createBuildDirectoryIfNotExist(pathToUserProject)
+  // handleCompilerBuildXmlFile = (
+  //   _ev: IpcMainInvokeEvent,
+  //   pathToUserProject: string,
+  //   dataToCreateXml: ProjectState['data'],
+  // ) => this.compilerService.buildXmlFile(pathToUserProject, dataToCreateXml)
+  // handleCompilerBuildStProgram = (event: IpcMainEvent, pathToXMLFile: string) => {
+  //   const replyPort = Array.isArray(event.ports) && event.ports.length > 0 ? event.ports[0] : undefined
+  //   if (replyPort) {
+  //     this.compilerService.compileSTProgram(pathToXMLFile, replyPort)
+  //   }
+  // }
+  // handleCompilerGenerateCFiles = (event: IpcMainEvent, pathToStProgram: string) => {
+  //   const replyPort = Array.isArray(event.ports) && event.ports.length > 0 ? event.ports[0] : undefined
+  //   if (replyPort) {
+  //     this.compilerService.generateCFiles(pathToStProgram, replyPort)
+  //   }
+  // }
+
+  // Window controls handlers
+  handleWindowControlsClose = () => this.mainWindow?.close()
+  handleWindowControlsClosed = () => this.mainWindow?.destroy()
+  handleWindowControlsHide = () => this.mainWindow?.hide()
+  handleWindowControlsMinimize = () => this.mainWindow?.minimize()
+  handleWindowControlsMaximize = () => {
+    if (this.mainWindow?.isMaximized()) {
+      this.mainWindow?.restore()
+    } else {
+      this.mainWindow?.maximize()
+    }
+  }
+  handleWindowReload = () => {
+    this.simulatorModule.stop()
+    this.mainWindow?.webContents.reload()
+  }
+  handleWindowRebuildMenu = () => void this.menuBuilder.buildMenu()
+
+  // Hardware handlers
+  handleHardwareGetAvailableCommunicationPorts = async () => this.hardwareModule.getAvailableSerialPorts()
+  handleHardwareGetAvailableBoards = async () => this.hardwareModule.getAvailableBoards()
+  handleHardwareRefreshCommunicationPorts = async () => this.hardwareModule.getAvailableSerialPorts()
+  handleHardwareRefreshAvailableBoards = async () => this.hardwareModule.getAvailableBoards()
+
+  // Utility handlers
+  handleUtilGetPreviewImage = async (_event: IpcMainInvokeEvent, image: string) =>
+    this.hardwareModule.getBoardImagePreview(image)
+  handleUtilLog = (_: IpcMainEvent, { level, message }: { level: 'info' | 'error'; message: string }) => {
+    logger[level](message)
+  }
+  handleReadDebugFile = async (_event: IpcMainInvokeEvent, projectPath: string, boardTarget: string) => {
+    try {
+      const fs = await import('fs/promises')
+      const path = await import('path')
+
+      // projectPath is already the project directory, not a file path
+      // Guard against traversal/absolute input in boardTarget
+      if (path.isAbsolute(boardTarget) || boardTarget.includes('..') || boardTarget.includes(path.sep)) {
+        return { success: false, error: 'Invalid board target' }
+      }
+      const debugFilePath = path.resolve(projectPath, 'build', boardTarget, 'src', 'debug.c')
+
+      const content = await fs.readFile(debugFilePath, 'utf-8')
+      return { success: true, content }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to read debug.c file',
+      }
+    }
+  }
+
+  handleDebuggerVerifyMd5 = async (
+    _event: IpcMainInvokeEvent,
+    connectionType: 'tcp' | 'rtu' | 'websocket' | 'simulator',
+    connectionParams: {
+      ipAddress?: string
+      port?: string
+      baudRate?: number
+      slaveId?: number
+      jwtToken?: string
+    },
+    expectedMd5: string,
+  ): Promise<{ success: boolean; match?: boolean; targetMd5?: string; error?: string }> => {
+    let client: ModbusTcpClient | ModbusRtuClient | null = null
+    let wsClient: WebSocketDebugClient | null = null
+    try {
+      if (connectionType === 'simulator') {
+        const virtualPort = new VirtualSerialPort(this.simulatorModule)
+        client = new ModbusRtuClient({
+          port: 'simulator',
+          baudRate: 115200,
+          slaveId: 1,
+          timeout: 5000,
+          serialPort: virtualPort,
+        })
+        await client.connect()
+        const targetMd5 = await client.getMd5Hash()
+        const match = targetMd5.toLowerCase() === expectedMd5.toLowerCase()
+
+        // Keep the client for subsequent debug operations
+        this.debuggerModbusClient = client
+        this.debuggerConnectionType = 'simulator'
+
+        return { success: true, match, targetMd5 }
+      } else if (connectionType === 'websocket') {
+        if (!connectionParams.ipAddress || !connectionParams.jwtToken) {
+          return { success: false, error: 'IP address and JWT token are required for WebSocket connection' }
+        }
+        if (!this.debuggerWebSocketClient) {
+          wsClient = new WebSocketDebugClient({
+            host: connectionParams.ipAddress,
+            port: 8443,
+            token: connectionParams.jwtToken,
+            rejectUnauthorized: false,
+          })
+          await wsClient.connect()
+        } else {
+          wsClient = this.debuggerWebSocketClient
+        }
+
+        const targetMd5 = await wsClient.getMd5Hash()
+
+        const match = targetMd5.toLowerCase() === expectedMd5.toLowerCase()
+
+        if (!this.debuggerWebSocketClient) {
+          this.debuggerWebSocketClient = wsClient
+          this.debuggerTargetIp = connectionParams.ipAddress
+          this.debuggerJwtToken = connectionParams.jwtToken
+          this.debuggerConnectionType = 'websocket'
+        }
+
+        return { success: true, match, targetMd5 }
+      } else if (connectionType === 'tcp') {
+        if (!connectionParams.ipAddress) {
+          return { success: false, error: 'IP address is required for TCP connection' }
+        }
+        client = new ModbusTcpClient({
+          host: connectionParams.ipAddress,
+          port: 502,
+          timeout: 5000,
+        })
+      } else {
+        if (!connectionParams.port || !connectionParams.baudRate || connectionParams.slaveId === undefined) {
+          return { success: false, error: 'Port, baud rate, and slave ID are required for RTU connection' }
+        }
+        client = new ModbusRtuClient({
+          port: connectionParams.port,
+          baudRate: connectionParams.baudRate,
+          slaveId: connectionParams.slaveId,
+          timeout: 5000,
+        })
+      }
+
+      await client.connect()
+      const targetMd5 = await client.getMd5Hash()
+
+      const match = targetMd5.toLowerCase() === expectedMd5.toLowerCase()
+
+      if (connectionType === 'tcp') {
+        client.disconnect()
+      } else {
+        this.debuggerModbusClient = client
+        this.debuggerConnectionType = 'rtu'
+        this.debuggerRtuPort = connectionParams.port!
+        this.debuggerRtuBaudRate = connectionParams.baudRate!
+        this.debuggerRtuSlaveId = connectionParams.slaveId!
+      }
+
+      return { success: true, match, targetMd5 }
+    } catch (error) {
+      client?.disconnect()
+      wsClient?.disconnect()
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error during MD5 verification',
+      }
+    }
+  }
+
+  handleReadProgramStMd5 = async (
+    _event: IpcMainInvokeEvent,
+    projectPath: string,
+    boardTarget: string,
+  ): Promise<{ success: boolean; md5?: string; error?: string }> => {
+    try {
+      const fs = await import('fs/promises')
+      const path = await import('path')
+
+      // projectPath is already the project directory, not a file path
+      // Guard against traversal/absolute input in boardTarget
+      if (path.isAbsolute(boardTarget) || boardTarget.includes('..') || boardTarget.includes(path.sep)) {
+        return { success: false, error: 'Invalid board target' }
+      }
+      const programStPath = path.resolve(projectPath, 'build', boardTarget, 'src', 'program.st')
+
+      const content = await fs.readFile(programStPath, 'utf-8')
+
+      const md5Pattern = /\(\*DBG:char md5\[\] = "([a-fA-F0-9]{32})";?\*\)/
+      const match = content.match(md5Pattern)
+
+      if (!match || !match[1]) {
+        return {
+          success: false,
+          error: 'Could not find MD5 hash in program.st file',
+        }
+      }
+
+      return { success: true, md5: match[1] }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to read program.st file',
+      }
+    }
+  }
+
+  handleDebuggerGetVariablesList = async (
+    _event: IpcMainInvokeEvent,
+    variableIndexes: number[],
+  ): Promise<{
+    success: boolean
+    tick?: number
+    lastIndex?: number
+    data?: number[]
+    error?: string
+    needsReconnect?: boolean
+  }> => {
+    // If connection type is null, the debugger was intentionally disconnected.
+    // Return a silent failure so the renderer polling ignores it.
+    if (this.debuggerConnectionType === null) {
+      return { success: false, error: 'Debugger not connected' }
+    }
+
+    if (this.debuggerConnectionType === 'websocket') {
+      if (!this.debuggerWebSocketClient) {
+        if (this.debuggerReconnecting) {
+          return { success: false, error: 'Reconnection in progress', needsReconnect: true }
+        }
+
+        this.debuggerReconnecting = true
+        try {
+          if (!this.debuggerTargetIp || !this.debuggerJwtToken) {
+            this.debuggerReconnecting = false
+            return { success: false, error: 'No target IP or JWT token stored', needsReconnect: true }
+          }
+          this.debuggerWebSocketClient = new WebSocketDebugClient({
+            host: this.debuggerTargetIp,
+            port: 8443,
+            token: this.debuggerJwtToken,
+            rejectUnauthorized: false,
+          })
+          await this.debuggerWebSocketClient.connect()
+          this.debuggerReconnecting = false
+        } catch (error) {
+          this.debuggerWebSocketClient = null
+          this.debuggerReconnecting = false
+          return { success: false, error: `Failed to reconnect: ${String(error)}`, needsReconnect: true }
+        }
+      }
+
+      try {
+        const result = await this.debuggerWebSocketClient.getVariablesList(variableIndexes)
+
+        if (result.success && result.data) {
+          return {
+            success: true,
+            tick: result.tick,
+            lastIndex: result.lastIndex,
+            data: Array.from(result.data),
+          }
+        }
+
+        return { success: false, error: result.error }
+      } catch (error) {
+        if (this.debuggerWebSocketClient) {
+          this.debuggerWebSocketClient.disconnect()
+          this.debuggerWebSocketClient = null
+        }
+        return { success: false, error: String(error), needsReconnect: true }
+      }
+    }
+
+    if (!this.debuggerModbusClient) {
+      if (this.debuggerReconnecting) {
+        return { success: false, error: 'Reconnection in progress', needsReconnect: true }
+      }
+
+      this.debuggerReconnecting = true
+      try {
+        if (this.debuggerConnectionType === 'simulator') {
+          const virtualPort = new VirtualSerialPort(this.simulatorModule)
+          this.debuggerModbusClient = new ModbusRtuClient({
+            port: 'simulator',
+            baudRate: 115200,
+            slaveId: 1,
+            timeout: 5000,
+            serialPort: virtualPort,
+          })
+        } else if (this.debuggerConnectionType === 'tcp') {
+          if (!this.debuggerTargetIp) {
+            this.debuggerReconnecting = false
+            return { success: false, error: 'No target IP address stored', needsReconnect: true }
+          }
+          this.debuggerModbusClient = new ModbusTcpClient({
+            host: this.debuggerTargetIp,
+            port: 502,
+            timeout: 5000,
+          })
+        } else if (this.debuggerConnectionType === 'rtu') {
+          if (!this.debuggerRtuPort || !this.debuggerRtuBaudRate || this.debuggerRtuSlaveId === null) {
+            this.debuggerReconnecting = false
+            return { success: false, error: 'No RTU connection parameters stored', needsReconnect: true }
+          }
+          this.debuggerModbusClient = new ModbusRtuClient({
+            port: this.debuggerRtuPort,
+            baudRate: this.debuggerRtuBaudRate,
+            slaveId: this.debuggerRtuSlaveId,
+            timeout: 5000,
+          })
+        } else {
+          this.debuggerReconnecting = false
+          return { success: false, error: 'No connection type stored', needsReconnect: true }
+        }
+
+        await this.debuggerModbusClient.connect()
+        this.debuggerReconnecting = false
+      } catch (error) {
+        this.debuggerModbusClient = null
+        this.debuggerReconnecting = false
+        return { success: false, error: `Failed to reconnect: ${String(error)}`, needsReconnect: true }
+      }
+    }
+
+    try {
+      const result = await this.debuggerModbusClient.getVariablesList(variableIndexes)
+
+      if (result.success && result.data) {
+        return {
+          success: true,
+          tick: result.tick,
+          lastIndex: result.lastIndex,
+          data: Array.from(result.data),
+        }
+      }
+
+      return { success: false, error: result.error }
+    } catch (error) {
+      if (this.debuggerModbusClient) {
+        this.debuggerModbusClient.disconnect()
+        this.debuggerModbusClient = null
+      }
+      return { success: false, error: String(error), needsReconnect: true }
+    }
+  }
+
+  handleDebuggerConnect = async (
+    _event: IpcMainInvokeEvent,
+    connectionType: 'tcp' | 'rtu' | 'websocket' | 'simulator',
+    connectionParams: {
+      ipAddress?: string
+      port?: string
+      baudRate?: number
+      slaveId?: number
+      jwtToken?: string
+    },
+  ): Promise<{ success: boolean; error?: string }> => {
+    try {
+      if (connectionType === 'simulator') {
+        if (this.debuggerModbusClient) {
+          this.debuggerModbusClient.disconnect()
+          this.debuggerModbusClient = null
+        }
+
+        const virtualPort = new VirtualSerialPort(this.simulatorModule)
+        this.debuggerModbusClient = new ModbusRtuClient({
+          port: 'simulator',
+          baudRate: 115200,
+          slaveId: 1,
+          timeout: 5000,
+          serialPort: virtualPort,
+        })
+        await this.debuggerModbusClient.connect()
+
+        // Trigger endianness detection on the emulated runtime.
+        // getMd5Hash sends 0xDEAD which the runtime uses to detect byte order
+        // and call set_endianness(). Without this, the default SAME_ENDIANNESS
+        // causes multi-byte values to be stored with swapped bytes on the
+        // little-endian AVR emulator.
+        await this.debuggerModbusClient.getMd5Hash()
+      } else if (connectionType === 'websocket') {
+        if (this.debuggerModbusClient) {
+          this.debuggerModbusClient.disconnect()
+          this.debuggerModbusClient = null
+        }
+
+        if (!connectionParams.ipAddress || !connectionParams.jwtToken) {
+          return { success: false, error: 'IP address and JWT token are required for WebSocket connection' }
+        }
+
+        if (!this.debuggerWebSocketClient || this.debuggerConnectionType !== 'websocket') {
+          if (this.debuggerWebSocketClient) {
+            this.debuggerWebSocketClient.disconnect()
+            this.debuggerWebSocketClient = null
+          }
+
+          this.debuggerWebSocketClient = new WebSocketDebugClient({
+            host: connectionParams.ipAddress,
+            port: 8443,
+            token: connectionParams.jwtToken,
+            rejectUnauthorized: false,
+          })
+          await this.debuggerWebSocketClient.connect()
+        }
+
+        this.debuggerTargetIp = connectionParams.ipAddress
+        this.debuggerJwtToken = connectionParams.jwtToken
+      } else if (connectionType === 'tcp') {
+        if (this.debuggerModbusClient) {
+          this.debuggerModbusClient.disconnect()
+          this.debuggerModbusClient = null
+        }
+
+        if (!connectionParams.ipAddress) {
+          return { success: false, error: 'IP address is required for TCP connection' }
+        }
+        this.debuggerModbusClient = new ModbusTcpClient({
+          host: connectionParams.ipAddress,
+          port: 502,
+          timeout: 5000,
+        })
+        await this.debuggerModbusClient.connect()
+        this.debuggerTargetIp = connectionParams.ipAddress
+      } else {
+        if (!connectionParams.port || !connectionParams.baudRate || connectionParams.slaveId === undefined) {
+          return { success: false, error: 'Port, baud rate, and slave ID are required for RTU connection' }
+        }
+
+        if (
+          this.debuggerModbusClient &&
+          this.debuggerConnectionType === 'rtu' &&
+          this.debuggerRtuPort === connectionParams.port &&
+          this.debuggerRtuBaudRate === connectionParams.baudRate &&
+          this.debuggerRtuSlaveId === connectionParams.slaveId
+        ) {
+          this.debuggerReconnecting = false
+          return { success: true }
+        }
+
+        if (this.debuggerModbusClient) {
+          this.debuggerModbusClient.disconnect()
+          this.debuggerModbusClient = null
+        }
+
+        this.debuggerModbusClient = new ModbusRtuClient({
+          port: connectionParams.port,
+          baudRate: connectionParams.baudRate,
+          slaveId: connectionParams.slaveId,
+          timeout: 5000,
+        })
+        await this.debuggerModbusClient.connect()
+        this.debuggerRtuPort = connectionParams.port
+        this.debuggerRtuBaudRate = connectionParams.baudRate
+        this.debuggerRtuSlaveId = connectionParams.slaveId
+      }
+
+      this.debuggerConnectionType = connectionType
+      this.debuggerReconnecting = false
+
+      return { success: true }
+    } catch (error) {
+      this.debuggerModbusClient = null
+      this.debuggerWebSocketClient = null
+      this.debuggerTargetIp = null
+      this.debuggerConnectionType = null
+      this.debuggerRtuPort = null
+      this.debuggerRtuBaudRate = null
+      this.debuggerRtuSlaveId = null
+      this.debuggerJwtToken = null
+      return { success: false, error: String(error) }
+    }
+  }
+
+  handleDebuggerDisconnect = (_event: IpcMainInvokeEvent): Promise<{ success: boolean }> => {
+    if (this.debuggerModbusClient) {
+      this.debuggerModbusClient.disconnect()
+      this.debuggerModbusClient = null
+    }
+    if (this.debuggerWebSocketClient) {
+      this.debuggerWebSocketClient.disconnect()
+      this.debuggerWebSocketClient = null
+    }
+    this.debuggerTargetIp = null
+    this.debuggerConnectionType = null
+    this.debuggerRtuPort = null
+    this.debuggerRtuBaudRate = null
+    this.debuggerRtuSlaveId = null
+    this.debuggerJwtToken = null
+    this.debuggerReconnecting = false
+    return Promise.resolve({ success: true })
+  }
+
+  handleDebuggerSetVariable = async (
+    _event: IpcMainInvokeEvent,
+    variableIndex: number,
+    force: boolean,
+    valueBuffer?: Uint8Array,
+  ): Promise<{ success: boolean; error?: string }> => {
+    const buffer = valueBuffer ? Buffer.from(valueBuffer) : undefined
+
+    if (this.debuggerConnectionType === 'websocket') {
+      if (!this.debuggerWebSocketClient) {
+        console.log('[IPC Handler] WebSocket client not connected')
+        return { success: false, error: 'Not connected to debugger' }
+      }
+
+      try {
+        const result = await this.debuggerWebSocketClient.setVariable(variableIndex, force, buffer)
+        console.log('[IPC Handler] WebSocket setVariable result:', result)
+        return result
+      } catch (error) {
+        console.error('[IPC Handler] WebSocket setVariable error:', error)
+        return { success: false, error: String(error) }
+      }
+    }
+
+    if (!this.debuggerModbusClient) {
+      console.log('[IPC Handler] Modbus client not connected')
+      return { success: false, error: 'Not connected to debugger' }
+    }
+
+    try {
+      const result = await this.debuggerModbusClient.setVariable(variableIndex, force, buffer)
+      console.log('[IPC Handler] Modbus setVariable result:', result)
+      return result
+    } catch (error) {
+      console.error('[IPC Handler] Modbus setVariable error:', error)
+      return { success: false, error: String(error) }
+    }
+  }
+
+  // ===================== FILE WATCHER HANDLERS =====================
+
+  /**
+   * Validate that a file path is within the current project root.
+   * Resolves symlinks to prevent directory traversal attacks.
+   */
+  private validateFilePath(filePath: string): boolean {
+    if (!this.currentProjectPath) return false
+    try {
+      const resolved = realpathSync(resolve(filePath))
+      const projectRoot = realpathSync(resolve(this.currentProjectPath))
+      return resolved.startsWith(projectRoot + sep) || resolved === projectRoot
+    } catch {
+      // realpathSync fails if the file doesn't exist yet — fall back to resolve only
+      const resolved = resolve(filePath)
+      const projectRoot = resolve(this.currentProjectPath)
+      return resolved.startsWith(projectRoot + sep) || resolved === projectRoot
+    }
+  }
+
+  // ===================== SIMULATOR HANDLERS =====================
+
+  /** Stops the simulator and notifies the renderer so it can update UI state. */
+  private stopSimulatorAndNotify(): void {
+    if (this.simulatorModule.isRunning()) {
+      this.simulatorModule.stop()
+      this.mainWindow?.webContents.send('simulator:stopped')
+    }
+  }
+
+  handleSimulatorLoadFirmware = async (
+    _event: IpcMainInvokeEvent,
+    hexPath: string,
+  ): Promise<{ success: boolean; error?: string }> => {
+    try {
+      await this.simulatorModule.loadAndRun(hexPath)
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  }
+
+  handleSimulatorStop = (_event: IpcMainInvokeEvent): Promise<{ success: boolean }> => {
+    this.simulatorModule.stop()
+    return Promise.resolve({ success: true })
+  }
+
+  handleSimulatorIsRunning = (_event: IpcMainInvokeEvent): Promise<boolean> => {
+    return Promise.resolve(this.simulatorModule.isRunning())
+  }
+
+  // Using watchFile (polling-based) instead of watch for better macOS compatibility
+  // fs.watch can fail when editors use "safe write" (write to temp file, then rename)
+  handleFileWatchStart = (
+    _event: IpcMainInvokeEvent,
+    filePath: string,
+  ): Promise<{ success: boolean; error?: string }> => {
+    if (!this.validateFilePath(filePath)) {
+      return Promise.resolve({ success: false, error: 'Path is outside the project directory' })
+    }
+
+    return new Promise((res) => {
+      if (this.fileWatchers.has(filePath)) {
+        res({ success: true })
+        return
+      }
+
+      stat(filePath, (statErr, stats) => {
+        if (statErr) {
+          res({ success: false, error: `Failed to stat file: ${statErr.message}` })
+          return
+        }
+
+        const initialMtime = stats.mtimeMs
+
+        try {
+          watchFile(filePath, { interval: 1000 }, (curr, prev) => {
+            const watcherData = this.fileWatchers.get(filePath)
+            if (!watcherData) return
+
+            if (curr.mtimeMs > prev.mtimeMs && curr.mtimeMs > watcherData.lastMtime) {
+              watcherData.lastMtime = curr.mtimeMs
+              this.mainWindow?.webContents.send('file:external-change', { filePath })
+            }
+          })
+
+          this.fileWatchers.set(filePath, { lastMtime: initialMtime })
+          res({ success: true })
+        } catch (error) {
+          res({ success: false, error: `Failed to watch file: ${String(error)}` })
+        }
+      })
+    })
+  }
+
+  handleFileWatchStop = (_event: IpcMainInvokeEvent, filePath: string): { success: boolean; error?: string } => {
+    if (!this.validateFilePath(filePath)) {
+      return { success: false, error: 'Path is outside the project directory' }
+    }
+    if (this.fileWatchers.has(filePath)) {
+      unwatchFile(filePath)
+      this.fileWatchers.delete(filePath)
+    }
+    return { success: true }
+  }
+
+  handleFileWatchStopAll = (_event: IpcMainInvokeEvent): { success: boolean } => {
+    for (const [filePath] of this.fileWatchers) {
+      unwatchFile(filePath)
+    }
+    this.fileWatchers.clear()
+    return { success: true }
+  }
+
+  handleFileReadContent = (
+    _event: IpcMainInvokeEvent,
+    filePath: string,
+  ): Promise<{ success: boolean; content?: string; error?: string }> => {
+    if (!this.validateFilePath(filePath)) {
+      return Promise.resolve({ success: false, error: 'Path is outside the project directory' })
+    }
+    return new Promise((res) => {
+      readFile(filePath, 'utf-8', (err, content) => {
+        if (err) {
+          res({ success: false, error: `Failed to read file: ${err.message}` })
+        } else {
+          res({ success: true, content })
+        }
+      })
+    })
+  }
+
+  // ===================== EVENT HANDLERS =====================
+  mainIpcEventHandlers = {
+    handleUpdateTheme: () => {
+      nativeTheme.themeSource = nativeTheme.shouldUseDarkColors ? 'light' : 'dark'
+    },
+    createPou: () => this.mainWindow?.webContents.send('pou:createPou', { ok: true }),
+  }
+}
+
+export default MainProcessBridge
diff --git a/src_old/main/modules/ipc/renderer.ts b/src_old/main/modules/ipc/renderer.ts
new file mode 100644
index 000000000..24d3d5e0b
--- /dev/null
+++ b/src_old/main/modules/ipc/renderer.ts
@@ -0,0 +1,386 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return */
+import { CreatePouFileProps, PouServiceResponse } from '@root/types/IPC/pou-service'
+import { CreateProjectFileProps, IProjectServiceResponse } from '@root/types/IPC/project-service'
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { RuntimeLogEntry } from '@root/types/PLC/runtime-logs'
+import { ipcRenderer, IpcRendererEvent } from 'electron'
+
+import { ProjectState } from '../../../renderer/store/slices'
+import { PLCPou, PLCProject } from '../../../types/PLC/open-plc'
+
+type IpcRendererCallbacks = (_event: IpcRendererEvent, ...args: any) => void
+
+type IDataToWrite = {
+  projectPath: string
+  content: {
+    projectData: PLCProject
+    pous: PLCPou[]
+    deviceConfiguration: DeviceConfiguration
+    devicePinMapping: DevicePin[]
+    servers?: ProjectState['data']['servers']
+    remoteDevices?: ProjectState['data']['remoteDevices']
+  }
+}
+
+export type ISaveDataResponse = {
+  success: boolean
+  reason: {
+    title: string
+    description: string
+  }
+}
+
+/**
+ * A bridge for communication between the renderer process and the main process in an Electron application.
+ * Provides various methods for handling project creation, opening, saving, and other operations.
+ */
+const rendererProcessBridge = {
+  // ===================== PROJECT METHODS =====================
+  aboutAccelerator: (callback: IpcRendererCallbacks) => ipcRenderer.on('website:about-accelerator', callback),
+  aboutModalAccelerator: (callback: IpcRendererCallbacks) => ipcRenderer.on('about:open-accelerator', callback),
+  closeProjectAccelerator: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('workspace:close-project-accelerator', callback),
+  closeTabAccelerator: (callback: IpcRendererCallbacks) => ipcRenderer.on('workspace:close-tab-accelerator', callback),
+  createProject: (data: CreateProjectFileProps): Promise<IProjectServiceResponse> =>
+    ipcRenderer.invoke('project:create', data),
+  createProjectAccelerator: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('project:create-accelerator', (_event) => callback(_event)),
+  deleteFileAccelerator: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('workspace:delete-file-accelerator', callback),
+  findInProjectAccelerator: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('project:find-in-project-accelerator', callback),
+  handleOpenProjectRequest: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('project:open-project-request', (_event) => callback(_event)),
+  openProject: (): Promise<IProjectServiceResponse> => ipcRenderer.invoke('project:open'),
+  openProjectByPath: (projectPath: string): Promise<IProjectServiceResponse> =>
+    ipcRenderer.invoke('project:open-by-path', projectPath),
+  openRecentAccelerator: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('project:open-recent-accelerator', (_event, val: IProjectServiceResponse) => callback(_event, val)),
+  pathPicker: (): Promise<{ success: boolean; error?: { title: string; description: string }; path?: string }> =>
+    ipcRenderer.invoke('project:path-picker'),
+  removeCloseProjectListener: () => ipcRenderer.removeAllListeners('workspace:close-project-accelerator'),
+  removeCloseTabListener: () => ipcRenderer.removeAllListeners('workspace:close-tab-accelerator'),
+  removeCreateProjectAccelerator: () => ipcRenderer.removeAllListeners('project:create-accelerator'),
+  removeDeleteFileListener: () => ipcRenderer.removeAllListeners('workspace:delete-file-accelerator'),
+  removeOpenProjectAccelerator: () => ipcRenderer.removeAllListeners('project:open-project-request'),
+  removeOpenRecentListener: () => ipcRenderer.removeAllListeners('project:open-recent-accelerator'),
+  removeSaveFileAccelerator: () => ipcRenderer.removeAllListeners('project:save-file-accelerator'),
+  removeSaveProjectAccelerator: () => ipcRenderer.removeAllListeners('project:save-accelerator'),
+  saveFile: (filePath: string, content: unknown): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('project:save-file', filePath, content),
+  saveFileAccelerator: (callback: IpcRendererCallbacks) => ipcRenderer.on('project:save-file-accelerator', callback),
+  saveProject: (dataToWrite: IDataToWrite): Promise<ISaveDataResponse> =>
+    ipcRenderer.invoke('project:save', dataToWrite),
+  saveProjectAccelerator: (callback: IpcRendererCallbacks) => ipcRenderer.on('project:save-accelerator', callback),
+  switchPerspective: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('workspace:switch-perspective-accelerator', callback),
+
+  // ===================== POU METHODS =====================
+  createPouFile: (props: CreatePouFileProps): Promise<PouServiceResponse> => ipcRenderer.invoke('pou:create', props),
+  deletePouFile: (filePath: string): Promise<PouServiceResponse> => ipcRenderer.invoke('pou:delete', filePath),
+  renamePouFile: (data: {
+    filePath: string
+    newFileName: string
+    fileContent?: unknown
+  }): Promise<PouServiceResponse> => ipcRenderer.invoke('pou:rename', data),
+
+  // ===================== EDIT METHODS =====================
+  handleUndoRequest: (callback: IpcRendererCallbacks) => ipcRenderer.on('edit:undo-request', callback),
+  removeUndoRequestListener: () => ipcRenderer.removeAllListeners('edit:undo-request'),
+  handleRedoRequest: (callback: IpcRendererCallbacks) => ipcRenderer.on('edit:redo-request', callback),
+  removeRedoRequestListener: () => ipcRenderer.removeAllListeners('edit:redo-request'),
+
+  // ===================== APP & SYSTEM METHODS =====================
+  darwinAppIsClosing: (callback: IpcRendererCallbacks) => ipcRenderer.on('app:darwin-is-closing', callback),
+  getRecent: (): Promise<string[]> => ipcRenderer.invoke('app:store-get'),
+  getStoreValue: (key: string) => ipcRenderer.invoke('app:store-get', key),
+  getSystemInfo: (): Promise<{
+    OS: 'linux' | 'darwin' | 'win32' | ''
+    architecture: 'x64' | 'arm' | ''
+    prefersDarkMode: boolean
+    isWindowMaximized: boolean
+  }> => ipcRenderer.invoke('system:get-system-info'),
+  handleQuitApp: () => ipcRenderer.send('app:quit'),
+  openExternalLinkAccelerator: (link: string): Promise<{ success: boolean }> =>
+    ipcRenderer.invoke('open-external-link', link),
+  quitAppRequest: (callback: IpcRendererCallbacks) => ipcRenderer.on('app:quit-accelerator', callback),
+  removeQuitAppListener: () => ipcRenderer.removeAllListeners('app:quit-accelerator'),
+  retrieveRecent: (): Promise<{ name: string; path: string; lastOpenedAt: string; createdAt: string }[]> =>
+    ipcRenderer.invoke('app:store-retrieve-recent'),
+  setStoreValue: (key: string, val: string) => ipcRenderer.send('app:store-set', key, val),
+
+  // ===================== WINDOW CONTROLS =====================
+  closeWindow: () => ipcRenderer.send('window-controls:closed'),
+  handleCloseOrHideWindow: () => ipcRenderer.send('window-controls:close'),
+  handleCloseOrHideWindowAccelerator: () =>
+    ipcRenderer.on('window-controls:request-close', () => ipcRenderer.send('window-controls:close')),
+  hideWindow: () => ipcRenderer.send('window-controls:hide'),
+  isMaximizedWindow: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('window-controls:toggle-maximized', (_event) => callback(_event)),
+  maximizeWindow: () => ipcRenderer.send('window-controls:maximize'),
+  minimizeWindow: () => ipcRenderer.send('window-controls:minimize'),
+  rebuildMenu: () => ipcRenderer.send('window:rebuild-menu'),
+  reloadWindow: () => ipcRenderer.send('window:reload'),
+  removeHandleCloseOrHideWindowAccelerator: () => ipcRenderer.removeAllListeners('window-controls:request-close'),
+  windowIsClosing: (callback: IpcRendererCallbacks) => ipcRenderer.on('window-controls:is-closing', callback),
+
+  // ===================== THEME =====================
+  handleUpdateTheme: (callback: IpcRendererCallbacks) => ipcRenderer.on('system:update-theme', callback),
+  winHandleUpdateTheme: () => ipcRenderer.send('system:update-theme'),
+
+  // ===================== COMPILER/BUILD METHODS =====================
+  // !! Deprecated: This method is an outdated implementation and should be substituted.
+  exportProjectXml: async (
+    pathToUserProject: string,
+    dataToCreateXml: ProjectState['data'],
+    parseTo: 'old-editor' | 'codesys',
+  ): Promise<{ success: boolean; message: string }> =>
+    ipcRenderer.invoke('compiler:export-project-xml', pathToUserProject, dataToCreateXml, parseTo),
+  // =================== Work in Progress ===================
+  // This method is a placeholder for running the compile program.
+  runCompileProgram: (
+    compileProgramArgs: Array<string | boolean | null | ProjectState['data']>,
+    callback: (args: any) => void,
+  ) => {
+    // Create a MessageChannel to communicate between the renderer and main process
+    const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
+    // Send to the main process a message to run the compile program
+    // The main process will handle the compilation and send the result back through the port
+    ipcRenderer.postMessage('compiler:run-compile-program', compileProgramArgs, [mainProcessPort])
+    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.addEventListener('close', () =>
+      callback({
+        closePort: true,
+      }),
+    )
+    // rendererProcessPort.start()
+    // Set up the renderer process port to listen for messages from the main process
+  },
+
+  runDebugCompilation: (compileArgs: Array<string | ProjectState['data']>, callback: (args: any) => void) => {
+    const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
+    ipcRenderer.postMessage('compiler:run-debug-compilation', compileArgs, [mainProcessPort])
+    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.addEventListener('close', () =>
+      callback({
+        closePort: true,
+      }),
+    )
+  },
+
+  // !! Deprecated: These methods are an outdated implementation and should be removed.
+  compileRequest: (xmlPath: string, callback: (args: any) => void) => {
+    const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
+    ipcRenderer.postMessage('compiler:build-st-program', xmlPath, [mainProcessPort])
+    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.addEventListener('close', () => console.log('Port closed'))
+  },
+  createBuildDirectory: async (pathToUserProject: string): Promise<{ success: boolean; message: string }> =>
+    ipcRenderer.invoke('compiler:create-build-directory', pathToUserProject),
+  createXmlFileToBuild: async (
+    pathToUserProject: string,
+    dataToCreateXml: ProjectState['data'],
+  ): Promise<{ success: boolean; message: string }> =>
+    ipcRenderer.invoke('compiler:build-xml-file', pathToUserProject, dataToCreateXml),
+  exportProjectRequest: (callback: IpcRendererCallbacks) =>
+    ipcRenderer.on('compiler:export-project-request', (_event, value) => callback(_event, value)),
+  generateCFilesRequest: (pathToStProgram: string, callback: (args: any) => void) => {
+    const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
+    ipcRenderer.postMessage('compiler:generate-c-files', pathToStProgram, [mainProcessPort])
+    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.addEventListener('close', () => console.log('Port closed'))
+  },
+  removeExportProjectListener: () => ipcRenderer.removeAllListeners('compiler:export-project-request'),
+  setupCompilerEnvironment: (callback: (args: any) => void) => {
+    const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
+    ipcRenderer.postMessage('compiler:setup-environment', '', [mainProcessPort])
+    rendererProcessPort.onmessage = (event) => callback(event.data)
+    rendererProcessPort.addEventListener('close', () => console.log('Port closed'))
+  },
+
+  // ===================== HARDWARE METHODS =====================
+  getAvailableBoards: (): Promise<
+    Map<
+      string,
+      {
+        compiler: 'arduino-cli' | 'openplc-compiler' | 'simulator'
+        core: string
+        preview: string
+        specs: {
+          CPU: string
+          RAM: string
+          Flash: string
+          DigitalPins: string
+          AnalogPins: string
+          PWMPins: string
+          WiFi: string
+          Bluetooth: string
+          Ethernet: string
+        }
+        isCoreInstalled: boolean
+        pins: {
+          defaultAin?: string[]
+          defaultAout?: string[]
+          defaultDin?: string[]
+          defaultDout?: string[]
+        }
+      }
+    >
+  > => ipcRenderer.invoke('hardware:get-available-boards'),
+  getAvailableCommunicationPorts: (): Promise<{ name: string; address: string }[]> =>
+    ipcRenderer.invoke('hardware:get-available-communication-ports'),
+  refreshAvailableBoards: (): Promise<{ board: string; version: string }[]> =>
+    ipcRenderer.invoke('hardware:refresh-available-boards'),
+  refreshCommunicationPorts: (): Promise<{ name: string; address: string }[]> =>
+    ipcRenderer.invoke('hardware:refresh-communication-ports'),
+
+  // ===================== UTILITY METHODS =====================
+  getPreviewImage: (image: string): Promise<string> => ipcRenderer.invoke('util:get-preview-image', image),
+  log: (level: 'info' | 'error', message: string) => ipcRenderer.send('util:log', { level, message }),
+  readDebugFile: (
+    projectPath: string,
+    boardTarget: string,
+  ): Promise<{ success: boolean; content?: string; error?: string }> =>
+    ipcRenderer.invoke('util:read-debug-file', projectPath, boardTarget),
+
+  debuggerVerifyMd5: (
+    connectionType: 'tcp' | 'rtu' | 'websocket' | 'simulator',
+    connectionParams: {
+      ipAddress?: string
+      port?: string
+      baudRate?: number
+      slaveId?: number
+      jwtToken?: string
+    },
+    expectedMd5: string,
+  ): Promise<{ success: boolean; match?: boolean; targetMd5?: string; error?: string }> =>
+    ipcRenderer.invoke('debugger:verify-md5', connectionType, connectionParams, expectedMd5),
+
+  debuggerReadProgramStMd5: (
+    projectPath: string,
+    boardTarget: string,
+  ): Promise<{ success: boolean; md5?: string; error?: string }> =>
+    ipcRenderer.invoke('debugger:read-program-st-md5', projectPath, boardTarget),
+
+  debuggerGetVariablesList: (
+    variableIndexes: number[],
+  ): Promise<{
+    success: boolean
+    tick?: number
+    lastIndex?: number
+    data?: number[]
+    error?: string
+    needsReconnect?: boolean
+  }> => ipcRenderer.invoke('debugger:get-variables-list', variableIndexes),
+
+  debuggerSetVariable: (
+    variableIndex: number,
+    force: boolean,
+    valueBuffer?: Uint8Array,
+  ): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('debugger:set-variable', variableIndex, force, valueBuffer),
+
+  debuggerConnect: (
+    connectionType: 'tcp' | 'rtu' | 'websocket' | 'simulator',
+    connectionParams: {
+      ipAddress?: string
+      port?: string
+      baudRate?: number
+      slaveId?: number
+      jwtToken?: string
+    },
+  ): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('debugger:connect', connectionType, connectionParams),
+
+  debuggerDisconnect: (): Promise<{ success: boolean }> => ipcRenderer.invoke('debugger:disconnect'),
+
+  // ===================== RUNTIME API METHODS =====================
+  runtimeGetUsersInfo: (ipAddress: string): Promise<{ hasUsers: boolean; runtimeVersion?: string; error?: string }> =>
+    ipcRenderer.invoke('runtime:get-users-info', ipAddress),
+  runtimeCreateUser: (
+    ipAddress: string,
+    username: string,
+    password: string,
+  ): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('runtime:create-user', ipAddress, username, password),
+  runtimeLogin: (
+    ipAddress: string,
+    username: string,
+    password: string,
+  ): Promise<{ success: boolean; accessToken?: string; error?: string }> =>
+    ipcRenderer.invoke('runtime:login', ipAddress, username, password),
+  runtimeGetStatus: (
+    ipAddress: string,
+    jwtToken: string,
+    includeStats?: boolean,
+  ): Promise<{
+    success: boolean
+    status?: string
+    timingStats?: {
+      scan_count: number
+      scan_time_min: number | null
+      scan_time_max: number | null
+      scan_time_avg: number | null
+      cycle_time_min: number | null
+      cycle_time_max: number | null
+      cycle_time_avg: number | null
+      cycle_latency_min: number | null
+      cycle_latency_max: number | null
+      cycle_latency_avg: number | null
+      overruns: number
+    }
+    error?: string
+  }> => ipcRenderer.invoke('runtime:get-status', ipAddress, jwtToken, includeStats),
+  runtimeStartPlc: (ipAddress: string, jwtToken: string): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('runtime:start-plc', ipAddress, jwtToken),
+  runtimeStopPlc: (ipAddress: string, jwtToken: string): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('runtime:stop-plc', ipAddress, jwtToken),
+  runtimeGetCompilationStatus: (
+    ipAddress: string,
+    jwtToken: string,
+  ): Promise<{
+    success: boolean
+    data?: { status: string; logs: string[]; exit_code: number | null }
+    error?: string
+  }> => ipcRenderer.invoke('runtime:get-compilation-status', ipAddress, jwtToken),
+  runtimeGetLogs: (
+    ipAddress: string,
+    jwtToken: string,
+    minId?: number,
+  ): Promise<{ success: boolean; logs?: string | RuntimeLogEntry[]; error?: string }> =>
+    ipcRenderer.invoke('runtime:get-logs', ipAddress, jwtToken, minId),
+  runtimeClearCredentials: (): Promise<{ success: boolean }> => ipcRenderer.invoke('runtime:clear-credentials'),
+  runtimeGetSerialPorts: (
+    ipAddress: string,
+    jwtToken: string,
+  ): Promise<{ success: boolean; ports?: Array<{ device: string; description?: string }>; error?: string }> =>
+    ipcRenderer.invoke('runtime:get-serial-ports', ipAddress, jwtToken),
+  onRuntimeTokenRefreshed: (callback: (_event: IpcRendererEvent, newToken: string) => void) => {
+    ipcRenderer.on('runtime:token-refreshed', callback)
+    return () => ipcRenderer.removeListener('runtime:token-refreshed', callback)
+  },
+
+  // ===================== SIMULATOR METHODS =====================
+  simulatorLoadFirmware: (hexPath: string): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('simulator:load-firmware', hexPath),
+  simulatorStop: (): Promise<{ success: boolean }> => ipcRenderer.invoke('simulator:stop'),
+  simulatorIsRunning: (): Promise<boolean> => ipcRenderer.invoke('simulator:is-running'),
+  onSimulatorStopped: (callback: () => void) => {
+    const listener = () => callback()
+    ipcRenderer.on('simulator:stopped', listener)
+    return () => ipcRenderer.removeListener('simulator:stopped', listener)
+  },
+
+  // ===================== FILE WATCHER METHODS =====================
+  fileWatchStart: (filePath: string): Promise<{ success: boolean; error?: string }> =>
+    ipcRenderer.invoke('file:watch-start', filePath),
+  fileWatchStop: (filePath: string): Promise<{ success: boolean }> => ipcRenderer.invoke('file:watch-stop', filePath),
+  fileWatchStopAll: (): Promise<{ success: boolean }> => ipcRenderer.invoke('file:watch-stop-all'),
+  fileReadContent: (filePath: string): Promise<{ success: boolean; content?: string; error?: string }> =>
+    ipcRenderer.invoke('file:read-content', filePath),
+  onFileExternalChange: (callback: (_event: IpcRendererEvent, data: { filePath: string }) => void) => {
+    ipcRenderer.on('file:external-change', callback)
+    return () => ipcRenderer.removeListener('file:external-change', callback)
+  },
+}
+export default rendererProcessBridge
diff --git a/src/main/modules/modbus/modbus-client.ts b/src_old/main/modules/modbus/modbus-client.ts
similarity index 100%
rename from src/main/modules/modbus/modbus-client.ts
rename to src_old/main/modules/modbus/modbus-client.ts
diff --git a/src/main/modules/modbus/modbus-rtu-client.ts b/src_old/main/modules/modbus/modbus-rtu-client.ts
similarity index 100%
rename from src/main/modules/modbus/modbus-rtu-client.ts
rename to src_old/main/modules/modbus/modbus-rtu-client.ts
diff --git a/src_old/main/modules/preload/preload.ts b/src_old/main/modules/preload/preload.ts
new file mode 100644
index 000000000..b587edae0
--- /dev/null
+++ b/src_old/main/modules/preload/preload.ts
@@ -0,0 +1,15 @@
+// import './splash-screen/index'
+
+import { contextBridge } from 'electron'
+
+import rendererProcessBridge from '../ipc/renderer'
+
+contextBridge.exposeInMainWorld('bridge', rendererProcessBridge)
+
+export type ElectronHandler = typeof rendererProcessBridge
+
+declare global {
+  interface Window {
+    bridge: ElectronHandler
+  }
+}
diff --git a/src_old/main/modules/preload/splash-screen/splash.html b/src_old/main/modules/preload/splash-screen/splash.html
new file mode 100644
index 000000000..a8a7ad959
--- /dev/null
+++ b/src_old/main/modules/preload/splash-screen/splash.html
@@ -0,0 +1,128 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>OpenPLC Editor</title>
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap" />
+    <style>
+      body {
+        font-family: 'Inter', sans-serif;
+        background-color: #023c97;
+        margin: 0;
+        padding: 0;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+        color: #fff;
+        font-size: 10px;
+        font-weight: 500;
+        user-select: none;
+      }
+
+      .container {
+        position: relative;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        height: 100%;
+        width: 100%;
+        background-color: transparent;
+      }
+
+      .loadContainer {
+        position: absolute;
+        bottom: 0;
+        width: 100%;
+        height: 5px;
+        background-color: #030303;
+      }
+
+      .loadbar {
+        width: 0%;
+        height: 100%;
+        background: #0464fb;
+        transition: width 1s ease-out;
+      }
+      .loadingWrapper {
+        position: absolute;
+        bottom: 10px;
+        width: 95%;
+        margin-left: 10px;
+        margin-right: 10px;
+      }
+      .loadingText {
+        display: flex;
+        justify-content: space-between;
+      }
+      img {
+        -webkit-app-region: no-drag;
+        user-select: none;
+        pointer-events: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <img><svg width="274" height="50" viewBox="0 0 274 50" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <path d="M25.1406 0L0 25L25.1406 50L30.6716 44.3878L15.3316 29.2801C14.2057 28.1712 12.6983 27.551 11.1293 27.551H7.03937V22.449H11.1293C12.6983 22.449 14.2057 21.8288 15.3316 20.7199L30.6716 5.61224L25.1406 0Z" fill="white"/>
+        <path d="M49.2756 0L74.4162 25L49.2756 50L43.7447 44.3878L59.0846 29.2801C60.2105 28.1712 61.7179 27.551 63.287 27.551H67.3769V22.449H63.287C61.7179 22.449 60.2105 21.8288 59.0846 20.7199L43.7447 5.61224L49.2756 0Z" fill="white"/>
+        <path d="M263.552 46.7999C260.155 46.7999 257.554 45.8249 255.748 43.8749C253.985 41.9249 253.104 39.1732 253.104 35.6199V11.1799C253.104 7.62655 253.985 4.87488 255.748 2.92488C257.554 0.974879 260.155 -0.00012207 263.552 -0.00012207C266.949 -0.00012207 269.528 0.974879 271.291 2.92488C273.097 4.87488 274 7.62655 274 11.1799V15.9899H267.293V10.7249C267.293 7.90821 266.11 6.49988 263.746 6.49988C261.381 6.49988 260.198 7.90821 260.198 10.7249V36.1399C260.198 38.9132 261.381 40.2999 263.746 40.2999C266.11 40.2999 267.293 38.9132 267.293 36.1399V29.1849H274V35.6199C274 39.1732 273.097 41.9249 271.291 43.8749C269.528 45.8249 266.949 46.7999 263.552 46.7999Z" fill="white"/>
+        <path d="M231.638 0.649902H238.732V39.6499H250.405V46.1499H231.638V0.649902Z" fill="white"/>
+        <path d="M206.759 0.649902H217.207C220.733 0.649902 223.377 1.60324 225.14 3.5099C226.903 5.41657 227.784 8.21157 227.784 11.8949V16.3799C227.784 20.0632 226.903 22.8582 225.14 24.7649C223.377 26.6716 220.733 27.6249 217.207 27.6249H213.854V46.1499H206.759V0.649902ZM217.207 21.1249C218.368 21.1249 219.228 20.7999 219.787 20.1499C220.389 19.4999 220.69 18.3949 220.69 16.8349V11.4399C220.69 9.8799 220.389 8.7749 219.787 8.1249C219.228 7.4749 218.368 7.1499 217.207 7.1499H213.854V21.1249H217.207Z" fill="white"/>
+        <path d="M168.907 0.649902H177.807L184.708 27.8849H184.837V0.649902H191.157V46.1499H183.87L175.356 12.9349H175.227V46.1499H168.907V0.649902Z" fill="white"/>
+        <path d="M145.478 0.649902H164.826V7.1499H152.572V19.1749H162.31V25.6749H152.572V39.6499H164.826V46.1499H145.478V0.649902Z" fill="white"/>
+        <path d="M120.599 0.649902H131.047C134.573 0.649902 137.217 1.60324 138.98 3.5099C140.743 5.41657 141.624 8.21157 141.624 11.8949V16.3799C141.624 20.0632 140.743 22.8582 138.98 24.7649C137.217 26.6716 134.573 27.6249 131.047 27.6249H127.694V46.1499H120.599V0.649902ZM131.047 21.1249C132.208 21.1249 133.068 20.7999 133.627 20.1499C134.229 19.4999 134.53 18.3949 134.53 16.8349V11.4399C134.53 9.8799 134.229 8.7749 133.627 8.1249C133.068 7.4749 132.208 7.1499 131.047 7.1499H127.694V21.1249H131.047Z" fill="white"/>
+        <path d="M105.031 46.8C101.548 46.8 98.8827 45.8033 97.0339 43.81C95.185 41.8167 94.2606 39 94.2606 35.36V11.44C94.2606 7.8 95.185 4.98333 97.0339 2.99C98.8827 0.996667 101.548 0 105.031 0C108.514 0 111.18 0.996667 113.028 2.99C114.877 4.98333 115.802 7.8 115.802 11.44V35.36C115.802 39 114.877 41.8167 113.028 43.81C111.18 45.8033 108.514 46.8 105.031 46.8ZM105.031 40.3C107.482 40.3 108.707 38.805 108.707 35.815V10.985C108.707 7.995 107.482 6.5 105.031 6.5C102.58 6.5 101.355 7.995 101.355 10.985V35.815C101.355 38.805 102.58 40.3 105.031 40.3Z" fill="white"/>
+        </svg>
+         </img>
+      <div class="loadingWrapper">
+        <div class="loadingText">
+          <span style="font-size: 12px; font-weight: 700">AUTONOMY</span>
+          <span>© 2021-2025</span>
+        </div>
+        <div class="loadingText">
+          <span id="initialLoading">Loading</span>
+          <span>All rights reserved.</span>
+        </div>
+      </div>
+      <div class="loadContainer">
+        <div class="loadbar" id="progressBar"></div>
+      </div>
+    </div>
+
+    <script>
+      document.addEventListener('DOMContentLoaded', () => {
+        function updateProgressBar(progress) {
+          const progressBar = document.getElementById('progressBar')
+
+          progressBar.style.width = `${progress}%`
+        }
+
+        let progress = 0
+        const interval = setInterval(() => {
+          progress += 4
+          if (progress > 100) {
+            clearInterval(interval)
+            return
+          }
+
+          updateProgressBar(progress)
+        }, 100)
+
+        let dots = 0
+        const loadingText = document.getElementById('initialLoading')
+        const loadingInterval = setInterval(() => {
+          dots++
+          if (dots > 3) {
+            dots = 0
+          }
+          const dotsString = '.'.repeat(dots)
+          loadingText.textContent = 'Loading' + dotsString
+        }, 500)
+      })
+    </script>
+  </body>
+</html>
diff --git a/src/main/modules/simulator/simulator-module.ts b/src_old/main/modules/simulator/simulator-module.ts
similarity index 100%
rename from src/main/modules/simulator/simulator-module.ts
rename to src_old/main/modules/simulator/simulator-module.ts
diff --git a/src/main/modules/simulator/virtual-serial-port.ts b/src_old/main/modules/simulator/virtual-serial-port.ts
similarity index 100%
rename from src/main/modules/simulator/virtual-serial-port.ts
rename to src_old/main/modules/simulator/virtual-serial-port.ts
diff --git a/src_old/main/modules/store/index.ts b/src_old/main/modules/store/index.ts
new file mode 100644
index 000000000..d4f71d0d0
--- /dev/null
+++ b/src_old/main/modules/store/index.ts
@@ -0,0 +1,68 @@
+import Store from 'electron-store'
+
+import { TStoreType } from '../../contracts/types/modules/store'
+
+export const store = new Store<TStoreType>({
+  schema: {
+    last_projects: {
+      type: 'array',
+      items: {
+        type: 'string',
+      },
+      maxItems: 10,
+      uniqueItems: true,
+    },
+    theme: {
+      type: 'string',
+    },
+    window: {
+      type: 'object',
+      properties: {
+        /**
+         * Schema definition for the 'bounds' property within the 'window'.
+         */
+        bounds: {
+          type: 'object',
+          properties: {
+            /**
+             * Schema definition for the 'width' property within the 'bounds'.
+             */
+            width: {
+              type: 'number',
+            },
+            /**
+             * Schema definition for the 'height' property within the 'bounds'.
+             */
+            height: {
+              type: 'number',
+            },
+            /**
+             * Schema definition for the 'x' property within the 'bounds'.
+             */
+            x: {
+              type: 'number',
+            },
+            /**
+             * Schema definition for the 'y' property within the 'bounds'.
+             */
+            y: {
+              type: 'number',
+            },
+          },
+        },
+      },
+    },
+  },
+  defaults: {
+    last_projects: [],
+    theme: 'light',
+    window: {
+      bounds: {
+        width: 1440,
+        height: 768,
+        x: 0,
+        y: 0,
+      },
+    },
+  },
+})
diff --git a/src_old/main/modules/store/store.spec.ts b/src_old/main/modules/store/store.spec.ts
new file mode 100644
index 000000000..f050d463b
--- /dev/null
+++ b/src_old/main/modules/store/store.spec.ts
@@ -0,0 +1,7 @@
+import { describe, expect, it } from '@jest/globals'
+
+describe('Mock test for store', () => {
+  it('should pass', () => {
+    expect(1).toBe(1)
+  })
+})
diff --git a/src/main/modules/websocket/websocket-debug-client.ts b/src_old/main/modules/websocket/websocket-debug-client.ts
similarity index 100%
rename from src/main/modules/websocket/websocket-debug-client.ts
rename to src_old/main/modules/websocket/websocket-debug-client.ts
diff --git a/src_old/main/services/__tests__/user-service.test.ts b/src_old/main/services/__tests__/user-service.test.ts
new file mode 100644
index 000000000..3a0f81091
--- /dev/null
+++ b/src_old/main/services/__tests__/user-service.test.ts
@@ -0,0 +1,5 @@
+describe('UserService', () => {
+  it('should be defined', () => {
+    expect(true).toBe(true)
+  })
+})
diff --git a/src_old/main/services/index.ts b/src_old/main/services/index.ts
new file mode 100644
index 000000000..ec16c292b
--- /dev/null
+++ b/src_old/main/services/index.ts
@@ -0,0 +1,4 @@
+export * from './logger-service'
+export * from './pou-service'
+export * from './project-service'
+export * from './user-service'
diff --git a/src_old/main/services/logger-service/index.ts b/src_old/main/services/logger-service/index.ts
new file mode 100644
index 000000000..e9f67c4dc
--- /dev/null
+++ b/src_old/main/services/logger-service/index.ts
@@ -0,0 +1,39 @@
+import { app } from 'electron'
+import { join } from 'path'
+import { createLogger, format, transports } from 'winston'
+
+const { combine, colorize, timestamp, label, printf } = format
+
+const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
+
+const timestampFormatter = () => new Date().toLocaleString('en-US', { timeZone: timezone })
+
+const autonomyLoggerFormat = printf(({ level, message, label, timestamp }) => {
+  return `${timestamp as string} [${label as string}] ${level}: ${message as string}`
+})
+
+const logPath = join(app.getPath('userData'), 'logs')
+
+const logger = createLogger({
+  level: 'info',
+  format: combine(label({ label: 'autonomy' }), timestamp({ format: timestampFormatter() }), autonomyLoggerFormat),
+  transports: [
+    new transports.File({ filename: join(logPath, 'error.log'), level: 'error' }),
+    new transports.File({ filename: join(logPath, 'combined.log') }),
+  ],
+})
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(
+    new transports.Console({
+      format: combine(
+        colorize(),
+        printf(({ level, message }) => {
+          return `${level}: ${message as string}`
+        }),
+      ),
+    }),
+  )
+}
+
+export { logger }
diff --git a/src/main/services/pou-service/index.ts b/src_old/main/services/pou-service/index.ts
similarity index 100%
rename from src/main/services/pou-service/index.ts
rename to src_old/main/services/pou-service/index.ts
diff --git a/src_old/main/services/project-service/data/index.ts b/src_old/main/services/project-service/data/index.ts
new file mode 100644
index 000000000..35decdad8
--- /dev/null
+++ b/src_old/main/services/project-service/data/index.ts
@@ -0,0 +1 @@
+export * from './xml-file'
diff --git a/src_old/main/services/project-service/data/xml-file.ts b/src_old/main/services/project-service/data/xml-file.ts
new file mode 100644
index 000000000..f2279e0b9
--- /dev/null
+++ b/src_old/main/services/project-service/data/xml-file.ts
@@ -0,0 +1,49 @@
+import { formatDate } from '../../../../utils'
+
+export const baseXmlStructure = {
+  '@xmlns': 'http://www.plcopen.org/xml/tc6_0201',
+  '@xmlns:ns1': 'http://www.plcopen.org/xml/tc6.xsd',
+  '@xmlns:xhtml': 'http://www.w3.org/1999/xhtml',
+  '@xmlns:xsd': 'http://www.w3.org/2001/XMLSchema-instance',
+  '@xsi:schemaLocation': 'http://www.plcopen.org/xml/tc6_0200 http://www.plcopen.org/xml/tc6_0200',
+  fileHeader: {
+    '@companyName': 'Unknown',
+    '@creationDateTime': formatDate(new Date()),
+    '@productName': 'Unnamed',
+    '@productVersion': '1',
+  },
+  contentHeader: {
+    '@name': 'Unnamed',
+    '@modificationDateTime': formatDate(new Date()),
+    coordinateInfo: {
+      fbd: {
+        scaling: {
+          '@x': '16',
+          '@y': '16',
+        },
+      },
+      ld: {
+        scaling: {
+          '@x': '10',
+          '@y': '10',
+        },
+      },
+      sfc: {
+        scaling: {
+          '@x': '10',
+          '@y': '10',
+        },
+      },
+    },
+  },
+  instances: {
+    configurations: {
+      configuration: {
+        '@name': 'Config0',
+        resource: {
+          '@name': 'Res0',
+        },
+      },
+    },
+  },
+}
diff --git a/src/main/services/project-service/index.ts b/src_old/main/services/project-service/index.ts
similarity index 100%
rename from src/main/services/project-service/index.ts
rename to src_old/main/services/project-service/index.ts
diff --git a/src/main/services/project-service/utils/create-project.ts b/src_old/main/services/project-service/utils/create-project.ts
similarity index 100%
rename from src/main/services/project-service/utils/create-project.ts
rename to src_old/main/services/project-service/utils/create-project.ts
diff --git a/src_old/main/services/project-service/utils/index.ts b/src_old/main/services/project-service/utils/index.ts
new file mode 100644
index 000000000..2d23f4852
--- /dev/null
+++ b/src_old/main/services/project-service/utils/index.ts
@@ -0,0 +1,2 @@
+export * from './create-project'
+export * from './read-project'
diff --git a/src/main/services/project-service/utils/read-project.ts b/src_old/main/services/project-service/utils/read-project.ts
similarity index 100%
rename from src/main/services/project-service/utils/read-project.ts
rename to src_old/main/services/project-service/utils/read-project.ts
diff --git a/src_old/main/services/user-service/data/arduino.ts b/src_old/main/services/user-service/data/arduino.ts
new file mode 100644
index 000000000..21f4e589c
--- /dev/null
+++ b/src_old/main/services/user-service/data/arduino.ts
@@ -0,0 +1,16 @@
+export const ARDUINO_DATA = `
+board_manager:
+  additional_urls:
+      - https://arduino.esp8266.com/stable/package_esp8266com_index.json
+      - https://espressif.github.io/arduino-esp32/package_esp32_index.json
+      - https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json
+      - https://raw.githubusercontent.com/CONTROLLINO-PLC/CONTROLLINO_Library/master/Boards/package_ControllinoHardware_index.json
+      - https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
+      - https://facts-engineering.gitlab.io/facts-open-source/p1am/beta_file_hosting/package_productivity-P1AM_200-boardmanagermodule_index.json
+      - https://raw.githubusercontent.com/facts-engineering/facts-engineering.github.io/master/package_productivity-P1AM-boardmanagermodule_index.json
+      - https://raw.githubusercontent.com/VEA-SRL/IRUINO_Library/main/package_vea_index.json
+      - https://github.com/CONTROLLINO-PLC/controllino_rp2/releases/download/global/package_controllino_rp2_index.json
+      - https://downloads.arduino.cc/packages/package_zephyr_index.json
+output:
+  no_color: true
+`
diff --git a/src_old/main/services/user-service/data/history.ts b/src_old/main/services/user-service/data/history.ts
new file mode 100644
index 000000000..76218dc3b
--- /dev/null
+++ b/src_old/main/services/user-service/data/history.ts
@@ -0,0 +1,4 @@
+export const HISTORY_DATA = {
+  projects: [],
+  libraries: [],
+}
diff --git a/src_old/main/services/user-service/data/settings.ts b/src_old/main/services/user-service/data/settings.ts
new file mode 100644
index 000000000..f1eb958e7
--- /dev/null
+++ b/src_old/main/services/user-service/data/settings.ts
@@ -0,0 +1,11 @@
+export const SETTINGS_DATA = {
+  'theme-preference': 'light',
+  window: {
+    bounds: {
+      width: 1124,
+      height: 628,
+      x: 0,
+      y: 0,
+    },
+  },
+}
diff --git a/src/main/services/user-service/index.ts b/src_old/main/services/user-service/index.ts
similarity index 100%
rename from src/main/services/user-service/index.ts
rename to src_old/main/services/user-service/index.ts
diff --git a/src_old/main/services/user-service/user-service-types.ts b/src_old/main/services/user-service/user-service-types.ts
new file mode 100644
index 000000000..c4086a5fd
--- /dev/null
+++ b/src_old/main/services/user-service/user-service-types.ts
@@ -0,0 +1,100 @@
+import { z } from 'zod'
+
+const HelpSchema = z.object({
+  online: z.string(),
+})
+
+const BoardSchema = z.object({
+  name: z.string(),
+  fqbn: z.string().optional(),
+})
+
+const ReleaseSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  types: z.array(z.string()),
+  installed: z.boolean().optional(),
+  boards: z.array(BoardSchema),
+  help: HelpSchema,
+  compatible: z.boolean(),
+})
+
+const PlatformSchema = z.object({
+  id: z.string(),
+  maintainer: z.string(),
+  website: z.string(),
+  email: z.string(),
+  indexed: z.boolean(),
+  releases: z.record(ReleaseSchema),
+  installed_version: z.string(),
+  latest_version: z.string(),
+})
+
+type Platform = z.infer<typeof PlatformSchema>
+
+const ArduinoCoreListOutputSchema = z.object({
+  platforms: z.array(PlatformSchema),
+})
+
+/**
+ * Describes the properties of an available update for a library.
+ */
+const LibraryReleaseSchema = z.object({
+  author: z.string(),
+  version: z.string(),
+  maintainer: z.string(),
+  sentence: z.string(),
+  paragraph: z.string(),
+  website: z.string(),
+  category: z.string(),
+  architectures: z.array(z.string()),
+  types: z.array(z.string()),
+})
+
+/**
+ * Describes the detailed properties of an installed Arduino library.
+ */
+const LibrarySchema = z.object({
+  name: z.string(),
+  author: z.string(),
+  maintainer: z.string(),
+  sentence: z.string(),
+  paragraph: z.string(),
+  website: z.string(),
+  category: z.string(),
+  architectures: z.array(z.string()),
+  install_dir: z.string(),
+  source_dir: z.string(),
+  version: z.string(),
+  license: z.string(),
+  properties: z.record(z.unknown()),
+  location: z.string(),
+  layout: z.string(),
+  examples: z.array(z.string()),
+  provides_includes: z.array(z.string()),
+  compatible_with: z.record(z.unknown()), // An object with unknown keys/values
+})
+
+/**
+ * Represents a single installed library, which may have an associated available update.
+ */
+const InstalledLibrarySchema = z.object({
+  library: LibrarySchema,
+  release: LibraryReleaseSchema.optional(),
+})
+
+/**
+ * Defines the root structure containing a list of all installed Arduino libraries.
+ */
+const ArduinoLibraryListOutputSchema = z.object({
+  installed_libraries: z.array(InstalledLibrarySchema),
+})
+
+export const ArduinoListOutputSchemas = z.object({
+  core: ArduinoCoreListOutputSchema,
+  library: ArduinoLibraryListOutputSchema,
+})
+
+type ArduinoListOutput = z.infer<typeof ArduinoListOutputSchemas>
+
+export type { ArduinoListOutput, Platform }
diff --git a/src_old/main/utils/create-directory.ts b/src_old/main/utils/create-directory.ts
new file mode 100644
index 000000000..7b1f3da30
--- /dev/null
+++ b/src_old/main/utils/create-directory.ts
@@ -0,0 +1,16 @@
+import { mkdirSync } from 'fs'
+import { resolve } from 'path'
+
+/**
+ * Recursively creates a directory and all parent directories if they do not exist.
+ * @param dirPath The directory path to create.
+ * @returns {boolean} True if the directory was created or already exists, false if an error occurred.
+ */
+export function createDirectory(dirPath: string): boolean {
+  try {
+    mkdirSync(resolve(dirPath), { recursive: true })
+    return true
+  } catch (_error) {
+    return false
+  }
+}
diff --git a/src_old/main/utils/file-or-directory-exists.ts b/src_old/main/utils/file-or-directory-exists.ts
new file mode 100644
index 000000000..132802805
--- /dev/null
+++ b/src_old/main/utils/file-or-directory-exists.ts
@@ -0,0 +1,15 @@
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+
+/**
+ * Checks if a file or directory exists at the given path.
+ * @param targetPath The path to check.
+ * @returns {boolean} True if the file or directory exists, false otherwise.
+ */
+export function fileOrDirectoryExists(targetPath: string): boolean {
+  try {
+    return existsSync(resolve(targetPath))
+  } catch (_error) {
+    return false
+  }
+}
diff --git a/src/main/utils/index.ts b/src_old/main/utils/index.ts
similarity index 100%
rename from src/main/utils/index.ts
rename to src_old/main/utils/index.ts
diff --git a/src_old/main/utils/is-empty-dir.ts b/src_old/main/utils/is-empty-dir.ts
new file mode 100644
index 000000000..30f412b88
--- /dev/null
+++ b/src_old/main/utils/is-empty-dir.ts
@@ -0,0 +1,12 @@
+import { promises } from 'fs'
+
+export const isEmptyDir = async (filePath: string) => {
+  try {
+    const directory = await promises.opendir(filePath)
+    const entry = await directory.read()
+    await directory.close()
+    return entry === null
+  } catch (_error) {
+    return false
+  }
+}
diff --git a/src_old/main/utils/json-manager.ts b/src_old/main/utils/json-manager.ts
new file mode 100644
index 000000000..1724e2834
--- /dev/null
+++ b/src_old/main/utils/json-manager.ts
@@ -0,0 +1,22 @@
+import { writeFile } from 'fs'
+import { join } from 'path'
+
+/**
+ *
+ * Function to create a JSON file.
+ *
+ * @param path A string containing the path to create the file.
+ * @param data The data to write.
+ * @param fileName The name of the file to create.
+ * @returns A boolean value indicating whether the file was created successfully or not.
+ */
+const CreateJSONFile = (path: string, data: string | NodeJS.ArrayBufferView, fileName: string) => {
+  const normalizedPath = join(path, `${fileName}.json`)
+  writeFile(normalizedPath, data, (error) => {
+    if (error) throw error
+  })
+
+  return { ok: true }
+}
+
+export { CreateJSONFile }
diff --git a/src/main/utils/path-picker.ts b/src_old/main/utils/path-picker.ts
similarity index 100%
rename from src/main/utils/path-picker.ts
rename to src_old/main/utils/path-picker.ts
diff --git a/src_old/main/utils/resolve-html-path.ts b/src_old/main/utils/resolve-html-path.ts
new file mode 100644
index 000000000..7f26b02e2
--- /dev/null
+++ b/src_old/main/utils/resolve-html-path.ts
@@ -0,0 +1,12 @@
+import path from 'path'
+import { URL } from 'url'
+
+export function resolveHtmlPath(htmlFileName: string) {
+  if (process.env.NODE_ENV === 'development') {
+    const port = process.env.PORT || 1212
+    const url = new URL(`http://localhost:${port}`)
+    url.pathname = htmlFileName
+    return url.href
+  }
+  return `file://${path.resolve(__dirname, '../renderer/', htmlFileName)}`
+}
diff --git a/src_old/main/utils/xml-manager.ts b/src_old/main/utils/xml-manager.ts
new file mode 100644
index 000000000..84db49f2e
--- /dev/null
+++ b/src_old/main/utils/xml-manager.ts
@@ -0,0 +1,18 @@
+import { writeFile } from 'fs'
+import { join } from 'path'
+
+/**
+ * Create a xml file with the given params.
+ * @param path - the path where the file must be created
+ * @param dataToWrite - the data to write in the file
+ * @param fileName - the file display name
+ */
+const CreateXMLFile = (path: string, dataToWrite: string, fileName: string) => {
+  const normalizedPath = join(path, `${fileName}.xml`)
+  writeFile(normalizedPath, dataToWrite, (error) => {
+    if (error) return { success: false, error }
+  })
+  return { success: true, message: 'Xml file created successfully' }
+}
+
+export { CreateXMLFile }
diff --git a/src/renderer/App.tsx b/src_old/renderer/App.tsx
similarity index 100%
rename from src/renderer/App.tsx
rename to src_old/renderer/App.tsx
diff --git a/src2/frontend/assets/folder.png b/src_old/renderer/assets/folder.png
similarity index 100%
rename from src2/frontend/assets/folder.png
rename to src_old/renderer/assets/folder.png
diff --git a/src/renderer/assets/icons/Fallback.tsx b/src_old/renderer/assets/icons/Fallback.tsx
similarity index 100%
rename from src/renderer/assets/icons/Fallback.tsx
rename to src_old/renderer/assets/icons/Fallback.tsx
diff --git a/src2/frontend/assets/icons/Types/iconTypes.tsx b/src_old/renderer/assets/icons/Types/iconTypes.tsx
similarity index 100%
rename from src2/frontend/assets/icons/Types/iconTypes.tsx
rename to src_old/renderer/assets/icons/Types/iconTypes.tsx
diff --git a/src2/frontend/assets/icons/about/logo.svg b/src_old/renderer/assets/icons/about/logo.svg
similarity index 100%
rename from src2/frontend/assets/icons/about/logo.svg
rename to src_old/renderer/assets/icons/about/logo.svg
diff --git a/src2/frontend/assets/icons/base/left-arrow.svg b/src_old/renderer/assets/icons/base/left-arrow.svg
similarity index 100%
rename from src2/frontend/assets/icons/base/left-arrow.svg
rename to src_old/renderer/assets/icons/base/left-arrow.svg
diff --git a/src2/frontend/assets/icons/base/right-arrow.svg b/src_old/renderer/assets/icons/base/right-arrow.svg
similarity index 100%
rename from src2/frontend/assets/icons/base/right-arrow.svg
rename to src_old/renderer/assets/icons/base/right-arrow.svg
diff --git a/src2/frontend/assets/icons/flow/Coil.tsx b/src_old/renderer/assets/icons/flow/Coil.tsx
similarity index 100%
rename from src2/frontend/assets/icons/flow/Coil.tsx
rename to src_old/renderer/assets/icons/flow/Coil.tsx
diff --git a/src2/frontend/assets/icons/flow/Contact.tsx b/src_old/renderer/assets/icons/flow/Contact.tsx
similarity index 100%
rename from src2/frontend/assets/icons/flow/Contact.tsx
rename to src_old/renderer/assets/icons/flow/Contact.tsx
diff --git a/src2/frontend/assets/icons/flow/Placeholder.tsx b/src_old/renderer/assets/icons/flow/Placeholder.tsx
similarity index 100%
rename from src2/frontend/assets/icons/flow/Placeholder.tsx
rename to src_old/renderer/assets/icons/flow/Placeholder.tsx
diff --git a/src/renderer/assets/icons/index.ts b/src_old/renderer/assets/icons/index.ts
similarity index 100%
rename from src/renderer/assets/icons/index.ts
rename to src_old/renderer/assets/icons/index.ts
diff --git a/src/renderer/assets/icons/interface/Arrow.tsx b/src_old/renderer/assets/icons/interface/Arrow.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Arrow.tsx
rename to src_old/renderer/assets/icons/interface/Arrow.tsx
diff --git a/src/renderer/assets/icons/interface/ArrowButton.tsx b/src_old/renderer/assets/icons/interface/ArrowButton.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/ArrowButton.tsx
rename to src_old/renderer/assets/icons/interface/ArrowButton.tsx
diff --git a/src/renderer/assets/icons/interface/ArrowUp.tsx b/src_old/renderer/assets/icons/interface/ArrowUp.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/ArrowUp.tsx
rename to src_old/renderer/assets/icons/interface/ArrowUp.tsx
diff --git a/src/renderer/assets/icons/interface/Book.tsx b/src_old/renderer/assets/icons/interface/Book.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Book.tsx
rename to src_old/renderer/assets/icons/interface/Book.tsx
diff --git a/src2/frontend/assets/icons/interface/Broom.tsx b/src_old/renderer/assets/icons/interface/Broom.tsx
similarity index 93%
rename from src2/frontend/assets/icons/interface/Broom.tsx
rename to src_old/renderer/assets/icons/interface/Broom.tsx
index 7a74fcca8..26491a9c5 100644
--- a/src2/frontend/assets/icons/interface/Broom.tsx
+++ b/src_old/renderer/assets/icons/interface/Broom.tsx
@@ -1,4 +1,4 @@
-import { ComponentPropsWithRef } from "react"
+import { ComponentPropsWithRef } from 'react'
 
 type BroomIconProps = ComponentPropsWithRef<'svg'>
 
diff --git a/src/renderer/assets/icons/interface/Close.tsx b/src_old/renderer/assets/icons/interface/Close.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Close.tsx
rename to src_old/renderer/assets/icons/interface/Close.tsx
diff --git a/src/renderer/assets/icons/interface/CodeIcon.tsx b/src_old/renderer/assets/icons/interface/CodeIcon.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/CodeIcon.tsx
rename to src_old/renderer/assets/icons/interface/CodeIcon.tsx
diff --git a/src/renderer/assets/icons/interface/Comment.tsx b/src_old/renderer/assets/icons/interface/Comment.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Comment.tsx
rename to src_old/renderer/assets/icons/interface/Comment.tsx
diff --git a/src/renderer/assets/icons/interface/Config.tsx b/src_old/renderer/assets/icons/interface/Config.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Config.tsx
rename to src_old/renderer/assets/icons/interface/Config.tsx
diff --git a/src/renderer/assets/icons/interface/DarkTheme.tsx b/src_old/renderer/assets/icons/interface/DarkTheme.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/DarkTheme.tsx
rename to src_old/renderer/assets/icons/interface/DarkTheme.tsx
diff --git a/src/renderer/assets/icons/interface/Debugger.tsx b/src_old/renderer/assets/icons/interface/Debugger.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Debugger.tsx
rename to src_old/renderer/assets/icons/interface/Debugger.tsx
diff --git a/src/renderer/assets/icons/interface/DeviceTransfer.tsx b/src_old/renderer/assets/icons/interface/DeviceTransfer.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/DeviceTransfer.tsx
rename to src_old/renderer/assets/icons/interface/DeviceTransfer.tsx
diff --git a/src/renderer/assets/icons/interface/Download.tsx b/src_old/renderer/assets/icons/interface/Download.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Download.tsx
rename to src_old/renderer/assets/icons/interface/Download.tsx
diff --git a/src2/frontend/assets/icons/interface/DragHandle.tsx b/src_old/renderer/assets/icons/interface/DragHandle.tsx
similarity index 100%
rename from src2/frontend/assets/icons/interface/DragHandle.tsx
rename to src_old/renderer/assets/icons/interface/DragHandle.tsx
diff --git a/src/renderer/assets/icons/interface/Duplicate.tsx b/src_old/renderer/assets/icons/interface/Duplicate.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Duplicate.tsx
rename to src_old/renderer/assets/icons/interface/Duplicate.tsx
diff --git a/src/renderer/assets/icons/interface/EditButton.tsx b/src_old/renderer/assets/icons/interface/EditButton.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/EditButton.tsx
rename to src_old/renderer/assets/icons/interface/EditButton.tsx
diff --git a/src/renderer/assets/icons/interface/Exit.tsx b/src_old/renderer/assets/icons/interface/Exit.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Exit.tsx
rename to src_old/renderer/assets/icons/interface/Exit.tsx
diff --git a/src/renderer/assets/icons/interface/Folder.tsx b/src_old/renderer/assets/icons/interface/Folder.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Folder.tsx
rename to src_old/renderer/assets/icons/interface/Folder.tsx
diff --git a/src/renderer/assets/icons/interface/LightTheme.tsx b/src_old/renderer/assets/icons/interface/LightTheme.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/LightTheme.tsx
rename to src_old/renderer/assets/icons/interface/LightTheme.tsx
diff --git a/src/renderer/assets/icons/interface/Magnifier.tsx b/src_old/renderer/assets/icons/interface/Magnifier.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Magnifier.tsx
rename to src_old/renderer/assets/icons/interface/Magnifier.tsx
diff --git a/src/renderer/assets/icons/interface/Minus.tsx b/src_old/renderer/assets/icons/interface/Minus.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Minus.tsx
rename to src_old/renderer/assets/icons/interface/Minus.tsx
diff --git a/src/renderer/assets/icons/interface/MoreOptions.tsx b/src_old/renderer/assets/icons/interface/MoreOptions.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/MoreOptions.tsx
rename to src_old/renderer/assets/icons/interface/MoreOptions.tsx
diff --git a/src/renderer/assets/icons/interface/Next.tsx b/src_old/renderer/assets/icons/interface/Next.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Next.tsx
rename to src_old/renderer/assets/icons/interface/Next.tsx
diff --git a/src/renderer/assets/icons/interface/Path.tsx b/src_old/renderer/assets/icons/interface/Path.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Path.tsx
rename to src_old/renderer/assets/icons/interface/Path.tsx
diff --git a/src/renderer/assets/icons/interface/Pause.tsx b/src_old/renderer/assets/icons/interface/Pause.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Pause.tsx
rename to src_old/renderer/assets/icons/interface/Pause.tsx
diff --git a/src/renderer/assets/icons/interface/Pencil.tsx b/src_old/renderer/assets/icons/interface/Pencil.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Pencil.tsx
rename to src_old/renderer/assets/icons/interface/Pencil.tsx
diff --git a/src/renderer/assets/icons/interface/Play.tsx b/src_old/renderer/assets/icons/interface/Play.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Play.tsx
rename to src_old/renderer/assets/icons/interface/Play.tsx
diff --git a/src/renderer/assets/icons/interface/Plus.tsx b/src_old/renderer/assets/icons/interface/Plus.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Plus.tsx
rename to src_old/renderer/assets/icons/interface/Plus.tsx
diff --git a/src/renderer/assets/icons/interface/Prohibited.tsx b/src_old/renderer/assets/icons/interface/Prohibited.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Prohibited.tsx
rename to src_old/renderer/assets/icons/interface/Prohibited.tsx
diff --git a/src/renderer/assets/icons/interface/Recent.tsx b/src_old/renderer/assets/icons/interface/Recent.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Recent.tsx
rename to src_old/renderer/assets/icons/interface/Recent.tsx
diff --git a/src/renderer/assets/icons/interface/Refresh.tsx b/src_old/renderer/assets/icons/interface/Refresh.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Refresh.tsx
rename to src_old/renderer/assets/icons/interface/Refresh.tsx
diff --git a/src/renderer/assets/icons/interface/Search.tsx b/src_old/renderer/assets/icons/interface/Search.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Search.tsx
rename to src_old/renderer/assets/icons/interface/Search.tsx
diff --git a/src/renderer/assets/icons/interface/StickArrow.tsx b/src_old/renderer/assets/icons/interface/StickArrow.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/StickArrow.tsx
rename to src_old/renderer/assets/icons/interface/StickArrow.tsx
diff --git a/src/renderer/assets/icons/interface/Stop.tsx b/src_old/renderer/assets/icons/interface/Stop.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Stop.tsx
rename to src_old/renderer/assets/icons/interface/Stop.tsx
diff --git a/src/renderer/assets/icons/interface/TableIcon.tsx b/src_old/renderer/assets/icons/interface/TableIcon.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/TableIcon.tsx
rename to src_old/renderer/assets/icons/interface/TableIcon.tsx
diff --git a/src/renderer/assets/icons/interface/Timer.tsx b/src_old/renderer/assets/icons/interface/Timer.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Timer.tsx
rename to src_old/renderer/assets/icons/interface/Timer.tsx
diff --git a/src/renderer/assets/icons/interface/Transfer.tsx b/src_old/renderer/assets/icons/interface/Transfer.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Transfer.tsx
rename to src_old/renderer/assets/icons/interface/Transfer.tsx
diff --git a/src/renderer/assets/icons/interface/TrashCan.tsx b/src_old/renderer/assets/icons/interface/TrashCan.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/TrashCan.tsx
rename to src_old/renderer/assets/icons/interface/TrashCan.tsx
diff --git a/src/renderer/assets/icons/interface/Video.tsx b/src_old/renderer/assets/icons/interface/Video.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Video.tsx
rename to src_old/renderer/assets/icons/interface/Video.tsx
diff --git a/src/renderer/assets/icons/interface/View.tsx b/src_old/renderer/assets/icons/interface/View.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/View.tsx
rename to src_old/renderer/assets/icons/interface/View.tsx
diff --git a/src/renderer/assets/icons/interface/ViewHidden.tsx b/src_old/renderer/assets/icons/interface/ViewHidden.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/ViewHidden.tsx
rename to src_old/renderer/assets/icons/interface/ViewHidden.tsx
diff --git a/src/renderer/assets/icons/interface/Warning.tsx b/src_old/renderer/assets/icons/interface/Warning.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Warning.tsx
rename to src_old/renderer/assets/icons/interface/Warning.tsx
diff --git a/src/renderer/assets/icons/interface/Zap.tsx b/src_old/renderer/assets/icons/interface/Zap.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/Zap.tsx
rename to src_old/renderer/assets/icons/interface/Zap.tsx
diff --git a/src/renderer/assets/icons/interface/ZoomInOut.tsx b/src_old/renderer/assets/icons/interface/ZoomInOut.tsx
similarity index 100%
rename from src/renderer/assets/icons/interface/ZoomInOut.tsx
rename to src_old/renderer/assets/icons/interface/ZoomInOut.tsx
diff --git a/src/renderer/assets/icons/library/CloseFolder.tsx b/src_old/renderer/assets/icons/library/CloseFolder.tsx
similarity index 100%
rename from src/renderer/assets/icons/library/CloseFolder.tsx
rename to src_old/renderer/assets/icons/library/CloseFolder.tsx
diff --git a/src/renderer/assets/icons/library/File.tsx b/src_old/renderer/assets/icons/library/File.tsx
similarity index 100%
rename from src/renderer/assets/icons/library/File.tsx
rename to src_old/renderer/assets/icons/library/File.tsx
diff --git a/src/renderer/assets/icons/library/OpenFolder.tsx b/src_old/renderer/assets/icons/library/OpenFolder.tsx
similarity index 100%
rename from src/renderer/assets/icons/library/OpenFolder.tsx
rename to src_old/renderer/assets/icons/library/OpenFolder.tsx
diff --git a/src/renderer/assets/icons/oplc.tsx b/src_old/renderer/assets/icons/oplc.tsx
similarity index 100%
rename from src/renderer/assets/icons/oplc.tsx
rename to src_old/renderer/assets/icons/oplc.tsx
diff --git a/src/renderer/assets/icons/project/Array.tsx b/src_old/renderer/assets/icons/project/Array.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Array.tsx
rename to src_old/renderer/assets/icons/project/Array.tsx
diff --git a/src/renderer/assets/icons/project/CExt.tsx b/src_old/renderer/assets/icons/project/CExt.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/CExt.tsx
rename to src_old/renderer/assets/icons/project/CExt.tsx
diff --git a/src/renderer/assets/icons/project/Cpp.tsx b/src_old/renderer/assets/icons/project/Cpp.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Cpp.tsx
rename to src_old/renderer/assets/icons/project/Cpp.tsx
diff --git a/src/renderer/assets/icons/project/DataType.tsx b/src_old/renderer/assets/icons/project/DataType.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/DataType.tsx
rename to src_old/renderer/assets/icons/project/DataType.tsx
diff --git a/src/renderer/assets/icons/project/Device.tsx b/src_old/renderer/assets/icons/project/Device.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Device.tsx
rename to src_old/renderer/assets/icons/project/Device.tsx
diff --git a/src/renderer/assets/icons/project/Enum.tsx b/src_old/renderer/assets/icons/project/Enum.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Enum.tsx
rename to src_old/renderer/assets/icons/project/Enum.tsx
diff --git a/src/renderer/assets/icons/project/FBD.tsx b/src_old/renderer/assets/icons/project/FBD.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/FBD.tsx
rename to src_old/renderer/assets/icons/project/FBD.tsx
diff --git a/src/renderer/assets/icons/project/Function.tsx b/src_old/renderer/assets/icons/project/Function.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Function.tsx
rename to src_old/renderer/assets/icons/project/Function.tsx
diff --git a/src/renderer/assets/icons/project/FunctionBlock.tsx b/src_old/renderer/assets/icons/project/FunctionBlock.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/FunctionBlock.tsx
rename to src_old/renderer/assets/icons/project/FunctionBlock.tsx
diff --git a/src/renderer/assets/icons/project/GenericDT.tsx b/src_old/renderer/assets/icons/project/GenericDT.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/GenericDT.tsx
rename to src_old/renderer/assets/icons/project/GenericDT.tsx
diff --git a/src/renderer/assets/icons/project/IL.tsx b/src_old/renderer/assets/icons/project/IL.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/IL.tsx
rename to src_old/renderer/assets/icons/project/IL.tsx
diff --git a/src/renderer/assets/icons/project/LD.tsx b/src_old/renderer/assets/icons/project/LD.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/LD.tsx
rename to src_old/renderer/assets/icons/project/LD.tsx
diff --git a/src/renderer/assets/icons/project/Loop.tsx b/src_old/renderer/assets/icons/project/Loop.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Loop.tsx
rename to src_old/renderer/assets/icons/project/Loop.tsx
diff --git a/src/renderer/assets/icons/project/PLC.tsx b/src_old/renderer/assets/icons/project/PLC.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/PLC.tsx
rename to src_old/renderer/assets/icons/project/PLC.tsx
diff --git a/src/renderer/assets/icons/project/Program.tsx b/src_old/renderer/assets/icons/project/Program.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Program.tsx
rename to src_old/renderer/assets/icons/project/Program.tsx
diff --git a/src/renderer/assets/icons/project/Python.tsx b/src_old/renderer/assets/icons/project/Python.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Python.tsx
rename to src_old/renderer/assets/icons/project/Python.tsx
diff --git a/src/renderer/assets/icons/project/RemoteDevice.tsx b/src_old/renderer/assets/icons/project/RemoteDevice.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/RemoteDevice.tsx
rename to src_old/renderer/assets/icons/project/RemoteDevice.tsx
diff --git a/src/renderer/assets/icons/project/Resource.tsx b/src_old/renderer/assets/icons/project/Resource.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Resource.tsx
rename to src_old/renderer/assets/icons/project/Resource.tsx
diff --git a/src/renderer/assets/icons/project/SFC.tsx b/src_old/renderer/assets/icons/project/SFC.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/SFC.tsx
rename to src_old/renderer/assets/icons/project/SFC.tsx
diff --git a/src/renderer/assets/icons/project/ST.tsx b/src_old/renderer/assets/icons/project/ST.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/ST.tsx
rename to src_old/renderer/assets/icons/project/ST.tsx
diff --git a/src/renderer/assets/icons/project/Server.tsx b/src_old/renderer/assets/icons/project/Server.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Server.tsx
rename to src_old/renderer/assets/icons/project/Server.tsx
diff --git a/src/renderer/assets/icons/project/Structure.tsx b/src_old/renderer/assets/icons/project/Structure.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/Structure.tsx
rename to src_old/renderer/assets/icons/project/Structure.tsx
diff --git a/src/renderer/assets/icons/project/fbd/Block.tsx b/src_old/renderer/assets/icons/project/fbd/Block.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/Block.tsx
rename to src_old/renderer/assets/icons/project/fbd/Block.tsx
diff --git a/src/renderer/assets/icons/project/fbd/Comment.tsx b/src_old/renderer/assets/icons/project/fbd/Comment.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/Comment.tsx
rename to src_old/renderer/assets/icons/project/fbd/Comment.tsx
diff --git a/src/renderer/assets/icons/project/fbd/Connector.tsx b/src_old/renderer/assets/icons/project/fbd/Connector.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/Connector.tsx
rename to src_old/renderer/assets/icons/project/fbd/Connector.tsx
diff --git a/src/renderer/assets/icons/project/fbd/Continuation.tsx b/src_old/renderer/assets/icons/project/fbd/Continuation.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/Continuation.tsx
rename to src_old/renderer/assets/icons/project/fbd/Continuation.tsx
diff --git a/src/renderer/assets/icons/project/fbd/VariableIn.tsx b/src_old/renderer/assets/icons/project/fbd/VariableIn.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/VariableIn.tsx
rename to src_old/renderer/assets/icons/project/fbd/VariableIn.tsx
diff --git a/src/renderer/assets/icons/project/fbd/VariableInOut.tsx b/src_old/renderer/assets/icons/project/fbd/VariableInOut.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/VariableInOut.tsx
rename to src_old/renderer/assets/icons/project/fbd/VariableInOut.tsx
diff --git a/src/renderer/assets/icons/project/fbd/VariableOut.tsx b/src_old/renderer/assets/icons/project/fbd/VariableOut.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/fbd/VariableOut.tsx
rename to src_old/renderer/assets/icons/project/fbd/VariableOut.tsx
diff --git a/src/renderer/assets/icons/project/ladder/Block.tsx b/src_old/renderer/assets/icons/project/ladder/Block.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/ladder/Block.tsx
rename to src_old/renderer/assets/icons/project/ladder/Block.tsx
diff --git a/src/renderer/assets/icons/project/ladder/Coil.tsx b/src_old/renderer/assets/icons/project/ladder/Coil.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/ladder/Coil.tsx
rename to src_old/renderer/assets/icons/project/ladder/Coil.tsx
diff --git a/src/renderer/assets/icons/project/ladder/Contact.tsx b/src_old/renderer/assets/icons/project/ladder/Contact.tsx
similarity index 100%
rename from src/renderer/assets/icons/project/ladder/Contact.tsx
rename to src_old/renderer/assets/icons/project/ladder/Contact.tsx
diff --git a/src2/frontend/assets/icons/window-controls/Close.tsx b/src_old/renderer/assets/icons/window-controls/Close.tsx
similarity index 100%
rename from src2/frontend/assets/icons/window-controls/Close.tsx
rename to src_old/renderer/assets/icons/window-controls/Close.tsx
diff --git a/src2/frontend/assets/icons/window-controls/Exit-Maximize.tsx b/src_old/renderer/assets/icons/window-controls/Exit-Maximize.tsx
similarity index 100%
rename from src2/frontend/assets/icons/window-controls/Exit-Maximize.tsx
rename to src_old/renderer/assets/icons/window-controls/Exit-Maximize.tsx
diff --git a/src2/frontend/assets/icons/window-controls/Maximize.tsx b/src_old/renderer/assets/icons/window-controls/Maximize.tsx
similarity index 100%
rename from src2/frontend/assets/icons/window-controls/Maximize.tsx
rename to src_old/renderer/assets/icons/window-controls/Maximize.tsx
diff --git a/src_old/renderer/assets/icons/window-controls/Minimize.tsx b/src_old/renderer/assets/icons/window-controls/Minimize.tsx
new file mode 100644
index 000000000..3df3ba927
--- /dev/null
+++ b/src_old/renderer/assets/icons/window-controls/Minimize.tsx
@@ -0,0 +1,10 @@
+const MinimizeIcon = () => {
+  return (
+    <svg width='12' height='2' viewBox='0 0 16 2' fill='none' xmlns='http://www.w3.org/2000/svg'>
+      <title>Minimize</title>
+      <path d='M1 1H15' stroke='white' strokeWidth='1.5' strokeLinecap='round' />
+    </svg>
+  )
+}
+
+export { MinimizeIcon }
diff --git a/src2/frontend/assets/images/example.png b/src_old/renderer/assets/images/example.png
similarity index 100%
rename from src2/frontend/assets/images/example.png
rename to src_old/renderer/assets/images/example.png
diff --git a/src/renderer/assets/index.ts b/src_old/renderer/assets/index.ts
similarity index 100%
rename from src/renderer/assets/index.ts
rename to src_old/renderer/assets/index.ts
diff --git a/src/renderer/components/_atoms/accordion/index.tsx b/src_old/renderer/components/_atoms/accordion/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/accordion/index.tsx
rename to src_old/renderer/components/_atoms/accordion/index.tsx
diff --git a/src/renderer/components/_atoms/buttons/activity-bar/index.tsx b/src_old/renderer/components/_atoms/buttons/activity-bar/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/buttons/activity-bar/index.tsx
rename to src_old/renderer/components/_atoms/buttons/activity-bar/index.tsx
diff --git a/src/renderer/components/_atoms/buttons/console/clear-console.tsx b/src_old/renderer/components/_atoms/buttons/console/clear-console.tsx
similarity index 100%
rename from src/renderer/components/_atoms/buttons/console/clear-console.tsx
rename to src_old/renderer/components/_atoms/buttons/console/clear-console.tsx
diff --git a/src/renderer/components/_atoms/buttons/default/index.tsx b/src_old/renderer/components/_atoms/buttons/default/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/buttons/default/index.tsx
rename to src_old/renderer/components/_atoms/buttons/default/index.tsx
diff --git a/src/renderer/components/_atoms/buttons/index.ts b/src_old/renderer/components/_atoms/buttons/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/buttons/index.ts
rename to src_old/renderer/components/_atoms/buttons/index.ts
diff --git a/src/renderer/components/_atoms/buttons/tables-actions/index.tsx b/src_old/renderer/components/_atoms/buttons/tables-actions/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/buttons/tables-actions/index.tsx
rename to src_old/renderer/components/_atoms/buttons/tables-actions/index.tsx
diff --git a/src/renderer/components/_atoms/buttons/window-control/index.tsx b/src_old/renderer/components/_atoms/buttons/window-control/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/buttons/window-control/index.tsx
rename to src_old/renderer/components/_atoms/buttons/window-control/index.tsx
diff --git a/src2/frontend/components/_atoms/card/index.tsx b/src_old/renderer/components/_atoms/card/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/card/index.tsx
rename to src_old/renderer/components/_atoms/card/index.tsx
diff --git a/src/renderer/components/_atoms/checkbox/index.tsx b/src_old/renderer/components/_atoms/checkbox/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/checkbox/index.tsx
rename to src_old/renderer/components/_atoms/checkbox/index.tsx
diff --git a/src/renderer/components/_atoms/debug-tree-node/index.tsx b/src_old/renderer/components/_atoms/debug-tree-node/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/debug-tree-node/index.tsx
rename to src_old/renderer/components/_atoms/debug-tree-node/index.tsx
diff --git a/src/renderer/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx b/src_old/renderer/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
rename to src_old/renderer/components/_atoms/dimensions-modal/array-dimensions-input/index.tsx
diff --git a/src/renderer/components/_atoms/dimensions-modal/index.tsx b/src_old/renderer/components/_atoms/dimensions-modal/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/dimensions-modal/index.tsx
rename to src_old/renderer/components/_atoms/dimensions-modal/index.tsx
diff --git a/src/renderer/components/_atoms/file/index.tsx b/src_old/renderer/components/_atoms/file/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/file/index.tsx
rename to src_old/renderer/components/_atoms/file/index.tsx
diff --git a/src/renderer/components/_atoms/generic-data-type-table/index.tsx b/src_old/renderer/components/_atoms/generic-data-type-table/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-data-type-table/index.tsx
rename to src_old/renderer/components/_atoms/generic-data-type-table/index.tsx
diff --git a/src/renderer/components/_atoms/generic-table-inputs/generic-button-cell.tsx b/src_old/renderer/components/_atoms/generic-table-inputs/generic-button-cell.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-table-inputs/generic-button-cell.tsx
rename to src_old/renderer/components/_atoms/generic-table-inputs/generic-button-cell.tsx
diff --git a/src/renderer/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx b/src_old/renderer/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
rename to src_old/renderer/components/_atoms/generic-table-inputs/generic-combobox-cell.tsx
diff --git a/src/renderer/components/_atoms/generic-table-inputs/generic-select-cell.tsx b/src_old/renderer/components/_atoms/generic-table-inputs/generic-select-cell.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-table-inputs/generic-select-cell.tsx
rename to src_old/renderer/components/_atoms/generic-table-inputs/generic-select-cell.tsx
diff --git a/src/renderer/components/_atoms/generic-table-inputs/generic-text-cell.tsx b/src_old/renderer/components/_atoms/generic-table-inputs/generic-text-cell.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-table-inputs/generic-text-cell.tsx
rename to src_old/renderer/components/_atoms/generic-table-inputs/generic-text-cell.tsx
diff --git a/src/renderer/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx b/src_old/renderer/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
rename to src_old/renderer/components/_atoms/generic-table-inputs/generic-textarea-cell.tsx
diff --git a/src/renderer/components/_atoms/generic-table-inputs/index.ts b/src_old/renderer/components/_atoms/generic-table-inputs/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/generic-table-inputs/index.ts
rename to src_old/renderer/components/_atoms/generic-table-inputs/index.ts
diff --git a/src/renderer/components/_atoms/generic-table/index.tsx b/src_old/renderer/components/_atoms/generic-table/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/generic-table/index.tsx
rename to src_old/renderer/components/_atoms/generic-table/index.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/autocomplete/index.tsx b/src_old/renderer/components/_atoms/graphical-editor/autocomplete/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/autocomplete/index.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/autocomplete/index.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/block-output-debug-badges.tsx b/src_old/renderer/components/_atoms/graphical-editor/block-output-debug-badges.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/block-output-debug-badges.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/block-output-debug-badges.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/debug-value-badge.tsx b/src_old/renderer/components/_atoms/graphical-editor/debug-value-badge.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/debug-value-badge.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/debug-value-badge.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/autocomplete/index.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/block.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/block.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/block.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/block.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/comment.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/comment.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/comment.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/comment.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/connection.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/connection.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/connection.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/connection.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/handle.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/handle.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/handle.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/handle.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/index.ts b/src_old/renderer/components/_atoms/graphical-editor/fbd/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/index.ts
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/index.ts
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/svg/connector-svg.tsx
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/svg/continuation-svg.tsx
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/svg/index.ts b/src_old/renderer/components/_atoms/graphical-editor/fbd/svg/index.ts
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/svg/index.ts
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/svg/index.ts
diff --git a/src2/frontend/components/_atoms/graphical-editor/fbd/utils/index.ts b/src_old/renderer/components/_atoms/graphical-editor/fbd/utils/index.ts
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/fbd/utils/index.ts
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/utils/index.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/utils/types.ts b/src_old/renderer/components/_atoms/graphical-editor/fbd/utils/types.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/utils/types.ts
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/utils/types.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/utils/utils.ts b/src_old/renderer/components/_atoms/graphical-editor/fbd/utils/utils.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/utils/utils.ts
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/utils/utils.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/fbd/variable.tsx b/src_old/renderer/components/_atoms/graphical-editor/fbd/variable.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/fbd/variable.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/fbd/variable.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/autocomplete/index.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/block.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/block.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/block.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/block.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/coil.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/coil.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/coil.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/coil.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/contact.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/contact.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/contact.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/contact.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/handle.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/handle.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/handle.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/handle.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/index.ts b/src_old/renderer/components/_atoms/graphical-editor/ladder/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/index.ts
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/index.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/mock-node.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/mock-node.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/mock-node.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/mock-node.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/parallel.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/parallel.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/parallel.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/parallel.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/placeholder.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/placeholder.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/placeholder.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/placeholder.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/power-rail.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/power-rail.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/power-rail.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/power-rail.tsx
diff --git a/src2/frontend/components/_atoms/graphical-editor/ladder/utils/index.ts b/src_old/renderer/components/_atoms/graphical-editor/ladder/utils/index.ts
similarity index 100%
rename from src2/frontend/components/_atoms/graphical-editor/ladder/utils/index.ts
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/utils/index.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/utils/types.ts b/src_old/renderer/components/_atoms/graphical-editor/ladder/utils/types.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/utils/types.ts
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/utils/types.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/utils/utils.ts b/src_old/renderer/components/_atoms/graphical-editor/ladder/utils/utils.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/utils/utils.ts
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/utils/utils.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/ladder/variable.tsx b/src_old/renderer/components/_atoms/graphical-editor/ladder/variable.tsx
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/ladder/variable.tsx
rename to src_old/renderer/components/_atoms/graphical-editor/ladder/variable.tsx
diff --git a/src/renderer/components/_atoms/graphical-editor/types/block.ts b/src_old/renderer/components/_atoms/graphical-editor/types/block.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/types/block.ts
rename to src_old/renderer/components/_atoms/graphical-editor/types/block.ts
diff --git a/src/renderer/components/_atoms/graphical-editor/utils/index.ts b/src_old/renderer/components/_atoms/graphical-editor/utils/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/graphical-editor/utils/index.ts
rename to src_old/renderer/components/_atoms/graphical-editor/utils/index.ts
diff --git a/src2/frontend/components/_atoms/highlighted-text/index.tsx b/src_old/renderer/components/_atoms/highlighted-text/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/highlighted-text/index.tsx
rename to src_old/renderer/components/_atoms/highlighted-text/index.tsx
diff --git a/src/renderer/components/_atoms/highlighted-textarea/index.tsx b/src_old/renderer/components/_atoms/highlighted-textarea/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/highlighted-textarea/index.tsx
rename to src_old/renderer/components/_atoms/highlighted-textarea/index.tsx
diff --git a/src/renderer/components/_atoms/index.ts b/src_old/renderer/components/_atoms/index.ts
similarity index 100%
rename from src/renderer/components/_atoms/index.ts
rename to src_old/renderer/components/_atoms/index.ts
diff --git a/src/renderer/components/_atoms/input/index.tsx b/src_old/renderer/components/_atoms/input/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/input/index.tsx
rename to src_old/renderer/components/_atoms/input/index.tsx
diff --git a/src/renderer/components/_atoms/label/index.tsx b/src_old/renderer/components/_atoms/label/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/label/index.tsx
rename to src_old/renderer/components/_atoms/label/index.tsx
diff --git a/src/renderer/components/_atoms/react-flow/index.tsx b/src_old/renderer/components/_atoms/react-flow/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/react-flow/index.tsx
rename to src_old/renderer/components/_atoms/react-flow/index.tsx
diff --git a/src/renderer/components/_atoms/react-flow/style.css b/src_old/renderer/components/_atoms/react-flow/style.css
similarity index 100%
rename from src/renderer/components/_atoms/react-flow/style.css
rename to src_old/renderer/components/_atoms/react-flow/style.css
diff --git a/src/renderer/components/_atoms/select/index.tsx b/src_old/renderer/components/_atoms/select/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/select/index.tsx
rename to src_old/renderer/components/_atoms/select/index.tsx
diff --git a/src2/frontend/components/_atoms/tab-list/index.tsx b/src_old/renderer/components/_atoms/tab-list/index.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/tab-list/index.tsx
rename to src_old/renderer/components/_atoms/tab-list/index.tsx
diff --git a/src/renderer/components/_atoms/tab/index.tsx b/src_old/renderer/components/_atoms/tab/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/tab/index.tsx
rename to src_old/renderer/components/_atoms/tab/index.tsx
diff --git a/src/renderer/components/_atoms/table-actions/index.tsx b/src_old/renderer/components/_atoms/table-actions/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/table-actions/index.tsx
rename to src_old/renderer/components/_atoms/table-actions/index.tsx
diff --git a/src/renderer/components/_atoms/table/index.tsx b/src_old/renderer/components/_atoms/table/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/table/index.tsx
rename to src_old/renderer/components/_atoms/table/index.tsx
diff --git a/src/renderer/components/_atoms/tooltip/index.tsx b/src_old/renderer/components/_atoms/tooltip/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/tooltip/index.tsx
rename to src_old/renderer/components/_atoms/tooltip/index.tsx
diff --git a/src/renderer/components/_atoms/type-dropdown-selector/index.tsx b/src_old/renderer/components/_atoms/type-dropdown-selector/index.tsx
similarity index 100%
rename from src/renderer/components/_atoms/type-dropdown-selector/index.tsx
rename to src_old/renderer/components/_atoms/type-dropdown-selector/index.tsx
diff --git a/src2/frontend/components/_atoms/workspace-activity-bar/divider.tsx b/src_old/renderer/components/_atoms/workspace-activity-bar/divider.tsx
similarity index 100%
rename from src2/frontend/components/_atoms/workspace-activity-bar/divider.tsx
rename to src_old/renderer/components/_atoms/workspace-activity-bar/divider.tsx
diff --git a/src/renderer/components/_features/[app]/index.ts b/src_old/renderer/components/_features/[app]/index.ts
similarity index 100%
rename from src/renderer/components/_features/[app]/index.ts
rename to src_old/renderer/components/_features/[app]/index.ts
diff --git a/src/renderer/components/_features/[app]/toast/index.tsx b/src_old/renderer/components/_features/[app]/toast/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[app]/toast/index.tsx
rename to src_old/renderer/components/_features/[app]/toast/index.tsx
diff --git a/src2/frontend/components/_features/[app]/toast/toaster.tsx b/src_old/renderer/components/_features/[app]/toast/toaster.tsx
similarity index 100%
rename from src2/frontend/components/_features/[app]/toast/toaster.tsx
rename to src_old/renderer/components/_features/[app]/toast/toaster.tsx
diff --git a/src/renderer/components/_features/[app]/toast/use-toast.tsx b/src_old/renderer/components/_features/[app]/toast/use-toast.tsx
similarity index 100%
rename from src/renderer/components/_features/[app]/toast/use-toast.tsx
rename to src_old/renderer/components/_features/[app]/toast/use-toast.tsx
diff --git a/src/renderer/components/_features/[start]/menu/index.tsx b/src_old/renderer/components/_features/[start]/menu/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[start]/menu/index.tsx
rename to src_old/renderer/components/_features/[start]/menu/index.tsx
diff --git a/src/renderer/components/_features/[start]/new-project/interval-model.tsx b/src_old/renderer/components/_features/[start]/new-project/interval-model.tsx
similarity index 100%
rename from src/renderer/components/_features/[start]/new-project/interval-model.tsx
rename to src_old/renderer/components/_features/[start]/new-project/interval-model.tsx
diff --git a/src/renderer/components/_features/[start]/new-project/project-modal.tsx b/src_old/renderer/components/_features/[start]/new-project/project-modal.tsx
similarity index 100%
rename from src/renderer/components/_features/[start]/new-project/project-modal.tsx
rename to src_old/renderer/components/_features/[start]/new-project/project-modal.tsx
diff --git a/src/renderer/components/_features/[start]/new-project/steps/first-step.tsx b/src_old/renderer/components/_features/[start]/new-project/steps/first-step.tsx
similarity index 100%
rename from src/renderer/components/_features/[start]/new-project/steps/first-step.tsx
rename to src_old/renderer/components/_features/[start]/new-project/steps/first-step.tsx
diff --git a/src/renderer/components/_features/[start]/new-project/steps/second-step.tsx b/src_old/renderer/components/_features/[start]/new-project/steps/second-step.tsx
similarity index 100%
rename from src/renderer/components/_features/[start]/new-project/steps/second-step.tsx
rename to src_old/renderer/components/_features/[start]/new-project/steps/second-step.tsx
diff --git a/src/renderer/components/_features/[start]/new-project/steps/third-step.tsx b/src_old/renderer/components/_features/[start]/new-project/steps/third-step.tsx
similarity index 100%
rename from src/renderer/components/_features/[start]/new-project/steps/third-step.tsx
rename to src_old/renderer/components/_features/[start]/new-project/steps/third-step.tsx
diff --git a/src2/frontend/components/_features/[start]/new-project/store/index.ts b/src_old/renderer/components/_features/[start]/new-project/store/index.ts
similarity index 100%
rename from src2/frontend/components/_features/[start]/new-project/store/index.ts
rename to src_old/renderer/components/_features/[start]/new-project/store/index.ts
diff --git a/src/renderer/components/_features/[workspace]/create-element/element-card/data-type-element.tsx b/src_old/renderer/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
rename to src_old/renderer/components/_features/[workspace]/create-element/element-card/data-type-element.tsx
diff --git a/src/renderer/components/_features/[workspace]/create-element/element-card/index.tsx b/src_old/renderer/components/_features/[workspace]/create-element/element-card/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/create-element/element-card/index.tsx
rename to src_old/renderer/components/_features/[workspace]/create-element/element-card/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/create-element/index.tsx b/src_old/renderer/components/_features/[workspace]/create-element/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/create-element/index.tsx
rename to src_old/renderer/components/_features/[workspace]/create-element/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/data-type/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/data-type/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/data-type/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/data-type/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/board.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/board.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/board.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/board.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/communication.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/communication.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/communication.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/communication.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-rtu.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/modbus-tcp.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/pin-mapping-table.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/components/static-host.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/configuration/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/configuration/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/configuration/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/configuration/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/device/remote-device/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/device/remote-device/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/device/remote-device/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/device/remote-device/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/FBD/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/FBD/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/FBD/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/FBD/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/SFC/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/SFC/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/SFC/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/SFC/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/arrow-button-group/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/fbd/block/library.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/block/library.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/coil/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/contact/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/Group112.png b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/Group112.png
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/Group112.png
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/Group112.png
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image1.png b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image1.png
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image1.png
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image1.png
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image2.png b/src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image2.png
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image2.png
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/elements/ladder/mockImages/image2.png
diff --git a/src2/frontend/components/_features/[workspace]/editor/graphical/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/index.tsx
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/graphical/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/graphical/ladder/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/graphical/ladder/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/graphical/ladder/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/graphical/ladder/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/index.ts b/src_old/renderer/components/_features/[workspace]/editor/index.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/index.ts
rename to src_old/renderer/components/_features/[workspace]/editor/index.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/completion/cpp.completion.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/completion/datatype.completion.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/completion/fb.completion.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/completion/index.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/completion/index.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/completion/index.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/completion/index.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/index.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/index.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/index.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/index.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/_.register.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.register.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/il/il.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.register.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.snippets.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/python/python.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.register.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.snippets.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/languages/st/st.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/themes/_.register.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.register.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/configs/themes/openplc/openplc.ts
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/drag-and-drop/st.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/monaco/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/monaco/index.tsx
similarity index 99%
rename from src/renderer/components/_features/[workspace]/editor/monaco/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/index.tsx
index 31226bac3..a0c678c1d 100644
--- a/src/renderer/components/_features/[workspace]/editor/monaco/index.tsx
+++ b/src_old/renderer/components/_features/[workspace]/editor/monaco/index.tsx
@@ -114,6 +114,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   const editorRef = useRef<null | monaco.editor.IStandaloneCodeEditor>(null)
   const monacoRef = useRef<null | typeof monaco>(null)
   const focusDisposables = useRef<{ onFocus?: monaco.IDisposable; onBlur?: monaco.IDisposable }>({})
+  const [editorMounted, setEditorMounted] = useState(false)
 
   const {
     editor,
@@ -356,7 +357,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     }
 
     return { prefix, positions }
-  }, [isDebuggerVisible, debugVarKeySet, language, name, fbInstanceContext])
+  }, [isDebuggerVisible, debugVarKeySet, language, name, fbInstanceContext, editorMounted])
 
   // Phase 2: stamp current values onto cached positions (runs on each poll, O(positions) map lookups only)
   useEffect(() => {
@@ -724,6 +725,7 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
   ) {
     editorRef.current = editorInstance
     monacoRef.current = monacoInstance
+    setEditorMounted(true)
 
     if (!editorInstance || !monacoInstance) return
 
diff --git a/src2/frontend/components/_features/[workspace]/editor/monaco/python-lsp/index.ts b/src_old/renderer/components/_features/[workspace]/editor/monaco/python-lsp/index.ts
similarity index 100%
rename from src2/frontend/components/_features/[workspace]/editor/monaco/python-lsp/index.ts
rename to src_old/renderer/components/_features/[workspace]/editor/monaco/python-lsp/index.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/resource-editor/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/resource-editor/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/resource-editor/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/resource-editor/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/search-in-project/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/search-in-project/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/search-in-project/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/search-in-project/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/index.ts b/src_old/renderer/components/_features/[workspace]/editor/server/index.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/index.ts
rename to src_old/renderer/components/_features/[workspace]/editor/server/index.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/server/modbus-server/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/modbus-server/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/modbus-server/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/modbus-server/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/address-space-tab.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificate-modal.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/certificates-tab.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profile-modal.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/security-profiles-tab.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/selected-variables-list.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/user-modal.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/users-tab.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-config-modal.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/components/variable-tree.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/hooks/use-project-variables.ts
diff --git a/src/renderer/components/_features/[workspace]/editor/server/opcua-server/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/opcua-server/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/opcua-server/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/editor/server/s7comm-server/index.tsx b/src_old/renderer/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
rename to src_old/renderer/components/_features/[workspace]/editor/server/s7comm-server/index.tsx
diff --git a/src/renderer/components/_features/[workspace]/search/display/tree-view.tsx b/src_old/renderer/components/_features/[workspace]/search/display/tree-view.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/search/display/tree-view.tsx
rename to src_old/renderer/components/_features/[workspace]/search/display/tree-view.tsx
diff --git a/src/renderer/components/_features/[workspace]/search/index.tsx b/src_old/renderer/components/_features/[workspace]/search/index.tsx
similarity index 100%
rename from src/renderer/components/_features/[workspace]/search/index.tsx
rename to src_old/renderer/components/_features/[workspace]/search/index.tsx
diff --git a/src/renderer/components/_molecules/breadcrumbs/index.tsx b/src_old/renderer/components/_molecules/breadcrumbs/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/breadcrumbs/index.tsx
rename to src_old/renderer/components/_molecules/breadcrumbs/index.tsx
diff --git a/src/renderer/components/_molecules/charts/index.ts b/src_old/renderer/components/_molecules/charts/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/charts/index.ts
rename to src_old/renderer/components/_molecules/charts/index.ts
diff --git a/src/renderer/components/_molecules/charts/line-chart.tsx b/src_old/renderer/components/_molecules/charts/line-chart.tsx
similarity index 100%
rename from src/renderer/components/_molecules/charts/line-chart.tsx
rename to src_old/renderer/components/_molecules/charts/line-chart.tsx
diff --git a/src/renderer/components/_molecules/data-types/array/header/base-type.tsx b/src_old/renderer/components/_molecules/data-types/array/header/base-type.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/array/header/base-type.tsx
rename to src_old/renderer/components/_molecules/data-types/array/header/base-type.tsx
diff --git a/src2/frontend/components/_molecules/data-types/array/header/initial-value.tsx b/src_old/renderer/components/_molecules/data-types/array/header/initial-value.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/data-types/array/header/initial-value.tsx
rename to src_old/renderer/components/_molecules/data-types/array/header/initial-value.tsx
diff --git a/src/renderer/components/_molecules/data-types/array/index.tsx b/src_old/renderer/components/_molecules/data-types/array/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/array/index.tsx
rename to src_old/renderer/components/_molecules/data-types/array/index.tsx
diff --git a/src/renderer/components/_molecules/data-types/array/table/editable-cell.tsx b/src_old/renderer/components/_molecules/data-types/array/table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/array/table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/data-types/array/table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/data-types/array/table/index.tsx b/src_old/renderer/components/_molecules/data-types/array/table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/array/table/index.tsx
rename to src_old/renderer/components/_molecules/data-types/array/table/index.tsx
diff --git a/src/renderer/components/_molecules/data-types/enumerated/index.tsx b/src_old/renderer/components/_molecules/data-types/enumerated/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/enumerated/index.tsx
rename to src_old/renderer/components/_molecules/data-types/enumerated/index.tsx
diff --git a/src/renderer/components/_molecules/data-types/enumerated/table/editable-cell.tsx b/src_old/renderer/components/_molecules/data-types/enumerated/table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/enumerated/table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/data-types/enumerated/table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/data-types/enumerated/table/index.tsx b/src_old/renderer/components/_molecules/data-types/enumerated/table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/enumerated/table/index.tsx
rename to src_old/renderer/components/_molecules/data-types/enumerated/table/index.tsx
diff --git a/src/renderer/components/_molecules/data-types/structure/index.tsx b/src_old/renderer/components/_molecules/data-types/structure/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/structure/index.tsx
rename to src_old/renderer/components/_molecules/data-types/structure/index.tsx
diff --git a/src/renderer/components/_molecules/data-types/structure/table/editable-cell.tsx b/src_old/renderer/components/_molecules/data-types/structure/table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/structure/table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/data-types/structure/table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/data-types/structure/table/elements/array-modal.tsx b/src_old/renderer/components/_molecules/data-types/structure/table/elements/array-modal.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/structure/table/elements/array-modal.tsx
rename to src_old/renderer/components/_molecules/data-types/structure/table/elements/array-modal.tsx
diff --git a/src/renderer/components/_molecules/data-types/structure/table/index.tsx b/src_old/renderer/components/_molecules/data-types/structure/table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/structure/table/index.tsx
rename to src_old/renderer/components/_molecules/data-types/structure/table/index.tsx
diff --git a/src/renderer/components/_molecules/data-types/structure/table/selectable-cell.tsx b/src_old/renderer/components/_molecules/data-types/structure/table/selectable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/data-types/structure/table/selectable-cell.tsx
rename to src_old/renderer/components/_molecules/data-types/structure/table/selectable-cell.tsx
diff --git a/src/renderer/components/_molecules/file/file-label.tsx b/src_old/renderer/components/_molecules/file/file-label.tsx
similarity index 100%
rename from src/renderer/components/_molecules/file/file-label.tsx
rename to src_old/renderer/components/_molecules/file/file-label.tsx
diff --git a/src/renderer/components/_molecules/file/file-root.tsx b/src_old/renderer/components/_molecules/file/file-root.tsx
similarity index 100%
rename from src/renderer/components/_molecules/file/file-root.tsx
rename to src_old/renderer/components/_molecules/file/file-root.tsx
diff --git a/src2/frontend/components/_molecules/file/file-shape.tsx b/src_old/renderer/components/_molecules/file/file-shape.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/file/file-shape.tsx
rename to src_old/renderer/components/_molecules/file/file-shape.tsx
diff --git a/src2/frontend/components/_molecules/file/index.ts b/src_old/renderer/components/_molecules/file/index.ts
similarity index 100%
rename from src2/frontend/components/_molecules/file/index.ts
rename to src_old/renderer/components/_molecules/file/index.ts
diff --git a/src/renderer/components/_molecules/global-variables-table/editable-cell.tsx b/src_old/renderer/components/_molecules/global-variables-table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/global-variables-table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/global-variables-table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/global-variables-table/elements/array-modal.tsx b/src_old/renderer/components/_molecules/global-variables-table/elements/array-modal.tsx
similarity index 100%
rename from src/renderer/components/_molecules/global-variables-table/elements/array-modal.tsx
rename to src_old/renderer/components/_molecules/global-variables-table/elements/array-modal.tsx
diff --git a/src/renderer/components/_molecules/global-variables-table/index.tsx b/src_old/renderer/components/_molecules/global-variables-table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/global-variables-table/index.tsx
rename to src_old/renderer/components/_molecules/global-variables-table/index.tsx
diff --git a/src/renderer/components/_molecules/global-variables-table/selectable-cell.tsx b/src_old/renderer/components/_molecules/global-variables-table/selectable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/global-variables-table/selectable-cell.tsx
rename to src_old/renderer/components/_molecules/global-variables-table/selectable-cell.tsx
diff --git a/src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts b/src_old/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts
similarity index 100%
rename from src2/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts
rename to src_old/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/edges.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts b/src_old/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
rename to src_old/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts b/src_old/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
rename to src_old/renderer/components/_molecules/graphical-editor/fbd/fbd-utils/useCopyPaste.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/fbd/index.tsx b/src_old/renderer/components/_molecules/graphical-editor/fbd/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/fbd/index.tsx
rename to src_old/renderer/components/_molecules/graphical-editor/fbd/index.tsx
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/body.tsx b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/body.tsx
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/body.tsx
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/body.tsx
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/create-rung.tsx
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/header.tsx b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/header.tsx
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/header.tsx
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/header.tsx
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/edges.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/diagram/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/drag-n-drop/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/parallel/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/placeholder/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/serial/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/utils/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/elements/variable-block/index.ts
diff --git a/src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts b/src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
similarity index 100%
rename from src/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
rename to src_old/renderer/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
diff --git a/src/renderer/components/_molecules/index.ts b/src_old/renderer/components/_molecules/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/index.ts
rename to src_old/renderer/components/_molecules/index.ts
diff --git a/src/renderer/components/_molecules/input-field/index.tsx b/src_old/renderer/components/_molecules/input-field/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/input-field/index.tsx
rename to src_old/renderer/components/_molecules/input-field/index.tsx
diff --git a/src/renderer/components/_molecules/instances-table/editable-cell.tsx b/src_old/renderer/components/_molecules/instances-table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/instances-table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/instances-table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/instances-table/index.tsx b/src_old/renderer/components/_molecules/instances-table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/instances-table/index.tsx
rename to src_old/renderer/components/_molecules/instances-table/index.tsx
diff --git a/src/renderer/components/_molecules/instances-table/selectable-cell.tsx b/src_old/renderer/components/_molecules/instances-table/selectable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/instances-table/selectable-cell.tsx
rename to src_old/renderer/components/_molecules/instances-table/selectable-cell.tsx
diff --git a/src/renderer/components/_molecules/library-tree/index.tsx b/src_old/renderer/components/_molecules/library-tree/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/library-tree/index.tsx
rename to src_old/renderer/components/_molecules/library-tree/index.tsx
diff --git a/src2/frontend/components/_molecules/menu-bar/constants.ts b/src_old/renderer/components/_molecules/menu-bar/constants.ts
similarity index 100%
rename from src2/frontend/components/_molecules/menu-bar/constants.ts
rename to src_old/renderer/components/_molecules/menu-bar/constants.ts
diff --git a/src/renderer/components/_molecules/menu-bar/index.tsx b/src_old/renderer/components/_molecules/menu-bar/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/index.tsx
rename to src_old/renderer/components/_molecules/menu-bar/index.tsx
diff --git a/src/renderer/components/_molecules/menu-bar/menus/display.tsx b/src_old/renderer/components/_molecules/menu-bar/menus/display.tsx
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/menus/display.tsx
rename to src_old/renderer/components/_molecules/menu-bar/menus/display.tsx
diff --git a/src/renderer/components/_molecules/menu-bar/menus/edit.tsx b/src_old/renderer/components/_molecules/menu-bar/menus/edit.tsx
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/menus/edit.tsx
rename to src_old/renderer/components/_molecules/menu-bar/menus/edit.tsx
diff --git a/src/renderer/components/_molecules/menu-bar/menus/file.tsx b/src_old/renderer/components/_molecules/menu-bar/menus/file.tsx
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/menus/file.tsx
rename to src_old/renderer/components/_molecules/menu-bar/menus/file.tsx
diff --git a/src/renderer/components/_molecules/menu-bar/menus/help.tsx b/src_old/renderer/components/_molecules/menu-bar/menus/help.tsx
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/menus/help.tsx
rename to src_old/renderer/components/_molecules/menu-bar/menus/help.tsx
diff --git a/src/renderer/components/_molecules/menu-bar/menus/index.ts b/src_old/renderer/components/_molecules/menu-bar/menus/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/menus/index.ts
rename to src_old/renderer/components/_molecules/menu-bar/menus/index.ts
diff --git a/src/renderer/components/_molecules/menu-bar/menus/recent.tsx b/src_old/renderer/components/_molecules/menu-bar/menus/recent.tsx
similarity index 100%
rename from src/renderer/components/_molecules/menu-bar/menus/recent.tsx
rename to src_old/renderer/components/_molecules/menu-bar/menus/recent.tsx
diff --git a/src/renderer/components/_molecules/modal/index.tsx b/src_old/renderer/components/_molecules/modal/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/modal/index.tsx
rename to src_old/renderer/components/_molecules/modal/index.tsx
diff --git a/src/renderer/components/_molecules/pin-mapping-table/combobox-input.tsx b/src_old/renderer/components/_molecules/pin-mapping-table/combobox-input.tsx
similarity index 100%
rename from src/renderer/components/_molecules/pin-mapping-table/combobox-input.tsx
rename to src_old/renderer/components/_molecules/pin-mapping-table/combobox-input.tsx
diff --git a/src/renderer/components/_molecules/pin-mapping-table/index.ts b/src_old/renderer/components/_molecules/pin-mapping-table/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/pin-mapping-table/index.ts
rename to src_old/renderer/components/_molecules/pin-mapping-table/index.ts
diff --git a/src/renderer/components/_molecules/pin-mapping-table/select-input.tsx b/src_old/renderer/components/_molecules/pin-mapping-table/select-input.tsx
similarity index 100%
rename from src/renderer/components/_molecules/pin-mapping-table/select-input.tsx
rename to src_old/renderer/components/_molecules/pin-mapping-table/select-input.tsx
diff --git a/src/renderer/components/_molecules/pin-mapping-table/text-input.tsx b/src_old/renderer/components/_molecules/pin-mapping-table/text-input.tsx
similarity index 100%
rename from src/renderer/components/_molecules/pin-mapping-table/text-input.tsx
rename to src_old/renderer/components/_molecules/pin-mapping-table/text-input.tsx
diff --git a/src/renderer/components/_molecules/project-tree/index.tsx b/src_old/renderer/components/_molecules/project-tree/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/project-tree/index.tsx
rename to src_old/renderer/components/_molecules/project-tree/index.tsx
diff --git a/src/renderer/components/_molecules/rename-impact-modal/index.tsx b/src_old/renderer/components/_molecules/rename-impact-modal/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/rename-impact-modal/index.tsx
rename to src_old/renderer/components/_molecules/rename-impact-modal/index.tsx
diff --git a/src/renderer/components/_molecules/search/index.tsx b/src_old/renderer/components/_molecules/search/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/search/index.tsx
rename to src_old/renderer/components/_molecules/search/index.tsx
diff --git a/src/renderer/components/_molecules/select-field/index.tsx b/src_old/renderer/components/_molecules/select-field/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/select-field/index.tsx
rename to src_old/renderer/components/_molecules/select-field/index.tsx
diff --git a/src/renderer/components/_molecules/tabs/index.tsx b/src_old/renderer/components/_molecules/tabs/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/tabs/index.tsx
rename to src_old/renderer/components/_molecules/tabs/index.tsx
diff --git a/src/renderer/components/_molecules/task-table/editable-cell.tsx b/src_old/renderer/components/_molecules/task-table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/task-table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/task-table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/task-table/index.tsx b/src_old/renderer/components/_molecules/task-table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/task-table/index.tsx
rename to src_old/renderer/components/_molecules/task-table/index.tsx
diff --git a/src/renderer/components/_molecules/task-table/selectable-cell.tsx b/src_old/renderer/components/_molecules/task-table/selectable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/task-table/selectable-cell.tsx
rename to src_old/renderer/components/_molecules/task-table/selectable-cell.tsx
diff --git a/src2/frontend/components/_molecules/toast/index.tsx b/src_old/renderer/components/_molecules/toast/index.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/toast/index.tsx
rename to src_old/renderer/components/_molecules/toast/index.tsx
diff --git a/src/renderer/components/_molecules/type-change-modal/index.tsx b/src_old/renderer/components/_molecules/type-change-modal/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/type-change-modal/index.tsx
rename to src_old/renderer/components/_molecules/type-change-modal/index.tsx
diff --git a/src/renderer/components/_molecules/variables-panel/index.tsx b/src_old/renderer/components/_molecules/variables-panel/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/variables-panel/index.tsx
rename to src_old/renderer/components/_molecules/variables-panel/index.tsx
diff --git a/src/renderer/components/_molecules/variables-table/editable-cell.tsx b/src_old/renderer/components/_molecules/variables-table/editable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/variables-table/editable-cell.tsx
rename to src_old/renderer/components/_molecules/variables-table/editable-cell.tsx
diff --git a/src/renderer/components/_molecules/variables-table/elements/array-modal.tsx b/src_old/renderer/components/_molecules/variables-table/elements/array-modal.tsx
similarity index 100%
rename from src/renderer/components/_molecules/variables-table/elements/array-modal.tsx
rename to src_old/renderer/components/_molecules/variables-table/elements/array-modal.tsx
diff --git a/src/renderer/components/_molecules/variables-table/index.tsx b/src_old/renderer/components/_molecules/variables-table/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/variables-table/index.tsx
rename to src_old/renderer/components/_molecules/variables-table/index.tsx
diff --git a/src/renderer/components/_molecules/variables-table/selectable-cell.tsx b/src_old/renderer/components/_molecules/variables-table/selectable-cell.tsx
similarity index 100%
rename from src/renderer/components/_molecules/variables-table/selectable-cell.tsx
rename to src_old/renderer/components/_molecules/variables-table/selectable-cell.tsx
diff --git a/src/renderer/components/_molecules/window-controls/index.tsx b/src_old/renderer/components/_molecules/window-controls/index.tsx
similarity index 100%
rename from src/renderer/components/_molecules/window-controls/index.tsx
rename to src_old/renderer/components/_molecules/window-controls/index.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/debugger.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/debugger.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/debugger.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/debugger.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/delete-element.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/delete-element.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/delete-element.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/delete-element.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/download.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/download.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/download.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/download.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/exit.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/exit.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/exit.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/exit.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/index.ts b/src_old/renderer/components/_molecules/workspace-activity-bar/default/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/index.ts
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/index.ts
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/play.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/play.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/play.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/play.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/search.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/search.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/search.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/search.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/transfer.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/transfer.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/transfer.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/transfer.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/default/zoom.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/default/zoom.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/default/zoom.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/default/zoom.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/block.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/block.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/block.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/block.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/comment.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/comment.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/comment.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/comment.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/connector.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/connector.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/connector.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/connector.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/continuation.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/continuation.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/index.ts b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/index.ts
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/index.ts
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/inout-variable.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/input-variable.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/fbd/out-variable.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/ladder/block.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/ladder/block.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/ladder/block.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/ladder/block.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/ladder/coil.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/ladder/coil.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/ladder/coil.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/ladder/coil.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/ladder/contact.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/ladder/contact.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/ladder/contact.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/ladder/contact.tsx
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/ladder/index.ts b/src_old/renderer/components/_molecules/workspace-activity-bar/ladder/index.ts
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/ladder/index.ts
rename to src_old/renderer/components/_molecules/workspace-activity-bar/ladder/index.ts
diff --git a/src/renderer/components/_molecules/workspace-activity-bar/ladder/parallel.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
similarity index 100%
rename from src/renderer/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/ladder/parallel.tsx
diff --git a/src2/frontend/components/_molecules/workspace-activity-bar/tooltip-button.tsx b/src_old/renderer/components/_molecules/workspace-activity-bar/tooltip-button.tsx
similarity index 100%
rename from src2/frontend/components/_molecules/workspace-activity-bar/tooltip-button.tsx
rename to src_old/renderer/components/_molecules/workspace-activity-bar/tooltip-button.tsx
diff --git a/src/renderer/components/_organisms/about-modal/index.tsx b/src_old/renderer/components/_organisms/about-modal/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/about-modal/index.tsx
rename to src_old/renderer/components/_organisms/about-modal/index.tsx
diff --git a/src/renderer/components/_organisms/console/filters.tsx b/src_old/renderer/components/_organisms/console/filters.tsx
similarity index 100%
rename from src/renderer/components/_organisms/console/filters.tsx
rename to src_old/renderer/components/_organisms/console/filters.tsx
diff --git a/src/renderer/components/_organisms/console/index.tsx b/src_old/renderer/components/_organisms/console/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/console/index.tsx
rename to src_old/renderer/components/_organisms/console/index.tsx
diff --git a/src/renderer/components/_organisms/console/log.tsx b/src_old/renderer/components/_organisms/console/log.tsx
similarity index 100%
rename from src/renderer/components/_organisms/console/log.tsx
rename to src_old/renderer/components/_organisms/console/log.tsx
diff --git a/src/renderer/components/_organisms/debugger/index.tsx b/src_old/renderer/components/_organisms/debugger/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/debugger/index.tsx
rename to src_old/renderer/components/_organisms/debugger/index.tsx
diff --git a/src/renderer/components/_organisms/display-recent-projects/index.tsx b/src_old/renderer/components/_organisms/display-recent-projects/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/display-recent-projects/index.tsx
rename to src_old/renderer/components/_organisms/display-recent-projects/index.tsx
diff --git a/src/renderer/components/_organisms/explorer/index.tsx b/src_old/renderer/components/_organisms/explorer/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/explorer/index.tsx
rename to src_old/renderer/components/_organisms/explorer/index.tsx
diff --git a/src2/frontend/components/_organisms/explorer/info.tsx b/src_old/renderer/components/_organisms/explorer/info.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/explorer/info.tsx
rename to src_old/renderer/components/_organisms/explorer/info.tsx
diff --git a/src/renderer/components/_organisms/explorer/library.tsx b/src_old/renderer/components/_organisms/explorer/library.tsx
similarity index 100%
rename from src/renderer/components/_organisms/explorer/library.tsx
rename to src_old/renderer/components/_organisms/explorer/library.tsx
diff --git a/src/renderer/components/_organisms/explorer/project.tsx b/src_old/renderer/components/_organisms/explorer/project.tsx
similarity index 100%
rename from src/renderer/components/_organisms/explorer/project.tsx
rename to src_old/renderer/components/_organisms/explorer/project.tsx
diff --git a/src/renderer/components/_organisms/global-variables-editor/index.tsx b/src_old/renderer/components/_organisms/global-variables-editor/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/global-variables-editor/index.tsx
rename to src_old/renderer/components/_organisms/global-variables-editor/index.tsx
diff --git a/src/renderer/components/_organisms/graphical-editor/ladder/index.ts b/src_old/renderer/components/_organisms/graphical-editor/ladder/index.ts
similarity index 100%
rename from src/renderer/components/_organisms/graphical-editor/ladder/index.ts
rename to src_old/renderer/components/_organisms/graphical-editor/ladder/index.ts
diff --git a/src/renderer/components/_organisms/graphical-editor/ladder/rung/index.tsx b/src_old/renderer/components/_organisms/graphical-editor/ladder/rung/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/graphical-editor/ladder/rung/index.tsx
rename to src_old/renderer/components/_organisms/graphical-editor/ladder/rung/index.tsx
diff --git a/src/renderer/components/_organisms/instances-editor/index.tsx b/src_old/renderer/components/_organisms/instances-editor/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/instances-editor/index.tsx
rename to src_old/renderer/components/_organisms/instances-editor/index.tsx
diff --git a/src/renderer/components/_organisms/modals/confirm-device-switch-modal.tsx b/src_old/renderer/components/_organisms/modals/confirm-device-switch-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/confirm-device-switch-modal.tsx
rename to src_old/renderer/components/_organisms/modals/confirm-device-switch-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/debugger-ip-input-modal.tsx b/src_old/renderer/components/_organisms/modals/debugger-ip-input-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/debugger-ip-input-modal.tsx
rename to src_old/renderer/components/_organisms/modals/debugger-ip-input-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/debugger-message-modal.tsx b/src_old/renderer/components/_organisms/modals/debugger-message-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/debugger-message-modal.tsx
rename to src_old/renderer/components/_organisms/modals/debugger-message-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/delete-confirmation-modal.tsx b/src_old/renderer/components/_organisms/modals/delete-confirmation-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/delete-confirmation-modal.tsx
rename to src_old/renderer/components/_organisms/modals/delete-confirmation-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/index.ts b/src_old/renderer/components/_organisms/modals/index.ts
similarity index 100%
rename from src/renderer/components/_organisms/modals/index.ts
rename to src_old/renderer/components/_organisms/modals/index.ts
diff --git a/src/renderer/components/_organisms/modals/quit-application-modal.tsx b/src_old/renderer/components/_organisms/modals/quit-application-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/quit-application-modal.tsx
rename to src_old/renderer/components/_organisms/modals/quit-application-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/runtime-connection-lost-modal.tsx b/src_old/renderer/components/_organisms/modals/runtime-connection-lost-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/runtime-connection-lost-modal.tsx
rename to src_old/renderer/components/_organisms/modals/runtime-connection-lost-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/runtime-create-user-modal.tsx b/src_old/renderer/components/_organisms/modals/runtime-create-user-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/runtime-create-user-modal.tsx
rename to src_old/renderer/components/_organisms/modals/runtime-create-user-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/runtime-login-modal.tsx b/src_old/renderer/components/_organisms/modals/runtime-login-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/runtime-login-modal.tsx
rename to src_old/renderer/components/_organisms/modals/runtime-login-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/save-changes-file-modal.tsx b/src_old/renderer/components/_organisms/modals/save-changes-file-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/save-changes-file-modal.tsx
rename to src_old/renderer/components/_organisms/modals/save-changes-file-modal.tsx
diff --git a/src/renderer/components/_organisms/modals/save-changes-modal.tsx b/src_old/renderer/components/_organisms/modals/save-changes-modal.tsx
similarity index 100%
rename from src/renderer/components/_organisms/modals/save-changes-modal.tsx
rename to src_old/renderer/components/_organisms/modals/save-changes-modal.tsx
diff --git a/src2/frontend/components/_organisms/navigation/index.tsx b/src_old/renderer/components/_organisms/navigation/index.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/navigation/index.tsx
rename to src_old/renderer/components/_organisms/navigation/index.tsx
diff --git a/src/renderer/components/_organisms/panel/index.tsx b/src_old/renderer/components/_organisms/panel/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/panel/index.tsx
rename to src_old/renderer/components/_organisms/panel/index.tsx
diff --git a/src/renderer/components/_organisms/plc-logs/filters.tsx b/src_old/renderer/components/_organisms/plc-logs/filters.tsx
similarity index 100%
rename from src/renderer/components/_organisms/plc-logs/filters.tsx
rename to src_old/renderer/components/_organisms/plc-logs/filters.tsx
diff --git a/src/renderer/components/_organisms/plc-logs/index.tsx b/src_old/renderer/components/_organisms/plc-logs/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/plc-logs/index.tsx
rename to src_old/renderer/components/_organisms/plc-logs/index.tsx
diff --git a/src/renderer/components/_organisms/project-filter-bar/index.tsx b/src_old/renderer/components/_organisms/project-filter-bar/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/project-filter-bar/index.tsx
rename to src_old/renderer/components/_organisms/project-filter-bar/index.tsx
diff --git a/src/renderer/components/_organisms/task-editor/index.tsx b/src_old/renderer/components/_organisms/task-editor/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/task-editor/index.tsx
rename to src_old/renderer/components/_organisms/task-editor/index.tsx
diff --git a/src2/frontend/components/_organisms/title-bar/index.tsx b/src_old/renderer/components/_organisms/title-bar/index.tsx
similarity index 100%
rename from src2/frontend/components/_organisms/title-bar/index.tsx
rename to src_old/renderer/components/_organisms/title-bar/index.tsx
diff --git a/src/renderer/components/_organisms/title-bar/slots/center-slot.tsx b/src_old/renderer/components/_organisms/title-bar/slots/center-slot.tsx
similarity index 100%
rename from src/renderer/components/_organisms/title-bar/slots/center-slot.tsx
rename to src_old/renderer/components/_organisms/title-bar/slots/center-slot.tsx
diff --git a/src2/frontend/components/_organisms/title-bar/slots/index.ts b/src_old/renderer/components/_organisms/title-bar/slots/index.ts
similarity index 100%
rename from src2/frontend/components/_organisms/title-bar/slots/index.ts
rename to src_old/renderer/components/_organisms/title-bar/slots/index.ts
diff --git a/src/renderer/components/_organisms/title-bar/slots/left-slot.tsx b/src_old/renderer/components/_organisms/title-bar/slots/left-slot.tsx
similarity index 100%
rename from src/renderer/components/_organisms/title-bar/slots/left-slot.tsx
rename to src_old/renderer/components/_organisms/title-bar/slots/left-slot.tsx
diff --git a/src/renderer/components/_organisms/title-bar/slots/right-slot.tsx b/src_old/renderer/components/_organisms/title-bar/slots/right-slot.tsx
similarity index 100%
rename from src/renderer/components/_organisms/title-bar/slots/right-slot.tsx
rename to src_old/renderer/components/_organisms/title-bar/slots/right-slot.tsx
diff --git a/src/renderer/components/_organisms/variables-code-editor/index.tsx b/src_old/renderer/components/_organisms/variables-code-editor/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/variables-code-editor/index.tsx
rename to src_old/renderer/components/_organisms/variables-code-editor/index.tsx
diff --git a/src/renderer/components/_organisms/variables-editor/index.tsx b/src_old/renderer/components/_organisms/variables-editor/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/variables-editor/index.tsx
rename to src_old/renderer/components/_organisms/variables-editor/index.tsx
diff --git a/src/renderer/components/_organisms/workspace-activity-bar/default.tsx b/src_old/renderer/components/_organisms/workspace-activity-bar/default.tsx
similarity index 100%
rename from src/renderer/components/_organisms/workspace-activity-bar/default.tsx
rename to src_old/renderer/components/_organisms/workspace-activity-bar/default.tsx
diff --git a/src/renderer/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx b/src_old/renderer/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
similarity index 100%
rename from src/renderer/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
rename to src_old/renderer/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
diff --git a/src/renderer/components/_organisms/workspace-activity-bar/index.tsx b/src_old/renderer/components/_organisms/workspace-activity-bar/index.tsx
similarity index 100%
rename from src/renderer/components/_organisms/workspace-activity-bar/index.tsx
rename to src_old/renderer/components/_organisms/workspace-activity-bar/index.tsx
diff --git a/src/renderer/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx b/src_old/renderer/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
similarity index 100%
rename from src/renderer/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
rename to src_old/renderer/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
diff --git a/src2/frontend/components/_templates/[editors]/device-editor-slot.tsx b/src_old/renderer/components/_templates/[editors]/device-editor-slot.tsx
similarity index 100%
rename from src2/frontend/components/_templates/[editors]/device-editor-slot.tsx
rename to src_old/renderer/components/_templates/[editors]/device-editor-slot.tsx
diff --git a/src2/frontend/components/_templates/[editors]/device-editor-template.tsx b/src_old/renderer/components/_templates/[editors]/device-editor-template.tsx
similarity index 100%
rename from src2/frontend/components/_templates/[editors]/device-editor-template.tsx
rename to src_old/renderer/components/_templates/[editors]/device-editor-template.tsx
diff --git a/src/renderer/components/_templates/[editors]/index.ts b/src_old/renderer/components/_templates/[editors]/index.ts
similarity index 100%
rename from src/renderer/components/_templates/[editors]/index.ts
rename to src_old/renderer/components/_templates/[editors]/index.ts
diff --git a/src/renderer/components/_templates/[start]/index.ts b/src_old/renderer/components/_templates/[start]/index.ts
similarity index 100%
rename from src/renderer/components/_templates/[start]/index.ts
rename to src_old/renderer/components/_templates/[start]/index.ts
diff --git a/src2/frontend/components/_templates/[start]/main-content.tsx b/src_old/renderer/components/_templates/[start]/main-content.tsx
similarity index 100%
rename from src2/frontend/components/_templates/[start]/main-content.tsx
rename to src_old/renderer/components/_templates/[start]/main-content.tsx
diff --git a/src2/frontend/components/_templates/[start]/side-content.tsx b/src_old/renderer/components/_templates/[start]/side-content.tsx
similarity index 100%
rename from src2/frontend/components/_templates/[start]/side-content.tsx
rename to src_old/renderer/components/_templates/[start]/side-content.tsx
diff --git a/src/renderer/components/_templates/[workspace]/index.ts b/src_old/renderer/components/_templates/[workspace]/index.ts
similarity index 100%
rename from src/renderer/components/_templates/[workspace]/index.ts
rename to src_old/renderer/components/_templates/[workspace]/index.ts
diff --git a/src/renderer/components/_templates/[workspace]/main-content.tsx b/src_old/renderer/components/_templates/[workspace]/main-content.tsx
similarity index 100%
rename from src/renderer/components/_templates/[workspace]/main-content.tsx
rename to src_old/renderer/components/_templates/[workspace]/main-content.tsx
diff --git a/src2/frontend/components/_templates/[workspace]/side-content.tsx b/src_old/renderer/components/_templates/[workspace]/side-content.tsx
similarity index 100%
rename from src2/frontend/components/_templates/[workspace]/side-content.tsx
rename to src_old/renderer/components/_templates/[workspace]/side-content.tsx
diff --git a/src/renderer/components/_templates/accelerator-handler.tsx b/src_old/renderer/components/_templates/accelerator-handler.tsx
similarity index 100%
rename from src/renderer/components/_templates/accelerator-handler.tsx
rename to src_old/renderer/components/_templates/accelerator-handler.tsx
diff --git a/src/renderer/components/_templates/app-layout.tsx b/src_old/renderer/components/_templates/app-layout.tsx
similarity index 100%
rename from src/renderer/components/_templates/app-layout.tsx
rename to src_old/renderer/components/_templates/app-layout.tsx
diff --git a/src/renderer/components/_templates/index.ts b/src_old/renderer/components/_templates/index.ts
similarity index 100%
rename from src/renderer/components/_templates/index.ts
rename to src_old/renderer/components/_templates/index.ts
diff --git a/src/renderer/components/elements/card/card-label.tsx b/src_old/renderer/components/elements/card/card-label.tsx
similarity index 100%
rename from src/renderer/components/elements/card/card-label.tsx
rename to src_old/renderer/components/elements/card/card-label.tsx
diff --git a/src/renderer/components/elements/card/card-preview.tsx b/src_old/renderer/components/elements/card/card-preview.tsx
similarity index 100%
rename from src/renderer/components/elements/card/card-preview.tsx
rename to src_old/renderer/components/elements/card/card-preview.tsx
diff --git a/src/renderer/components/elements/card/card-root.tsx b/src_old/renderer/components/elements/card/card-root.tsx
similarity index 100%
rename from src/renderer/components/elements/card/card-root.tsx
rename to src_old/renderer/components/elements/card/card-root.tsx
diff --git a/src/renderer/components/elements/card/index.ts b/src_old/renderer/components/elements/card/index.ts
similarity index 100%
rename from src/renderer/components/elements/card/index.ts
rename to src_old/renderer/components/elements/card/index.ts
diff --git a/src/renderer/components/elements/dropdown/index.ts b/src_old/renderer/components/elements/dropdown/index.ts
similarity index 100%
rename from src/renderer/components/elements/dropdown/index.ts
rename to src_old/renderer/components/elements/dropdown/index.ts
diff --git a/src/renderer/components/elements/dropdown/options.tsx b/src_old/renderer/components/elements/dropdown/options.tsx
similarity index 100%
rename from src/renderer/components/elements/dropdown/options.tsx
rename to src_old/renderer/components/elements/dropdown/options.tsx
diff --git a/src/renderer/components/elements/dropdown/root.tsx b/src_old/renderer/components/elements/dropdown/root.tsx
similarity index 100%
rename from src/renderer/components/elements/dropdown/root.tsx
rename to src_old/renderer/components/elements/dropdown/root.tsx
diff --git a/src/renderer/components/elements/dropdown/select.tsx b/src_old/renderer/components/elements/dropdown/select.tsx
similarity index 100%
rename from src/renderer/components/elements/dropdown/select.tsx
rename to src_old/renderer/components/elements/dropdown/select.tsx
diff --git a/src/renderer/components/elements/index.ts b/src_old/renderer/components/elements/index.ts
similarity index 100%
rename from src/renderer/components/elements/index.ts
rename to src_old/renderer/components/elements/index.ts
diff --git a/src/renderer/components/refactor/display-example-projects/index.tsx b/src_old/renderer/components/refactor/display-example-projects/index.tsx
similarity index 100%
rename from src/renderer/components/refactor/display-example-projects/index.tsx
rename to src_old/renderer/components/refactor/display-example-projects/index.tsx
diff --git a/src/renderer/components/ui/index.ts b/src_old/renderer/components/ui/index.ts
similarity index 100%
rename from src/renderer/components/ui/index.ts
rename to src_old/renderer/components/ui/index.ts
diff --git a/src/renderer/components/ui/menu/index.ts b/src_old/renderer/components/ui/menu/index.ts
similarity index 100%
rename from src/renderer/components/ui/menu/index.ts
rename to src_old/renderer/components/ui/menu/index.ts
diff --git a/src/renderer/components/ui/menu/menu-button.tsx b/src_old/renderer/components/ui/menu/menu-button.tsx
similarity index 100%
rename from src/renderer/components/ui/menu/menu-button.tsx
rename to src_old/renderer/components/ui/menu/menu-button.tsx
diff --git a/src/renderer/components/ui/menu/menu-divider.tsx b/src_old/renderer/components/ui/menu/menu-divider.tsx
similarity index 100%
rename from src/renderer/components/ui/menu/menu-divider.tsx
rename to src_old/renderer/components/ui/menu/menu-divider.tsx
diff --git a/src/renderer/components/ui/menu/menu-root.tsx b/src_old/renderer/components/ui/menu/menu-root.tsx
similarity index 100%
rename from src/renderer/components/ui/menu/menu-root.tsx
rename to src_old/renderer/components/ui/menu/menu-root.tsx
diff --git a/src/renderer/components/ui/menu/menu-section.tsx b/src_old/renderer/components/ui/menu/menu-section.tsx
similarity index 100%
rename from src/renderer/components/ui/menu/menu-section.tsx
rename to src_old/renderer/components/ui/menu/menu-section.tsx
diff --git a/src/renderer/components/ui/scroll-area/display.tsx b/src_old/renderer/components/ui/scroll-area/display.tsx
similarity index 100%
rename from src/renderer/components/ui/scroll-area/display.tsx
rename to src_old/renderer/components/ui/scroll-area/display.tsx
diff --git a/src2/frontend/components/ui/scroll-area/index.ts b/src_old/renderer/components/ui/scroll-area/index.ts
similarity index 100%
rename from src2/frontend/components/ui/scroll-area/index.ts
rename to src_old/renderer/components/ui/scroll-area/index.ts
diff --git a/src/renderer/components/ui/scroll-area/root.tsx b/src_old/renderer/components/ui/scroll-area/root.tsx
similarity index 100%
rename from src/renderer/components/ui/scroll-area/root.tsx
rename to src_old/renderer/components/ui/scroll-area/root.tsx
diff --git a/src/renderer/components/ui/scroll-area/scrollbar.tsx b/src_old/renderer/components/ui/scroll-area/scrollbar.tsx
similarity index 100%
rename from src/renderer/components/ui/scroll-area/scrollbar.tsx
rename to src_old/renderer/components/ui/scroll-area/scrollbar.tsx
diff --git a/src/renderer/components/ui/scroll-area/viewport.tsx b/src_old/renderer/components/ui/scroll-area/viewport.tsx
similarity index 100%
rename from src/renderer/components/ui/scroll-area/viewport.tsx
rename to src_old/renderer/components/ui/scroll-area/viewport.tsx
diff --git a/src/renderer/contracts/types/index.ts b/src_old/renderer/contracts/types/index.ts
similarity index 100%
rename from src/renderer/contracts/types/index.ts
rename to src_old/renderer/contracts/types/index.ts
diff --git a/src/renderer/contracts/types/store/workspace.ts b/src_old/renderer/contracts/types/store/workspace.ts
similarity index 100%
rename from src/renderer/contracts/types/store/workspace.ts
rename to src_old/renderer/contracts/types/store/workspace.ts
diff --git a/src/renderer/contracts/types/templates/layout.ts b/src_old/renderer/contracts/types/templates/layout.ts
similarity index 100%
rename from src/renderer/contracts/types/templates/layout.ts
rename to src_old/renderer/contracts/types/templates/layout.ts
diff --git a/src/renderer/data/constants/device-styles.ts b/src_old/renderer/data/constants/device-styles.ts
similarity index 100%
rename from src/renderer/data/constants/device-styles.ts
rename to src_old/renderer/data/constants/device-styles.ts
diff --git a/src2/frontend/data/constants/icon-styles.ts b/src_old/renderer/data/constants/icon-styles.ts
similarity index 100%
rename from src2/frontend/data/constants/icon-styles.ts
rename to src_old/renderer/data/constants/icon-styles.ts
diff --git a/src/renderer/data/constants/language-icons.ts b/src_old/renderer/data/constants/language-icons.ts
similarity index 100%
rename from src/renderer/data/constants/language-icons.ts
rename to src_old/renderer/data/constants/language-icons.ts
diff --git a/src/renderer/data/constants/pou-icons.ts b/src_old/renderer/data/constants/pou-icons.ts
similarity index 100%
rename from src/renderer/data/constants/pou-icons.ts
rename to src_old/renderer/data/constants/pou-icons.ts
diff --git a/src/renderer/data/index.ts b/src_old/renderer/data/index.ts
similarity index 100%
rename from src/renderer/data/index.ts
rename to src_old/renderer/data/index.ts
diff --git a/src/renderer/data/library/MQTT.ts b/src_old/renderer/data/library/MQTT.ts
similarity index 100%
rename from src/renderer/data/library/MQTT.ts
rename to src_old/renderer/data/library/MQTT.ts
diff --git a/src/renderer/data/library/P1AM.ts b/src_old/renderer/data/library/P1AM.ts
similarity index 100%
rename from src/renderer/data/library/P1AM.ts
rename to src_old/renderer/data/library/P1AM.ts
diff --git a/src/renderer/data/library/additional-function-blocks.ts b/src_old/renderer/data/library/additional-function-blocks.ts
similarity index 100%
rename from src/renderer/data/library/additional-function-blocks.ts
rename to src_old/renderer/data/library/additional-function-blocks.ts
diff --git a/src/renderer/data/library/arduino-function-blocks.ts b/src_old/renderer/data/library/arduino-function-blocks.ts
similarity index 100%
rename from src/renderer/data/library/arduino-function-blocks.ts
rename to src_old/renderer/data/library/arduino-function-blocks.ts
diff --git a/src/renderer/data/library/communication-blocks.ts b/src_old/renderer/data/library/communication-blocks.ts
similarity index 100%
rename from src/renderer/data/library/communication-blocks.ts
rename to src_old/renderer/data/library/communication-blocks.ts
diff --git a/src/renderer/data/library/function/arithmetic.ts b/src_old/renderer/data/library/function/arithmetic.ts
similarity index 100%
rename from src/renderer/data/library/function/arithmetic.ts
rename to src_old/renderer/data/library/function/arithmetic.ts
diff --git a/src/renderer/data/library/function/bit-shift.ts b/src_old/renderer/data/library/function/bit-shift.ts
similarity index 100%
rename from src/renderer/data/library/function/bit-shift.ts
rename to src_old/renderer/data/library/function/bit-shift.ts
diff --git a/src/renderer/data/library/function/bitwise.ts b/src_old/renderer/data/library/function/bitwise.ts
similarity index 100%
rename from src/renderer/data/library/function/bitwise.ts
rename to src_old/renderer/data/library/function/bitwise.ts
diff --git a/src/renderer/data/library/function/character-string.ts b/src_old/renderer/data/library/function/character-string.ts
similarity index 100%
rename from src/renderer/data/library/function/character-string.ts
rename to src_old/renderer/data/library/function/character-string.ts
diff --git a/src/renderer/data/library/function/comparison.ts b/src_old/renderer/data/library/function/comparison.ts
similarity index 100%
rename from src/renderer/data/library/function/comparison.ts
rename to src_old/renderer/data/library/function/comparison.ts
diff --git a/src_old/renderer/data/library/function/index.ts b/src_old/renderer/data/library/function/index.ts
new file mode 100644
index 000000000..2d586bbcc
--- /dev/null
+++ b/src_old/renderer/data/library/function/index.ts
@@ -0,0 +1,9 @@
+export * from './arithmetic'
+export * from './bit-shift'
+export * from './bitwise'
+export * from './character-string'
+export * from './comparison'
+export * from './numerical'
+export * from './selection'
+export * from './time'
+export * from './type-conversion'
diff --git a/src/renderer/data/library/function/numerical.ts b/src_old/renderer/data/library/function/numerical.ts
similarity index 100%
rename from src/renderer/data/library/function/numerical.ts
rename to src_old/renderer/data/library/function/numerical.ts
diff --git a/src/renderer/data/library/function/selection.ts b/src_old/renderer/data/library/function/selection.ts
similarity index 100%
rename from src/renderer/data/library/function/selection.ts
rename to src_old/renderer/data/library/function/selection.ts
diff --git a/src/renderer/data/library/function/time.ts b/src_old/renderer/data/library/function/time.ts
similarity index 100%
rename from src/renderer/data/library/function/time.ts
rename to src_old/renderer/data/library/function/time.ts
diff --git a/src/renderer/data/library/function/type-conversion.ts b/src_old/renderer/data/library/function/type-conversion.ts
similarity index 100%
rename from src/renderer/data/library/function/type-conversion.ts
rename to src_old/renderer/data/library/function/type-conversion.ts
diff --git a/src_old/renderer/data/library/index.ts b/src_old/renderer/data/library/index.ts
new file mode 100644
index 000000000..8646fbbc1
--- /dev/null
+++ b/src_old/renderer/data/library/index.ts
@@ -0,0 +1,9 @@
+export * from './additional-function-blocks'
+export * from './arduino-function-blocks'
+export * from './communication-blocks'
+export * from './function'
+export * from './jaguar'
+export * from './MQTT'
+export * from './P1AM'
+export * from './sequent-microsystems-modules'
+export * from './standard-function-blocks'
diff --git a/src/renderer/data/library/jaguar.ts b/src_old/renderer/data/library/jaguar.ts
similarity index 100%
rename from src/renderer/data/library/jaguar.ts
rename to src_old/renderer/data/library/jaguar.ts
diff --git a/src/renderer/data/library/sequent-microsystems-modules.ts b/src_old/renderer/data/library/sequent-microsystems-modules.ts
similarity index 100%
rename from src/renderer/data/library/sequent-microsystems-modules.ts
rename to src_old/renderer/data/library/sequent-microsystems-modules.ts
diff --git a/src/renderer/data/library/standard-function-blocks.ts b/src_old/renderer/data/library/standard-function-blocks.ts
similarity index 100%
rename from src/renderer/data/library/standard-function-blocks.ts
rename to src_old/renderer/data/library/standard-function-blocks.ts
diff --git a/src/renderer/data/sources/POU.tsx b/src_old/renderer/data/sources/POU.tsx
similarity index 100%
rename from src/renderer/data/sources/POU.tsx
rename to src_old/renderer/data/sources/POU.tsx
diff --git a/src/renderer/data/sources/data-type.tsx b/src_old/renderer/data/sources/data-type.tsx
similarity index 100%
rename from src/renderer/data/sources/data-type.tsx
rename to src_old/renderer/data/sources/data-type.tsx
diff --git a/src/renderer/hooks/index.ts b/src_old/renderer/hooks/index.ts
similarity index 100%
rename from src/renderer/hooks/index.ts
rename to src_old/renderer/hooks/index.ts
diff --git a/src/renderer/hooks/use-compiler.ts b/src_old/renderer/hooks/use-compiler.ts
similarity index 100%
rename from src/renderer/hooks/use-compiler.ts
rename to src_old/renderer/hooks/use-compiler.ts
diff --git a/src/renderer/hooks/use-debug-composite-key.ts b/src_old/renderer/hooks/use-debug-composite-key.ts
similarity index 100%
rename from src/renderer/hooks/use-debug-composite-key.ts
rename to src_old/renderer/hooks/use-debug-composite-key.ts
diff --git a/src/renderer/hooks/use-quit-app.tsx b/src_old/renderer/hooks/use-quit-app.tsx
similarity index 100%
rename from src/renderer/hooks/use-quit-app.tsx
rename to src_old/renderer/hooks/use-quit-app.tsx
diff --git a/src/renderer/hooks/use-remove-tab.tsx b/src_old/renderer/hooks/use-remove-tab.tsx
similarity index 100%
rename from src/renderer/hooks/use-remove-tab.tsx
rename to src_old/renderer/hooks/use-remove-tab.tsx
diff --git a/src/renderer/hooks/use-runtime-polling.ts b/src_old/renderer/hooks/use-runtime-polling.ts
similarity index 100%
rename from src/renderer/hooks/use-runtime-polling.ts
rename to src_old/renderer/hooks/use-runtime-polling.ts
diff --git a/src/renderer/hooks/use-store-selectors.ts b/src_old/renderer/hooks/use-store-selectors.ts
similarity index 100%
rename from src/renderer/hooks/use-store-selectors.ts
rename to src_old/renderer/hooks/use-store-selectors.ts
diff --git a/src/renderer/index.ejs b/src_old/renderer/index.ejs
similarity index 100%
rename from src/renderer/index.ejs
rename to src_old/renderer/index.ejs
diff --git a/src/renderer/index.tsx b/src_old/renderer/index.tsx
similarity index 100%
rename from src/renderer/index.tsx
rename to src_old/renderer/index.tsx
diff --git a/src/renderer/screens/index.ts b/src_old/renderer/screens/index.ts
similarity index 100%
rename from src/renderer/screens/index.ts
rename to src_old/renderer/screens/index.ts
diff --git a/src/renderer/screens/start-screen.tsx b/src_old/renderer/screens/start-screen.tsx
similarity index 100%
rename from src/renderer/screens/start-screen.tsx
rename to src_old/renderer/screens/start-screen.tsx
diff --git a/src/renderer/screens/workspace-screen.tsx b/src_old/renderer/screens/workspace-screen.tsx
similarity index 100%
rename from src/renderer/screens/workspace-screen.tsx
rename to src_old/renderer/screens/workspace-screen.tsx
diff --git a/src/renderer/store/index.ts b/src_old/renderer/store/index.ts
similarity index 100%
rename from src/renderer/store/index.ts
rename to src_old/renderer/store/index.ts
diff --git a/src/renderer/store/slices/editor/index.ts b/src_old/renderer/store/slices/console/index.ts
similarity index 100%
rename from src/renderer/store/slices/editor/index.ts
rename to src_old/renderer/store/slices/console/index.ts
diff --git a/src/renderer/store/slices/console/slice.ts b/src_old/renderer/store/slices/console/slice.ts
similarity index 100%
rename from src/renderer/store/slices/console/slice.ts
rename to src_old/renderer/store/slices/console/slice.ts
diff --git a/src/renderer/store/slices/console/types.ts b/src_old/renderer/store/slices/console/types.ts
similarity index 100%
rename from src/renderer/store/slices/console/types.ts
rename to src_old/renderer/store/slices/console/types.ts
diff --git a/src/renderer/store/slices/device/data/constants.ts b/src_old/renderer/store/slices/device/data/constants.ts
similarity index 100%
rename from src/renderer/store/slices/device/data/constants.ts
rename to src_old/renderer/store/slices/device/data/constants.ts
diff --git a/src/renderer/store/slices/device/data/index.ts b/src_old/renderer/store/slices/device/data/index.ts
similarity index 100%
rename from src/renderer/store/slices/device/data/index.ts
rename to src_old/renderer/store/slices/device/data/index.ts
diff --git a/src/renderer/store/slices/fbd/index.ts b/src_old/renderer/store/slices/device/index.ts
similarity index 100%
rename from src/renderer/store/slices/fbd/index.ts
rename to src_old/renderer/store/slices/device/index.ts
diff --git a/src/renderer/store/slices/device/slice.ts b/src_old/renderer/store/slices/device/slice.ts
similarity index 100%
rename from src/renderer/store/slices/device/slice.ts
rename to src_old/renderer/store/slices/device/slice.ts
diff --git a/src/renderer/store/slices/device/types.ts b/src_old/renderer/store/slices/device/types.ts
similarity index 100%
rename from src/renderer/store/slices/device/types.ts
rename to src_old/renderer/store/slices/device/types.ts
diff --git a/src/renderer/store/slices/device/validation/__tests__/pins.spec.ts b/src_old/renderer/store/slices/device/validation/__tests__/pins.spec.ts
similarity index 100%
rename from src/renderer/store/slices/device/validation/__tests__/pins.spec.ts
rename to src_old/renderer/store/slices/device/validation/__tests__/pins.spec.ts
diff --git a/src/renderer/store/slices/device/validation/pins.ts b/src_old/renderer/store/slices/device/validation/pins.ts
similarity index 100%
rename from src/renderer/store/slices/device/validation/pins.ts
rename to src_old/renderer/store/slices/device/validation/pins.ts
diff --git a/src/renderer/store/slices/files/index.ts b/src_old/renderer/store/slices/editor/index.ts
similarity index 100%
rename from src/renderer/store/slices/files/index.ts
rename to src_old/renderer/store/slices/editor/index.ts
diff --git a/src/renderer/store/slices/editor/slice.ts b/src_old/renderer/store/slices/editor/slice.ts
similarity index 100%
rename from src/renderer/store/slices/editor/slice.ts
rename to src_old/renderer/store/slices/editor/slice.ts
diff --git a/src/renderer/store/slices/editor/types.ts b/src_old/renderer/store/slices/editor/types.ts
similarity index 100%
rename from src/renderer/store/slices/editor/types.ts
rename to src_old/renderer/store/slices/editor/types.ts
diff --git a/src/renderer/store/slices/history/index.ts b/src_old/renderer/store/slices/fbd/index.ts
similarity index 100%
rename from src/renderer/store/slices/history/index.ts
rename to src_old/renderer/store/slices/fbd/index.ts
diff --git a/src/renderer/store/slices/fbd/slice.ts b/src_old/renderer/store/slices/fbd/slice.ts
similarity index 100%
rename from src/renderer/store/slices/fbd/slice.ts
rename to src_old/renderer/store/slices/fbd/slice.ts
diff --git a/src/renderer/store/slices/fbd/types.ts b/src_old/renderer/store/slices/fbd/types.ts
similarity index 100%
rename from src/renderer/store/slices/fbd/types.ts
rename to src_old/renderer/store/slices/fbd/types.ts
diff --git a/src/renderer/store/slices/fbd/utils/index.ts b/src_old/renderer/store/slices/fbd/utils/index.ts
similarity index 100%
rename from src/renderer/store/slices/fbd/utils/index.ts
rename to src_old/renderer/store/slices/fbd/utils/index.ts
diff --git a/src/renderer/store/slices/ladder/index.ts b/src_old/renderer/store/slices/files/index.ts
similarity index 100%
rename from src/renderer/store/slices/ladder/index.ts
rename to src_old/renderer/store/slices/files/index.ts
diff --git a/src/renderer/store/slices/files/slice.ts b/src_old/renderer/store/slices/files/slice.ts
similarity index 100%
rename from src/renderer/store/slices/files/slice.ts
rename to src_old/renderer/store/slices/files/slice.ts
diff --git a/src/renderer/store/slices/files/types.ts b/src_old/renderer/store/slices/files/types.ts
similarity index 100%
rename from src/renderer/store/slices/files/types.ts
rename to src_old/renderer/store/slices/files/types.ts
diff --git a/src/renderer/store/slices/modal/index.ts b/src_old/renderer/store/slices/history/index.ts
similarity index 100%
rename from src/renderer/store/slices/modal/index.ts
rename to src_old/renderer/store/slices/history/index.ts
diff --git a/src/renderer/store/slices/history/slice.ts b/src_old/renderer/store/slices/history/slice.ts
similarity index 100%
rename from src/renderer/store/slices/history/slice.ts
rename to src_old/renderer/store/slices/history/slice.ts
diff --git a/src/renderer/store/slices/history/types.ts b/src_old/renderer/store/slices/history/types.ts
similarity index 100%
rename from src/renderer/store/slices/history/types.ts
rename to src_old/renderer/store/slices/history/types.ts
diff --git a/src/renderer/store/slices/index.ts b/src_old/renderer/store/slices/index.ts
similarity index 100%
rename from src/renderer/store/slices/index.ts
rename to src_old/renderer/store/slices/index.ts
diff --git a/src/renderer/store/slices/project/index.ts b/src_old/renderer/store/slices/ladder/index.ts
similarity index 100%
rename from src/renderer/store/slices/project/index.ts
rename to src_old/renderer/store/slices/ladder/index.ts
diff --git a/src/renderer/store/slices/ladder/slice.ts b/src_old/renderer/store/slices/ladder/slice.ts
similarity index 100%
rename from src/renderer/store/slices/ladder/slice.ts
rename to src_old/renderer/store/slices/ladder/slice.ts
diff --git a/src/renderer/store/slices/ladder/types.ts b/src_old/renderer/store/slices/ladder/types.ts
similarity index 100%
rename from src/renderer/store/slices/ladder/types.ts
rename to src_old/renderer/store/slices/ladder/types.ts
diff --git a/src/renderer/store/slices/ladder/utils/index.ts b/src_old/renderer/store/slices/ladder/utils/index.ts
similarity index 100%
rename from src/renderer/store/slices/ladder/utils/index.ts
rename to src_old/renderer/store/slices/ladder/utils/index.ts
diff --git a/src/renderer/store/slices/library/index.ts b/src_old/renderer/store/slices/library/index.ts
similarity index 100%
rename from src/renderer/store/slices/library/index.ts
rename to src_old/renderer/store/slices/library/index.ts
diff --git a/src/renderer/store/slices/library/slice.ts b/src_old/renderer/store/slices/library/slice.ts
similarity index 100%
rename from src/renderer/store/slices/library/slice.ts
rename to src_old/renderer/store/slices/library/slice.ts
diff --git a/src/renderer/store/slices/library/type.ts b/src_old/renderer/store/slices/library/type.ts
similarity index 100%
rename from src/renderer/store/slices/library/type.ts
rename to src_old/renderer/store/slices/library/type.ts
diff --git a/src/renderer/store/slices/tabs/index.ts b/src_old/renderer/store/slices/modal/index.ts
similarity index 100%
rename from src/renderer/store/slices/tabs/index.ts
rename to src_old/renderer/store/slices/modal/index.ts
diff --git a/src/renderer/store/slices/modal/slice.ts b/src_old/renderer/store/slices/modal/slice.ts
similarity index 100%
rename from src/renderer/store/slices/modal/slice.ts
rename to src_old/renderer/store/slices/modal/slice.ts
diff --git a/src/renderer/store/slices/modal/types.ts b/src_old/renderer/store/slices/modal/types.ts
similarity index 100%
rename from src/renderer/store/slices/modal/types.ts
rename to src_old/renderer/store/slices/modal/types.ts
diff --git a/src2/frontend/store/slices/fbd/index.ts b/src_old/renderer/store/slices/project/index.ts
similarity index 100%
rename from src2/frontend/store/slices/fbd/index.ts
rename to src_old/renderer/store/slices/project/index.ts
diff --git a/src/renderer/store/slices/project/slice.ts b/src_old/renderer/store/slices/project/slice.ts
similarity index 100%
rename from src/renderer/store/slices/project/slice.ts
rename to src_old/renderer/store/slices/project/slice.ts
diff --git a/src/renderer/store/slices/project/types.ts b/src_old/renderer/store/slices/project/types.ts
similarity index 100%
rename from src/renderer/store/slices/project/types.ts
rename to src_old/renderer/store/slices/project/types.ts
diff --git a/src/renderer/store/slices/project/utils/index.ts b/src_old/renderer/store/slices/project/utils/index.ts
similarity index 100%
rename from src/renderer/store/slices/project/utils/index.ts
rename to src_old/renderer/store/slices/project/utils/index.ts
diff --git a/src/renderer/store/slices/project/validation/instances.ts b/src_old/renderer/store/slices/project/validation/instances.ts
similarity index 100%
rename from src/renderer/store/slices/project/validation/instances.ts
rename to src_old/renderer/store/slices/project/validation/instances.ts
diff --git a/src/renderer/store/slices/project/validation/tasks.ts b/src_old/renderer/store/slices/project/validation/tasks.ts
similarity index 100%
rename from src/renderer/store/slices/project/validation/tasks.ts
rename to src_old/renderer/store/slices/project/validation/tasks.ts
diff --git a/src/renderer/store/slices/project/validation/type-change.ts b/src_old/renderer/store/slices/project/validation/type-change.ts
similarity index 100%
rename from src/renderer/store/slices/project/validation/type-change.ts
rename to src_old/renderer/store/slices/project/validation/type-change.ts
diff --git a/src/renderer/store/slices/project/validation/variables.ts b/src_old/renderer/store/slices/project/validation/variables.ts
similarity index 100%
rename from src/renderer/store/slices/project/validation/variables.ts
rename to src_old/renderer/store/slices/project/validation/variables.ts
diff --git a/src2/frontend/store/slices/react-flow/index.ts b/src_old/renderer/store/slices/react-flow/index.ts
similarity index 100%
rename from src2/frontend/store/slices/react-flow/index.ts
rename to src_old/renderer/store/slices/react-flow/index.ts
diff --git a/src2/frontend/store/slices/react-flow/types.ts b/src_old/renderer/store/slices/react-flow/types.ts
similarity index 100%
rename from src2/frontend/store/slices/react-flow/types.ts
rename to src_old/renderer/store/slices/react-flow/types.ts
diff --git a/src/renderer/store/slices/search/index.ts b/src_old/renderer/store/slices/search/index.ts
similarity index 100%
rename from src/renderer/store/slices/search/index.ts
rename to src_old/renderer/store/slices/search/index.ts
diff --git a/src/renderer/store/slices/search/slice.ts b/src_old/renderer/store/slices/search/slice.ts
similarity index 100%
rename from src/renderer/store/slices/search/slice.ts
rename to src_old/renderer/store/slices/search/slice.ts
diff --git a/src/renderer/store/slices/search/type.ts b/src_old/renderer/store/slices/search/type.ts
similarity index 100%
rename from src/renderer/store/slices/search/type.ts
rename to src_old/renderer/store/slices/search/type.ts
diff --git a/src/renderer/store/slices/search/utils.ts b/src_old/renderer/store/slices/search/utils.ts
similarity index 100%
rename from src/renderer/store/slices/search/utils.ts
rename to src_old/renderer/store/slices/search/utils.ts
diff --git a/src/renderer/store/slices/shared/index.ts b/src_old/renderer/store/slices/shared/index.ts
similarity index 100%
rename from src/renderer/store/slices/shared/index.ts
rename to src_old/renderer/store/slices/shared/index.ts
diff --git a/src/renderer/store/slices/shared/utils/index.ts b/src_old/renderer/store/slices/shared/utils/index.ts
similarity index 100%
rename from src/renderer/store/slices/shared/utils/index.ts
rename to src_old/renderer/store/slices/shared/utils/index.ts
diff --git a/src2/frontend/store/slices/ladder/index.ts b/src_old/renderer/store/slices/tabs/index.ts
similarity index 100%
rename from src2/frontend/store/slices/ladder/index.ts
rename to src_old/renderer/store/slices/tabs/index.ts
diff --git a/src/renderer/store/slices/tabs/slice.ts b/src_old/renderer/store/slices/tabs/slice.ts
similarity index 100%
rename from src/renderer/store/slices/tabs/slice.ts
rename to src_old/renderer/store/slices/tabs/slice.ts
diff --git a/src/renderer/store/slices/tabs/types.ts b/src_old/renderer/store/slices/tabs/types.ts
similarity index 100%
rename from src/renderer/store/slices/tabs/types.ts
rename to src_old/renderer/store/slices/tabs/types.ts
diff --git a/src/renderer/store/slices/tabs/utils.ts b/src_old/renderer/store/slices/tabs/utils.ts
similarity index 100%
rename from src/renderer/store/slices/tabs/utils.ts
rename to src_old/renderer/store/slices/tabs/utils.ts
diff --git a/src/renderer/store/slices/workspace/index.ts b/src_old/renderer/store/slices/workspace/index.ts
similarity index 100%
rename from src/renderer/store/slices/workspace/index.ts
rename to src_old/renderer/store/slices/workspace/index.ts
diff --git a/src/renderer/store/slices/workspace/slice.ts b/src_old/renderer/store/slices/workspace/slice.ts
similarity index 100%
rename from src/renderer/store/slices/workspace/slice.ts
rename to src_old/renderer/store/slices/workspace/slice.ts
diff --git a/src/renderer/store/slices/workspace/types.ts b/src_old/renderer/store/slices/workspace/types.ts
similarity index 100%
rename from src/renderer/store/slices/workspace/types.ts
rename to src_old/renderer/store/slices/workspace/types.ts
diff --git a/src/renderer/store/slices/workspace/utils/instances.ts b/src_old/renderer/store/slices/workspace/utils/instances.ts
similarity index 100%
rename from src/renderer/store/slices/workspace/utils/instances.ts
rename to src_old/renderer/store/slices/workspace/utils/instances.ts
diff --git a/src/renderer/store/slices/workspace/utils/tasks.ts b/src_old/renderer/store/slices/workspace/utils/tasks.ts
similarity index 100%
rename from src/renderer/store/slices/workspace/utils/tasks.ts
rename to src_old/renderer/store/slices/workspace/utils/tasks.ts
diff --git a/src/renderer/store/slices/workspace/utils/variables.ts b/src_old/renderer/store/slices/workspace/utils/variables.ts
similarity index 100%
rename from src/renderer/store/slices/workspace/utils/variables.ts
rename to src_old/renderer/store/slices/workspace/utils/variables.ts
diff --git a/src2/backend/styles/globals.css b/src_old/renderer/styles/globals.css
similarity index 100%
rename from src2/backend/styles/globals.css
rename to src_old/renderer/styles/globals.css
diff --git a/src/renderer/utils/debug-tree-builder.ts b/src_old/renderer/utils/debug-tree-builder.ts
similarity index 100%
rename from src/renderer/utils/debug-tree-builder.ts
rename to src_old/renderer/utils/debug-tree-builder.ts
diff --git a/src/renderer/utils/debugger-session.ts b/src_old/renderer/utils/debugger-session.ts
similarity index 100%
rename from src/renderer/utils/debugger-session.ts
rename to src_old/renderer/utils/debugger-session.ts
diff --git a/src/renderer/utils/parse-debug-file.ts b/src_old/renderer/utils/parse-debug-file.ts
similarity index 100%
rename from src/renderer/utils/parse-debug-file.ts
rename to src_old/renderer/utils/parse-debug-file.ts
diff --git a/src2/frontend/utils/remote-device-options.ts b/src_old/renderer/utils/remote-device-options.ts
similarity index 100%
rename from src2/frontend/utils/remote-device-options.ts
rename to src_old/renderer/utils/remote-device-options.ts
diff --git a/src/renderer/utils/sync-nodes-with-variables.ts b/src_old/renderer/utils/sync-nodes-with-variables.ts
similarity index 100%
rename from src/renderer/utils/sync-nodes-with-variables.ts
rename to src_old/renderer/utils/sync-nodes-with-variables.ts
diff --git a/src/renderer/utils/validate-variable-reference.ts b/src_old/renderer/utils/validate-variable-reference.ts
similarity index 100%
rename from src/renderer/utils/validate-variable-reference.ts
rename to src_old/renderer/utils/validate-variable-reference.ts
diff --git a/src/renderer/utils/variable-references.ts b/src_old/renderer/utils/variable-references.ts
similarity index 100%
rename from src/renderer/utils/variable-references.ts
rename to src_old/renderer/utils/variable-references.ts
diff --git a/src/renderer/utils/variable-sizes.ts b/src_old/renderer/utils/variable-sizes.ts
similarity index 100%
rename from src/renderer/utils/variable-sizes.ts
rename to src_old/renderer/utils/variable-sizes.ts
diff --git a/src/shared/contracts/types/index.ts b/src_old/shared/contracts/types/index.ts
similarity index 100%
rename from src/shared/contracts/types/index.ts
rename to src_old/shared/contracts/types/index.ts
diff --git a/src/shared/contracts/types/pou.ts b/src_old/shared/contracts/types/pou.ts
similarity index 100%
rename from src/shared/contracts/types/pou.ts
rename to src_old/shared/contracts/types/pou.ts
diff --git a/src/shared/contracts/types/xml-project.ts b/src_old/shared/contracts/types/xml-project.ts
similarity index 100%
rename from src/shared/contracts/types/xml-project.ts
rename to src_old/shared/contracts/types/xml-project.ts
diff --git a/src/shared/contracts/validations/index.ts b/src_old/shared/contracts/validations/index.ts
similarity index 100%
rename from src/shared/contracts/validations/index.ts
rename to src_old/shared/contracts/validations/index.ts
diff --git a/src/shared/contracts/validations/pou-validation.ts b/src_old/shared/contracts/validations/pou-validation.ts
similarity index 100%
rename from src/shared/contracts/validations/pou-validation.ts
rename to src_old/shared/contracts/validations/pou-validation.ts
diff --git a/src/shared/contracts/validations/project-validation.ts b/src_old/shared/contracts/validations/project-validation.ts
similarity index 100%
rename from src/shared/contracts/validations/project-validation.ts
rename to src_old/shared/contracts/validations/project-validation.ts
diff --git a/src/shared/data/common.ts b/src_old/shared/data/common.ts
similarity index 100%
rename from src/shared/data/common.ts
rename to src_old/shared/data/common.ts
diff --git a/src/shared/data/constants.ts b/src_old/shared/data/constants.ts
similarity index 100%
rename from src/shared/data/constants.ts
rename to src_old/shared/data/constants.ts
diff --git a/src/shared/data/index.ts b/src_old/shared/data/index.ts
similarity index 100%
rename from src/shared/data/index.ts
rename to src_old/shared/data/index.ts
diff --git a/src2/backend/shared-data/mock/examples.json b/src_old/shared/data/mock/examples.json
similarity index 100%
rename from src2/backend/shared-data/mock/examples.json
rename to src_old/shared/data/mock/examples.json
diff --git a/src/shared/data/mock/object-to-create-project.ts b/src_old/shared/data/mock/object-to-create-project.ts
similarity index 100%
rename from src/shared/data/mock/object-to-create-project.ts
rename to src_old/shared/data/mock/object-to-create-project.ts
diff --git a/src2/backend/shared-data/mock/projects-data.json b/src_old/shared/data/mock/projects-data.json
similarity index 100%
rename from src2/backend/shared-data/mock/projects-data.json
rename to src_old/shared/data/mock/projects-data.json
diff --git a/src_old/types/IPC/pou-service/create-pou-file.ts b/src_old/types/IPC/pou-service/create-pou-file.ts
new file mode 100644
index 000000000..d48b2aeb3
--- /dev/null
+++ b/src_old/types/IPC/pou-service/create-pou-file.ts
@@ -0,0 +1,8 @@
+import { PLCPou } from '@root/types/PLC/open-plc'
+
+type CreatePouFileProps = {
+  path: string
+  pou: PLCPou
+}
+
+export { CreatePouFileProps }
diff --git a/src_old/types/IPC/pou-service/index.ts b/src_old/types/IPC/pou-service/index.ts
new file mode 100644
index 000000000..3504988df
--- /dev/null
+++ b/src_old/types/IPC/pou-service/index.ts
@@ -0,0 +1,17 @@
+import { PLCPou } from '@root/types/PLC/open-plc'
+
+export * from './create-pou-file'
+
+export type PouServiceResponse = {
+  success: boolean
+  error?: {
+    title: string
+    description: string
+    error: unknown
+  }
+  message?: string
+  data?: {
+    filePath?: string
+    pou?: PLCPou
+  }
+}
diff --git a/src_old/types/IPC/project-service/create-project.ts b/src_old/types/IPC/project-service/create-project.ts
new file mode 100644
index 000000000..43b47158c
--- /dev/null
+++ b/src_old/types/IPC/project-service/create-project.ts
@@ -0,0 +1,46 @@
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { PLCPou, PLCProject } from '@root/types/PLC/open-plc'
+
+/**
+ * Type designed to create a new project file in OpenPLC Editor.
+ */
+export type CreateProjectFileProps = {
+  language: 'il' | 'st' | 'ld' | 'sfc' | 'fbd'
+  time: string
+  type: 'plc-project' | 'plc-library'
+  name: string
+  path: string
+}
+
+/**
+ * Type designed to create default directories for a new project in OpenPLC Editor.
+ */
+export type CreateProjectDefaultDirectoriesResponse = {
+  success: boolean
+  error?: {
+    title: string
+    description: string
+    error: unknown
+  }
+  message?: string
+  data?: {
+    meta: {
+      path: string
+    }
+    content: {
+      project: PLCProject
+      /**
+       * POUs exposed as discrete files. Authoritative for save/export operations
+       * (main process uses data.content.pous when writing POU files). The renderer
+       * mirrors result.data.content.pous into project.data.pous for in‑memory state.
+       *
+       * To avoid divergence: either make content.pous the single source-of-truth
+       * for POU data, or ensure the read/write paths deterministically sync both
+       * content.pous and project.data.pous (see read-project.ts and create-project.ts).
+       */
+      pous: PLCPou[]
+      deviceConfiguration: DeviceConfiguration
+      devicePinMapping: DevicePin[]
+    }
+  }
+}
diff --git a/src_old/types/IPC/project-service/index.ts b/src_old/types/IPC/project-service/index.ts
new file mode 100644
index 000000000..da6504921
--- /dev/null
+++ b/src_old/types/IPC/project-service/index.ts
@@ -0,0 +1,27 @@
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { PLCPou, PLCProject } from '@root/types/PLC/open-plc'
+
+export * from './create-project'
+export * from './project-files-schema'
+export * from './project-recent-history'
+
+export type IProjectServiceResponse = {
+  success: boolean
+  error?: {
+    title: string
+    description: string
+    error: unknown
+  }
+  message?: string
+  data?: {
+    meta: {
+      path: string
+    }
+    content: {
+      project: PLCProject
+      pous: PLCPou[]
+      deviceConfiguration: DeviceConfiguration
+      devicePinMapping: DevicePin[]
+    }
+  }
+}
diff --git a/src_old/types/IPC/project-service/project-files-schema.ts b/src_old/types/IPC/project-service/project-files-schema.ts
new file mode 100644
index 000000000..b11d34490
--- /dev/null
+++ b/src_old/types/IPC/project-service/project-files-schema.ts
@@ -0,0 +1,15 @@
+import { deviceConfigurationSchema, devicePinSchema } from '@root/types/PLC/devices'
+import { PLCProjectSchema } from '@root/types/PLC/open-plc'
+
+export const projectDefaultFilesMapSchema = {
+  'project.json': PLCProjectSchema,
+  'devices/configuration.json': deviceConfigurationSchema,
+  'devices/pin-mapping.json': devicePinSchema.array(),
+} as const
+export type ProjectDefaultFilesMapKeys = keyof typeof projectDefaultFilesMapSchema
+export type ProjectDefaultFilesMapValues = (typeof projectDefaultFilesMapSchema)[ProjectDefaultFilesMapKeys]
+
+export const projectPouDirectories = ['pous/functions', 'pous/function-blocks', 'pous/programs'] as const
+export const projectDefaultDirectories = ['devices', ...projectPouDirectories] as const
+export const projectDefaultDirectoriesValidation = [...projectDefaultDirectories, 'build'] as readonly string[]
+export type ProjectDefaultDirectories = (typeof projectDefaultDirectories)[number]
diff --git a/src_old/types/IPC/project-service/project-recent-history.ts b/src_old/types/IPC/project-service/project-recent-history.ts
new file mode 100644
index 000000000..abfbf74a3
--- /dev/null
+++ b/src_old/types/IPC/project-service/project-recent-history.ts
@@ -0,0 +1,7 @@
+export interface IProjectRecentHistoryEntry {
+  name: string
+  path: string
+  projectFilePath: string
+  createdAt: string
+  lastOpenedAt: string
+}
diff --git a/src_old/types/IPC/project-service/read-project.ts b/src_old/types/IPC/project-service/read-project.ts
new file mode 100644
index 000000000..66994a2b3
--- /dev/null
+++ b/src_old/types/IPC/project-service/read-project.ts
@@ -0,0 +1,20 @@
+import { DeviceConfiguration, DevicePin } from '@root/types/PLC/devices'
+import { PLCPou, PLCProject, PLCRemoteDevice, PLCServer } from '@root/types/PLC/open-plc'
+
+export type IProjectServiceReadFilesResponse = {
+  success: boolean
+  error?: {
+    title: string
+    description: string
+    error: unknown
+  }
+  message?: string
+  data?: {
+    project: PLCProject
+    pous: PLCPou[]
+    deviceConfiguration: DeviceConfiguration
+    devicePinMapping: DevicePin[]
+    servers?: PLCServer[]
+    remoteDevices?: PLCRemoteDevice[]
+  }
+}
diff --git a/src_old/types/IPC/renderer.ts b/src_old/types/IPC/renderer.ts
new file mode 100644
index 000000000..1ad736b95
--- /dev/null
+++ b/src_old/types/IPC/renderer.ts
@@ -0,0 +1,2 @@
+type IRendererProcessBridge = object
+export default IRendererProcessBridge
diff --git a/src_old/types/PLC/devices/configuration.ts b/src_old/types/PLC/devices/configuration.ts
new file mode 100644
index 000000000..c3087b189
--- /dev/null
+++ b/src_old/types/PLC/devices/configuration.ts
@@ -0,0 +1,63 @@
+import { z } from 'zod'
+
+const baudRateOptions = ['9600', '14400', '19200', '38400', '57600', '115200'] as const
+
+const interfaceOptions = ['Serial', 'Serial1', 'Serial2', 'Serial3'] as const
+
+const staticHostConfigurationSchema = z.object({
+  ipAddress: z.string(), // This should have the format: XXX.XXX.XXX.XXX
+  dns: z.string(), // This should have the format: XXX.XXX.XXX.XXX
+  gateway: z.string(), // This should have the format: XXX.XXX.XXX.XXX
+  subnet: z.string(), // This should have the format: XXX.XXX.XXX.XXX
+})
+type StaticHostConfiguration = z.infer<typeof staticHostConfigurationSchema>
+
+const MAC_ADDRESS_REGEX = /^([0-9A-Fa-f]{2})([:\-,])(?:[0-9A-Fa-f]{2}\2){4}[0-9A-Fa-f]{2}$|^[0-9A-Fa-f]{12}$/
+const BYTE_MAC_ADDRESS_REGEX = /^(?:0x[0-9a-f]{2}\s*,\s*){5}0x[0-9a-f]{2}$/i
+
+const deviceConfigurationSchema = z.object({
+  deviceBoard: z.string(),
+  communicationPort: z.string(),
+  runtimeIpAddress: z.string().optional(),
+  compileOnly: z.boolean().default(false),
+  communicationConfiguration: z.object({
+    modbusRTU: z.object({
+      rtuInterface: z.enum(interfaceOptions), // This will be an enumerated that will be associated with the device board selected - Validation will be added further.
+      rtuBaudRate: z.enum(baudRateOptions), // This will be an enumerated that will be associated with the device board selected - Validation will be added further.
+      rtuSlaveId: z.number().int().gte(0).lte(255).nullable(), // Can be any integer number from 0 to 255 - Validation will be added further.
+      rtuRS485ENPin: z.string().nullable(), // Can be any integer number from 0 to 255 - Validation will be added further.
+    }),
+    modbusTCP: z.discriminatedUnion('tcpInterface', [
+      z.object({
+        tcpInterface: z.literal('Wi-Fi'),
+        tcpMacAddress: z.string().regex(MAC_ADDRESS_REGEX, 'Invalid MAC address format').nullable(), // This should have the format: XX:XX:XX:XX:XX:XX
+        tcpWifiSSID: z.string().nullable(),
+        tcpWifiPassword: z.string().nullable(),
+        tcpStaticHostConfiguration: staticHostConfigurationSchema, // When this is omitted the user has chosen DHCP.
+      }),
+      z.object({
+        tcpInterface: z.literal('Ethernet'),
+        tcpMacAddress: z.string().regex(MAC_ADDRESS_REGEX, 'Invalid MAC address format').nullable(),
+        tcpStaticHostConfiguration: staticHostConfigurationSchema, // When this is omitted the user has chosen DHCP.
+      }),
+    ]),
+    communicationPreferences: z.object({
+      enabledRTU: z.boolean(),
+      enabledTCP: z.boolean(),
+      enabledDHCP: z.boolean(),
+    }),
+  }),
+})
+
+type DeviceConfiguration = z.infer<typeof deviceConfigurationSchema>
+
+export {
+  baudRateOptions,
+  BYTE_MAC_ADDRESS_REGEX,
+  DeviceConfiguration,
+  deviceConfigurationSchema,
+  interfaceOptions,
+  MAC_ADDRESS_REGEX,
+  StaticHostConfiguration,
+  staticHostConfigurationSchema,
+}
diff --git a/src_old/types/PLC/devices/index.ts b/src_old/types/PLC/devices/index.ts
new file mode 100644
index 000000000..9156f5d0c
--- /dev/null
+++ b/src_old/types/PLC/devices/index.ts
@@ -0,0 +1,2 @@
+export * from './configuration'
+export * from './pin'
diff --git a/src_old/types/PLC/devices/pin.ts b/src_old/types/PLC/devices/pin.ts
new file mode 100644
index 000000000..d26eaade6
--- /dev/null
+++ b/src_old/types/PLC/devices/pin.ts
@@ -0,0 +1,26 @@
+import { z } from 'zod'
+
+const pinTypes = ['digitalInput', 'digitalOutput', 'analogInput', 'analogOutput'] as const
+type PinTypes = (typeof pinTypes)[number]
+
+/**
+ * The pin address obey the following name rules and is populated automatically by the editor.
+ *
+ * 1. For digital types:
+ *    - The address must start with the prefix "%QX" or "%IX"
+ *    - Following the prefix, the address must have a integer number starting with 0
+ *    - Following the number, the address must have a dot "."
+ *    - Following the dot, the address must have a integer number starting with 0 and ending with 7
+ * 2. For analog types:
+ *    - The address must start with the prefix "%QW" or "%IW"
+ *    - Following the prefix, the address must have a integer number starting with 0
+ */
+const devicePinSchema = z.object({
+  pin: z.string().min(1),
+  pinType: z.enum(pinTypes),
+  address: z.string(),
+  name: z.string().optional(),
+})
+type DevicePin = z.infer<typeof devicePinSchema>
+
+export { DevicePin, devicePinSchema, PinTypes, pinTypes }
diff --git a/src_old/types/PLC/index.ts b/src_old/types/PLC/index.ts
new file mode 100644
index 000000000..a1980db6a
--- /dev/null
+++ b/src_old/types/PLC/index.ts
@@ -0,0 +1,6 @@
+export * from './units/data-type'
+export * from './units/function'
+export * from './units/function-block'
+export * from './units/library'
+export * from './units/program'
+export * from './units/variable'
diff --git a/src_old/types/PLC/open-plc.ts b/src_old/types/PLC/open-plc.ts
new file mode 100644
index 000000000..2f4cdd4bc
--- /dev/null
+++ b/src_old/types/PLC/open-plc.ts
@@ -0,0 +1,799 @@
+import { z } from 'zod'
+
+import { zodFBDFlowSchema } from '../../renderer/store/slices/fbd/types'
+import { zodLadderFlowSchema } from '../../renderer/store/slices/ladder/types'
+
+const baseTypeSchema = z.enum([
+  'bool',
+  'sint',
+  'int',
+  'dint',
+  'lint',
+  'usint',
+  'uint',
+  'udint',
+  'ulint',
+  'real',
+  'lreal',
+  'time',
+  'date',
+  'tod',
+  'dt',
+  'string',
+  'byte',
+  'word',
+  'dword',
+  'lword',
+])
+
+type BaseType = z.infer<typeof baseTypeSchema>
+
+const PLCArrayDatatypeSchema = z.object({
+  name: z.string(),
+  derivation: z.literal('array'),
+  baseType: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('user-data-type'),
+      value: z.string(),
+    }),
+  ]),
+  initialValue: z.string().optional(),
+  dimensions: z.array(z.object({ dimension: z.string() })),
+})
+
+const PLCEnumeratedDatatypeSchema = z.object({
+  name: z.string(),
+  derivation: z.literal('enumerated'),
+  initialValue: z.string().optional(),
+  values: z.array(z.object({ description: z.string() })),
+})
+
+const PLCStructureVariableSchema = z.object({
+  name: z.string(),
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('user-data-type'),
+      value: z.string(),
+    }),
+    z.object({
+      definition: z.literal('array'),
+      value: z.string(),
+      data: z.object({
+        /** This must also include the data types created by the user */
+        baseType: z.discriminatedUnion('definition', [
+          z.object({
+            definition: z.literal('base-type'),
+            value: baseTypeSchema,
+          }),
+          z.object({
+            definition: z.literal('user-data-type'),
+            value: z.string(),
+          }),
+        ]),
+        dimensions: z.array(z.object({ dimension: z.string() })),
+      }),
+    }),
+    z.object({
+      /**
+       * This should be omitted at variable table type options
+       */
+      definition: z.literal('derived'),
+      value: z.string(),
+    }),
+  ]),
+  initialValue: z
+    .object({
+      simpleValue: z.object({
+        value: z.string(),
+      }),
+    })
+    .optional(),
+})
+const PLCStructureDatatypeSchema = z.object({
+  name: z.string(),
+  derivation: z.literal('structure'),
+  variable: z.array(PLCStructureVariableSchema),
+})
+
+type PLCEnumeratedDatatype = z.infer<typeof PLCEnumeratedDatatypeSchema>
+type PLCArrayDatatype = z.infer<typeof PLCArrayDatatypeSchema>
+type PLCStructureDatatype = z.infer<typeof PLCStructureDatatypeSchema>
+type PLCStructureVariable = z.infer<typeof PLCStructureVariableSchema>
+
+const PLCDataTypeSchema = z.discriminatedUnion('derivation', [
+  PLCStructureDatatypeSchema,
+  PLCEnumeratedDatatypeSchema,
+  PLCArrayDatatypeSchema,
+])
+
+type PLCDataType = z.infer<typeof PLCDataTypeSchema>
+
+const PLCVariableSchema = z.object({
+  name: z.string(),
+  class: z.enum(['input', 'output', 'inOut', 'external', 'local', 'temp', 'global']).optional(),
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: baseTypeSchema,
+    }),
+    z.object({
+      definition: z.literal('user-data-type'),
+      value: z.string(),
+    }),
+    z.object({
+      definition: z.literal('array'),
+      value: z.string(),
+      data: z.object({
+        /** This must also include the data types created by the user */
+        baseType: z.discriminatedUnion('definition', [
+          z.object({
+            definition: z.literal('base-type'),
+            value: baseTypeSchema,
+          }),
+          z.object({
+            definition: z.literal('user-data-type'),
+            value: z.string(),
+          }),
+        ]),
+        dimensions: z.array(z.object({ dimension: z.string() })),
+      }),
+    }),
+    z.object({
+      definition: z.literal('derived'),
+      value: z.string(),
+    }),
+  ]),
+  location: z.string(),
+  initialValue: z.string().or(z.null()).optional(),
+  documentation: z.string(),
+  debug: z.boolean().optional(),
+})
+
+type PLCVariable = z.infer<typeof PLCVariableSchema>
+const PLCGlobalVariableSchema = PLCVariableSchema
+type PLCGlobalVariable = z.infer<typeof PLCGlobalVariableSchema>
+
+const PLCTaskSchema = z.object({
+  name: z.string(), // TODO: This should be homologate. Concept: An unique identifier for the task object.
+  triggering: z.enum(['Cyclic', 'Interrupt']),
+  interval: z.string(), // TODO: Must have a regex validation for this. Probably a new modal must be created to handle this.
+  priority: z.number(), // TODO: implement this validation. This must be a positive integer from 0 to 100
+})
+
+type PLCTask = z.infer<typeof PLCTaskSchema>
+
+const bodySchema = z.discriminatedUnion('language', [
+  z.object({
+    language: z.literal('il'),
+    value: z.string(),
+  }),
+  z.object({
+    language: z.literal('st'),
+    value: z.string(),
+  }),
+  z.object({
+    language: z.literal('ld'),
+    value: zodLadderFlowSchema,
+  }),
+  z.object({
+    language: z.literal('sfc'),
+    value: z.string(),
+  }),
+  z.object({
+    language: z.literal('fbd'),
+    value: zodFBDFlowSchema,
+  }),
+  z.object({
+    language: z.literal('python'),
+    value: z.string(),
+  }),
+  z.object({
+    language: z.literal('cpp'),
+    value: z.string(),
+  }),
+])
+
+type BodySchema = z.infer<typeof bodySchema>
+//
+const PLCFunctionSchema = z.object({
+  language: z.enum(['il', 'st', 'ld', 'sfc', 'fbd', 'python', 'cpp']),
+  name: z.string(),
+  returnType: z.union([baseTypeSchema, z.string()]),
+  /** Array of variable - will be implemented */
+  variables: z.array(PLCVariableSchema),
+  body: bodySchema,
+  documentation: z.string(),
+  /** Raw unparsed variables text - used to preserve user input even if it doesn't parse correctly */
+  variablesText: z.string().optional(),
+})
+
+type PLCFunction = z.infer<typeof PLCFunctionSchema>
+
+const PLCProgramSchema = z.object({
+  language: z.enum(['il', 'st', 'ld', 'sfc', 'fbd', 'python', 'cpp']),
+  name: z.string(),
+  /** Array of variable - will be implemented */
+  variables: z.array(PLCVariableSchema),
+  body: bodySchema,
+  documentation: z.string(),
+  /** Raw unparsed variables text - used to preserve user input even if it doesn't parse correctly */
+  variablesText: z.string().optional(),
+})
+
+type PLCProgram = z.infer<typeof PLCProgramSchema>
+
+const PLCInstanceSchema = z.object({
+  name: z.string(), // TODO: This should be homologate. Concept: An unique identifier for the instance object.
+  task: z.string(), // TODO: Implement this validation. This task must be one of the objects in the "tasks" array defined right above.
+  program: z.string(), // TODO: Implement this validation. This program must be one of the user's defined pou of program type.
+})
+
+type PLCInstance = z.infer<typeof PLCInstanceSchema>
+
+const PLCFunctionBlockSchema = z.object({
+  language: z.enum(['il', 'st', 'ld', 'sfc', 'fbd', 'python', 'cpp']),
+  name: z.string(),
+  /** Array of variable - will be implemented */
+  variables: z.array(PLCVariableSchema),
+  body: bodySchema,
+  documentation: z.string(),
+  /** Raw unparsed variables text - used to preserve user input even if it doesn't parse correctly */
+  variablesText: z.string().optional(),
+})
+
+type PLCFunctionBlock = z.infer<typeof PLCFunctionBlockSchema>
+
+const PLCPouSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('program'),
+    data: PLCProgramSchema,
+  }),
+  z.object({
+    type: z.literal('function'),
+    data: PLCFunctionSchema,
+  }),
+  z.object({
+    type: z.literal('function-block'),
+    data: PLCFunctionBlockSchema,
+  }),
+])
+type PLCPou = z.infer<typeof PLCPouSchema>
+
+const PLCConfigurationSchema = z.object({
+  resource: z.object({
+    tasks: z.array(PLCTaskSchema),
+    instances: z.array(PLCInstanceSchema),
+    globalVariables: z.array(PLCVariableSchema.omit({ class: true })),
+  }),
+})
+type PLCConfiguration = z.infer<typeof PLCConfigurationSchema>
+
+const PLCServerProtocolSchema = z.enum(['modbus-tcp', 's7comm', 'ethernet-ip', 'opcua'])
+type PLCServerProtocol = z.infer<typeof PLCServerProtocolSchema>
+
+const ModbusSlaveBufferMappingSchema = z.object({
+  holdingRegisters: z.object({
+    qwCount: z.number(),
+    mwCount: z.number(),
+    mdCount: z.number(),
+    mlCount: z.number(),
+  }),
+  coils: z.object({
+    qxBits: z.number(),
+    mxBits: z.number(),
+  }),
+  discreteInputs: z.object({
+    ixBits: z.number(),
+  }),
+  inputRegisters: z.object({
+    iwCount: z.number(),
+  }),
+})
+type ModbusSlaveBufferMapping = z.infer<typeof ModbusSlaveBufferMappingSchema>
+
+const ModbusSlaveConfigSchema = z.object({
+  enabled: z.boolean(),
+  networkInterface: z.string(),
+  port: z.number(),
+  bufferMapping: ModbusSlaveBufferMappingSchema.optional(),
+})
+type ModbusSlaveConfig = z.infer<typeof ModbusSlaveConfigSchema>
+
+// S7Comm Buffer Type Enumeration
+const S7CommBufferTypeSchema = z.enum([
+  'bool_input',
+  'bool_output',
+  'bool_memory',
+  'byte_input',
+  'byte_output',
+  'int_input',
+  'int_output',
+  'int_memory',
+  'dint_input',
+  'dint_output',
+  'dint_memory',
+  'lint_input',
+  'lint_output',
+  'lint_memory',
+])
+type S7CommBufferType = z.infer<typeof S7CommBufferTypeSchema>
+
+// S7Comm Server Settings Schema
+const S7CommServerSettingsSchema = z.object({
+  enabled: z.boolean(),
+  bindAddress: z.string(),
+  port: z.number().min(1).max(65535),
+  maxClients: z.number().min(1).max(1024),
+  workIntervalMs: z.number().min(1).max(10000),
+  sendTimeoutMs: z.number().min(100).max(60000),
+  recvTimeoutMs: z.number().min(100).max(60000),
+  pingTimeoutMs: z.number().min(1000).max(300000),
+  pduSize: z.number().min(240).max(960),
+})
+type S7CommServerSettings = z.infer<typeof S7CommServerSettingsSchema>
+
+// S7Comm PLC Identity Schema
+const S7CommPlcIdentitySchema = z.object({
+  name: z.string().max(64),
+  moduleType: z.string().max(64),
+  serialNumber: z.string().max(64),
+  copyright: z.string().max(64),
+  moduleName: z.string().max(64),
+})
+type S7CommPlcIdentity = z.infer<typeof S7CommPlcIdentitySchema>
+
+// S7Comm Buffer Mapping Schema
+const S7CommBufferMappingSchema = z.object({
+  type: S7CommBufferTypeSchema,
+  startBuffer: z.number().min(0).max(1023),
+  bitAddressing: z.boolean(),
+})
+type S7CommBufferMapping = z.infer<typeof S7CommBufferMappingSchema>
+
+// S7Comm Data Block Schema
+const S7CommDataBlockSchema = z.object({
+  dbNumber: z.number().min(1).max(65535),
+  description: z.string().max(128),
+  sizeBytes: z.number().min(1).max(65536),
+  mapping: S7CommBufferMappingSchema,
+})
+type S7CommDataBlock = z.infer<typeof S7CommDataBlockSchema>
+
+// S7Comm System Area Schema
+const S7CommSystemAreaSchema = z.object({
+  enabled: z.boolean(),
+  sizeBytes: z.number().min(1).max(65536),
+  mapping: S7CommBufferMappingSchema.optional(),
+})
+type S7CommSystemArea = z.infer<typeof S7CommSystemAreaSchema>
+
+// S7Comm System Areas Container Schema
+const S7CommSystemAreasSchema = z.object({
+  peArea: S7CommSystemAreaSchema.optional(),
+  paArea: S7CommSystemAreaSchema.optional(),
+  mkArea: S7CommSystemAreaSchema.optional(),
+})
+type S7CommSystemAreas = z.infer<typeof S7CommSystemAreasSchema>
+
+// S7Comm Logging Schema
+const S7CommLoggingSchema = z.object({
+  logConnections: z.boolean(),
+  logDataAccess: z.boolean(),
+  logErrors: z.boolean(),
+})
+type S7CommLogging = z.infer<typeof S7CommLoggingSchema>
+
+// Complete S7Comm Slave Config Schema
+const S7CommSlaveConfigSchema = z.object({
+  server: S7CommServerSettingsSchema,
+  plcIdentity: S7CommPlcIdentitySchema.optional(),
+  dataBlocks: z.array(S7CommDataBlockSchema).max(64),
+  systemAreas: S7CommSystemAreasSchema.optional(),
+  logging: S7CommLoggingSchema.optional(),
+})
+type S7CommSlaveConfig = z.infer<typeof S7CommSlaveConfigSchema>
+
+// ═══════════════════════════════════════════════════════════════════════════
+// OPC-UA Server Configuration Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+// OPC-UA Security Policy Enumeration
+const OpcUaSecurityPolicySchema = z.enum(['None', 'Basic128Rsa15', 'Basic256', 'Basic256Sha256'])
+type OpcUaSecurityPolicy = z.infer<typeof OpcUaSecurityPolicySchema>
+
+// OPC-UA Security Mode Enumeration
+const OpcUaSecurityModeSchema = z.enum(['None', 'Sign', 'SignAndEncrypt'])
+type OpcUaSecurityMode = z.infer<typeof OpcUaSecurityModeSchema>
+
+// OPC-UA Authentication Method Enumeration
+const OpcUaAuthMethodSchema = z.enum(['Anonymous', 'Username', 'Certificate'])
+type OpcUaAuthMethod = z.infer<typeof OpcUaAuthMethodSchema>
+
+// OPC-UA User Role Enumeration
+const OpcUaUserRoleSchema = z.enum(['viewer', 'operator', 'engineer'])
+type OpcUaUserRole = z.infer<typeof OpcUaUserRoleSchema>
+
+// OPC-UA Security Profile Schema
+const OpcUaSecurityProfileSchema = z.object({
+  id: z.string(),
+  name: z.string().min(1).max(64),
+  enabled: z.boolean(),
+  securityPolicy: OpcUaSecurityPolicySchema,
+  securityMode: OpcUaSecurityModeSchema,
+  authMethods: z.array(OpcUaAuthMethodSchema).min(1),
+})
+type OpcUaSecurityProfile = z.infer<typeof OpcUaSecurityProfileSchema>
+
+// OPC-UA Trusted Certificate Schema
+const OpcUaTrustedCertificateSchema = z.object({
+  id: z.string().min(1).max(64),
+  pem: z.string(),
+  subject: z.string().optional(),
+  validFrom: z.string().optional(),
+  validTo: z.string().optional(),
+  fingerprint: z.string().optional(),
+})
+type OpcUaTrustedCertificate = z.infer<typeof OpcUaTrustedCertificateSchema>
+
+// OPC-UA User Schema
+const OpcUaUserSchema = z.object({
+  id: z.string(),
+  type: z.enum(['password', 'certificate']),
+  username: z.string().nullable(),
+  passwordHash: z.string().nullable(),
+  certificateId: z.string().nullable(),
+  role: OpcUaUserRoleSchema,
+})
+type OpcUaUser = z.infer<typeof OpcUaUserSchema>
+
+// OPC-UA Permissions Schema (per-variable access control)
+const OpcUaPermissionsSchema = z.object({
+  viewer: z.enum(['r', 'w', 'rw']),
+  operator: z.enum(['r', 'w', 'rw']),
+  engineer: z.enum(['r', 'w', 'rw']),
+})
+type OpcUaPermissions = z.infer<typeof OpcUaPermissionsSchema>
+
+// OPC-UA Field Configuration Schema (for structure fields)
+// Uses z.lazy() to support recursive nested fields for complex types (FBs, structs)
+interface OpcUaFieldConfig {
+  fieldPath: string
+  displayName: string
+  /** Data type of the field. Optional for backward compatibility with existing projects. */
+  datatype?: string
+  initialValue: boolean | number | string
+  permissions: OpcUaPermissions
+  /** Nested fields for complex types (FB instances, nested structs). Undefined or empty for leaf fields. */
+  fields?: OpcUaFieldConfig[]
+}
+const OpcUaFieldConfigSchema: z.ZodType<OpcUaFieldConfig> = z.lazy(() =>
+  z.object({
+    fieldPath: z.string(),
+    displayName: z.string(),
+    datatype: z.string().optional(), // Optional for backward compatibility
+    initialValue: z.union([z.boolean(), z.number(), z.string()]),
+    permissions: OpcUaPermissionsSchema,
+    fields: z.array(OpcUaFieldConfigSchema).optional(),
+  }),
+)
+
+// OPC-UA Node Configuration Schema (variable/structure/array)
+const OpcUaNodeConfigSchema = z.object({
+  id: z.string(),
+  pouName: z.string(),
+  variablePath: z.string(),
+  variableType: z.string(),
+  nodeId: z.string(),
+  browseName: z.string(),
+  displayName: z.string(),
+  description: z.string(),
+  initialValue: z.union([z.boolean(), z.number(), z.string()]),
+  permissions: OpcUaPermissionsSchema,
+  nodeType: z.enum(['variable', 'structure', 'array']),
+  fields: z.array(OpcUaFieldConfigSchema).optional(),
+  arrayLength: z.number().optional(),
+  elementType: z.string().optional(),
+})
+type OpcUaNodeConfig = z.infer<typeof OpcUaNodeConfigSchema>
+
+// OPC-UA Server Settings Schema
+const OpcUaServerSettingsSchema = z.object({
+  enabled: z.boolean(),
+  name: z.string().max(128),
+  applicationUri: z.string(),
+  productUri: z.string(),
+  bindAddress: z.string(),
+  port: z.number().int().min(1).max(65535),
+  endpointPath: z.string(),
+})
+type OpcUaServerSettings = z.infer<typeof OpcUaServerSettingsSchema>
+
+// OPC-UA Security Configuration Schema
+const OpcUaSecurityConfigSchema = z.object({
+  serverCertificateStrategy: z.enum(['auto_self_signed', 'custom']),
+  serverCertificateCustom: z.string().nullable(),
+  serverPrivateKeyCustom: z.string().nullable(),
+  trustedClientCertificates: z.array(OpcUaTrustedCertificateSchema),
+})
+type OpcUaSecurityConfig = z.infer<typeof OpcUaSecurityConfigSchema>
+
+// OPC-UA Address Space Configuration Schema
+const OpcUaAddressSpaceConfigSchema = z.object({
+  namespaceUri: z.string(),
+  nodes: z.array(OpcUaNodeConfigSchema),
+})
+type OpcUaAddressSpaceConfig = z.infer<typeof OpcUaAddressSpaceConfigSchema>
+
+// Complete OPC-UA Server Configuration Schema
+const OpcUaServerConfigSchema = z.object({
+  server: OpcUaServerSettingsSchema,
+  securityProfiles: z.array(OpcUaSecurityProfileSchema),
+  security: OpcUaSecurityConfigSchema,
+  users: z.array(OpcUaUserSchema),
+  cycleTimeMs: z.number().int().min(10).max(10000),
+  addressSpace: OpcUaAddressSpaceConfigSchema,
+})
+type OpcUaServerConfig = z.infer<typeof OpcUaServerConfigSchema>
+
+const PLCServerSchema = z.object({
+  name: z.string(),
+  protocol: PLCServerProtocolSchema,
+  modbusSlaveConfig: ModbusSlaveConfigSchema.optional(),
+  s7commSlaveConfig: S7CommSlaveConfigSchema.optional(),
+  opcuaServerConfig: OpcUaServerConfigSchema.optional(),
+})
+type PLCServer = z.infer<typeof PLCServerSchema>
+
+// Remote Device (Modbus Master) types
+const ModbusFunctionCodeSchema = z.enum(['1', '2', '3', '4', '5', '6', '15', '16'])
+type ModbusFunctionCode = z.infer<typeof ModbusFunctionCodeSchema>
+
+const ModbusErrorHandlingSchema = z.enum(['keep-last-value', 'set-to-zero'])
+type ModbusErrorHandling = z.infer<typeof ModbusErrorHandlingSchema>
+
+// Modbus transport type: TCP/IP or RTU (serial)
+const ModbusTransportTypeSchema = z.enum(['tcp', 'rtu'])
+type ModbusTransportType = z.infer<typeof ModbusTransportTypeSchema>
+
+// Modbus RTU parity settings
+const ModbusParitySchema = z.enum(['N', 'E', 'O'])
+type ModbusParity = z.infer<typeof ModbusParitySchema>
+
+const ModbusIOPointSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string(),
+  iecLocation: z.string(),
+  alias: z.string().optional(),
+})
+type ModbusIOPoint = z.infer<typeof ModbusIOPointSchema>
+
+const ModbusIOGroupSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  functionCode: ModbusFunctionCodeSchema,
+  cycleTime: z.number(),
+  offset: z.string(),
+  length: z.number(),
+  errorHandling: ModbusErrorHandlingSchema,
+  ioPoints: z.array(ModbusIOPointSchema),
+})
+type ModbusIOGroup = z.infer<typeof ModbusIOGroupSchema>
+
+const ModbusTcpConfigSchema = z.object({
+  // Transport type: 'tcp' (default) or 'rtu' (serial)
+  transport: ModbusTransportTypeSchema.optional(),
+  // TCP-specific fields (optional when using RTU)
+  host: z.string().optional(),
+  port: z.number().optional(),
+  // RTU-specific fields (optional when using TCP)
+  serialPort: z.string().optional(),
+  baudRate: z.number().optional(),
+  parity: ModbusParitySchema.optional(),
+  stopBits: z.number().int().min(1).max(2).optional(),
+  dataBits: z.number().int().min(7).max(8).optional(),
+  // Common fields
+  timeout: z.number(),
+  slaveId: z.number().int().min(0).max(255).optional(),
+  ioGroups: z.array(ModbusIOGroupSchema),
+})
+type ModbusTcpConfig = z.infer<typeof ModbusTcpConfigSchema>
+
+const PLCRemoteDeviceProtocolSchema = z.enum(['modbus-tcp', 'ethernet-ip', 'ethercat', 'profinet'])
+type PLCRemoteDeviceProtocol = z.infer<typeof PLCRemoteDeviceProtocolSchema>
+
+const PLCRemoteDeviceSchema = z.object({
+  name: z.string(),
+  protocol: PLCRemoteDeviceProtocolSchema,
+  modbusTcpConfig: ModbusTcpConfigSchema.optional(),
+})
+type PLCRemoteDevice = z.infer<typeof PLCRemoteDeviceSchema>
+
+/**
+ * Schema for storing debug variable flags.
+ * Since POU variables are saved as text files (IEC 61131-3 format) which don't support debug flags,
+ * we store the debug flags separately in project.json.
+ */
+const PLCDebugVariablesSchema = z
+  .object({
+    global: z.array(z.string()).optional(),
+    pous: z.record(z.string(), z.array(z.string())).optional(),
+  })
+  .optional()
+
+type PLCDebugVariables = z.infer<typeof PLCDebugVariablesSchema>
+
+const PLCProjectDataSchema = z.object({
+  dataTypes: z.array(PLCDataTypeSchema),
+  pous: z.array(PLCPouSchema).default([]),
+  configuration: PLCConfigurationSchema,
+  servers: z.array(PLCServerSchema).optional(),
+  remoteDevices: z.array(PLCRemoteDeviceSchema).optional(),
+  debugVariables: PLCDebugVariablesSchema,
+  deletedPous: z
+    .array(
+      z.object({
+        name: z.string(),
+        type: z.enum(['program', 'function', 'function-block']),
+        language: z.enum(['il', 'st', 'ld', 'sfc', 'fbd', 'python', 'cpp']),
+      }),
+    )
+    .optional(),
+  deletedServers: z
+    .array(
+      z.object({
+        name: z.string(),
+        protocol: PLCServerProtocolSchema,
+      }),
+    )
+    .optional(),
+  deletedRemoteDevices: z
+    .array(
+      z.object({
+        name: z.string(),
+        protocol: PLCRemoteDeviceProtocolSchema,
+      }),
+    )
+    .optional(),
+})
+
+type PLCProjectData = z.infer<typeof PLCProjectDataSchema>
+
+const PLCProjectMetaSchema = z.object({
+  name: z.string(),
+  type: z.enum(['plc-project', 'plc-library']),
+})
+type PLCProjectMeta = z.infer<typeof PLCProjectMetaSchema>
+
+const PLCProjectSchema = z.object({
+  meta: PLCProjectMetaSchema,
+  data: PLCProjectDataSchema,
+})
+
+type PLCProject = z.infer<typeof PLCProjectSchema>
+
+export {
+  baseTypeSchema,
+  bodySchema,
+  ModbusErrorHandlingSchema,
+  ModbusFunctionCodeSchema,
+  ModbusIOGroupSchema,
+  ModbusIOPointSchema,
+  ModbusParitySchema,
+  ModbusSlaveBufferMappingSchema,
+  ModbusSlaveConfigSchema,
+  ModbusTcpConfigSchema,
+  ModbusTransportTypeSchema,
+  OpcUaAddressSpaceConfigSchema,
+  OpcUaAuthMethodSchema,
+  OpcUaFieldConfigSchema,
+  OpcUaNodeConfigSchema,
+  OpcUaPermissionsSchema,
+  OpcUaSecurityConfigSchema,
+  OpcUaSecurityModeSchema,
+  OpcUaSecurityPolicySchema,
+  OpcUaSecurityProfileSchema,
+  OpcUaServerConfigSchema,
+  OpcUaServerSettingsSchema,
+  OpcUaTrustedCertificateSchema,
+  OpcUaUserRoleSchema,
+  OpcUaUserSchema,
+  PLCArrayDatatypeSchema,
+  PLCConfigurationSchema,
+  PLCDataTypeSchema,
+  PLCDebugVariablesSchema,
+  PLCEnumeratedDatatypeSchema,
+  PLCFunctionBlockSchema,
+  PLCFunctionSchema,
+  PLCGlobalVariableSchema,
+  PLCInstanceSchema,
+  PLCPouSchema,
+  PLCProgramSchema,
+  PLCProjectDataSchema,
+  PLCProjectMetaSchema,
+  PLCProjectSchema,
+  PLCRemoteDeviceProtocolSchema,
+  PLCRemoteDeviceSchema,
+  PLCServerProtocolSchema,
+  PLCServerSchema,
+  PLCStructureDatatypeSchema,
+  PLCStructureVariableSchema,
+  PLCTaskSchema,
+  PLCVariableSchema,
+  S7CommBufferMappingSchema,
+  S7CommBufferTypeSchema,
+  S7CommDataBlockSchema,
+  S7CommLoggingSchema,
+  S7CommPlcIdentitySchema,
+  S7CommServerSettingsSchema,
+  S7CommSlaveConfigSchema,
+  S7CommSystemAreaSchema,
+  S7CommSystemAreasSchema,
+}
+
+export type {
+  BaseType,
+  BodySchema,
+  ModbusErrorHandling,
+  ModbusFunctionCode,
+  ModbusIOGroup,
+  ModbusIOPoint,
+  ModbusParity,
+  ModbusSlaveBufferMapping,
+  ModbusSlaveConfig,
+  ModbusTcpConfig,
+  ModbusTransportType,
+  OpcUaAddressSpaceConfig,
+  OpcUaAuthMethod,
+  OpcUaFieldConfig,
+  OpcUaNodeConfig,
+  OpcUaPermissions,
+  OpcUaSecurityConfig,
+  OpcUaSecurityMode,
+  OpcUaSecurityPolicy,
+  OpcUaSecurityProfile,
+  OpcUaServerConfig,
+  OpcUaServerSettings,
+  OpcUaTrustedCertificate,
+  OpcUaUser,
+  OpcUaUserRole,
+  PLCArrayDatatype,
+  PLCConfiguration,
+  PLCDataType,
+  PLCDebugVariables,
+  PLCEnumeratedDatatype,
+  PLCFunction,
+  PLCFunctionBlock,
+  PLCGlobalVariable,
+  PLCInstance,
+  PLCPou,
+  PLCProgram,
+  PLCProject,
+  PLCProjectData,
+  PLCProjectMeta,
+  PLCRemoteDevice,
+  PLCRemoteDeviceProtocol,
+  PLCServer,
+  PLCServerProtocol,
+  PLCStructureDatatype,
+  PLCStructureVariable,
+  PLCTask,
+  PLCVariable,
+  S7CommBufferMapping,
+  S7CommBufferType,
+  S7CommDataBlock,
+  S7CommLogging,
+  S7CommPlcIdentity,
+  S7CommServerSettings,
+  S7CommSlaveConfig,
+  S7CommSystemArea,
+  S7CommSystemAreas,
+}
diff --git a/src_old/types/PLC/pous/index.ts b/src_old/types/PLC/pous/index.ts
new file mode 100644
index 000000000..e42b99390
--- /dev/null
+++ b/src_old/types/PLC/pous/index.ts
@@ -0,0 +1,2 @@
+export * from './language'
+export * from './types'
diff --git a/src_old/types/PLC/pous/language.ts b/src_old/types/PLC/pous/language.ts
new file mode 100644
index 000000000..a00ba989c
--- /dev/null
+++ b/src_old/types/PLC/pous/language.ts
@@ -0,0 +1,15 @@
+import z from 'zod'
+
+const pousLanguageSchema = z.object({
+  textual: z.enum(['il', 'st', 'python', 'cpp']),
+  graphical: z.enum(['ld', 'sfc', 'fbd']),
+})
+type PousLanguage = z.infer<typeof pousLanguageSchema>
+
+const pousAllLanguages = [
+  ...pousLanguageSchema.shape.textual.options,
+  ...pousLanguageSchema.shape.graphical.options,
+] as const
+
+export { pousAllLanguages, pousLanguageSchema }
+export type { PousLanguage }
diff --git a/src_old/types/PLC/pous/types.ts b/src_old/types/PLC/pous/types.ts
new file mode 100644
index 000000000..777fb3eb5
--- /dev/null
+++ b/src_old/types/PLC/pous/types.ts
@@ -0,0 +1,8 @@
+import z from 'zod'
+
+const pouTypesSchema = z.enum(['program', 'function', 'function-block'])
+const pouTypesArr = pouTypesSchema.options
+type PouType = z.infer<typeof pouTypesSchema>
+
+export type { PouType }
+export { pouTypesArr, pouTypesSchema }
diff --git a/src_old/types/PLC/project/data.ts b/src_old/types/PLC/project/data.ts
new file mode 100644
index 000000000..4a45c38d5
--- /dev/null
+++ b/src_old/types/PLC/project/data.ts
@@ -0,0 +1,42 @@
+import { z } from 'zod'
+
+import {
+  PLCDataTypeSchema,
+  PLCFunctionBlockSchema,
+  PLCFunctionSchema,
+  PLCInstanceSchema,
+  PLCProgramSchema,
+  PLCTaskSchema,
+  PLCVariableSchema,
+} from '../open-plc'
+
+const PLCProjectDataSchema = z.object({
+  'data-types': z.array(PLCDataTypeSchema),
+  pous: z.array(
+    z.discriminatedUnion('type', [
+      z.object({
+        type: z.literal('program'),
+        data: PLCProgramSchema,
+      }),
+      z.object({
+        type: z.literal('function'),
+        data: PLCFunctionSchema,
+      }),
+      z.object({
+        type: z.literal('function-block'),
+        data: PLCFunctionBlockSchema,
+      }),
+    ]),
+  ),
+  configuration: z.object({
+    resource: z.object({
+      tasks: z.array(PLCTaskSchema),
+      instances: z.array(PLCInstanceSchema),
+      'global-variables': z.array(PLCVariableSchema.omit({ class: true })),
+    }),
+  }),
+})
+
+type PLCProjectData = z.infer<typeof PLCProjectDataSchema>
+
+export { PLCProjectData, PLCProjectDataSchema }
diff --git a/src_old/types/PLC/project/index.ts b/src_old/types/PLC/project/index.ts
new file mode 100644
index 000000000..3c07ae473
--- /dev/null
+++ b/src_old/types/PLC/project/index.ts
@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+const PLCProjectJSONSchema = z.object({
+  meta: z.object({
+    name: z.string(),
+    type: z.enum(['plc-project', 'plc-library']).default('plc-project'),
+  }),
+  data: z.object({
+    'data-types': z.array(z.string()),
+    pous: z.array(z.string()),
+    configurations: z.object({
+      resource: z.object({
+        tasks: z.array(z.string()),
+        instances: z.array(z.string()),
+        globalVariables: z.array(z.string()),
+      }),
+    }),
+  }),
+})
+
+export { PLCProjectJSONSchema }
diff --git a/src_old/types/PLC/project/json.ts b/src_old/types/PLC/project/json.ts
new file mode 100644
index 000000000..9768d77cb
--- /dev/null
+++ b/src_old/types/PLC/project/json.ts
@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+import { PLCProjectDataSchema } from './data'
+
+const PLCProjectJSONSchema = z.object({
+  meta: z.object({
+    name: z.string(),
+    type: z.enum(['plc-project', 'plc-library']).default('plc-project'),
+  }),
+  data: PLCProjectDataSchema,
+})
+
+export { PLCProjectJSONSchema }
diff --git a/src_old/types/PLC/runtime-logs.ts b/src_old/types/PLC/runtime-logs.ts
new file mode 100644
index 000000000..943895066
--- /dev/null
+++ b/src_old/types/PLC/runtime-logs.ts
@@ -0,0 +1,42 @@
+/**
+ * Maximum number of log entries to keep in the client-side buffer.
+ * This prevents unbounded memory growth when polling logs continuously.
+ */
+export const LOG_BUFFER_CAP = 1000
+
+/**
+ * Log levels supported by OpenPLC Runtime v4.
+ * These map to the LogComponent's level prop for styling.
+ */
+export type RuntimeLogLevel = 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR'
+
+/**
+ * A single log entry from OpenPLC Runtime v4.
+ * V4 returns structured log objects with metadata.
+ */
+export type RuntimeLogEntry = {
+  id: number | null
+  timestamp: string
+  level: RuntimeLogLevel
+  message: string
+}
+
+/**
+ * Union type representing logs from either v3 (string) or v4 (array) runtime.
+ * Used for backward compatibility.
+ */
+export type PlcLogs = string | RuntimeLogEntry[]
+
+/**
+ * Type guard to check if logs are in v4 format (array of objects).
+ */
+export function isV4Logs(logs: PlcLogs): logs is RuntimeLogEntry[] {
+  return Array.isArray(logs)
+}
+
+/**
+ * Type guard to check if logs are in v3 format (plain string).
+ */
+export function isV3Logs(logs: PlcLogs): logs is string {
+  return typeof logs === 'string'
+}
diff --git a/src_old/types/PLC/units/base-types.ts b/src_old/types/PLC/units/base-types.ts
new file mode 100644
index 000000000..e3f0b7cee
--- /dev/null
+++ b/src_old/types/PLC/units/base-types.ts
@@ -0,0 +1,9 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const PLCBaseTypesSchema = z.enum(baseTypes)
+
+type PLCBaseTypes = z.infer<typeof PLCBaseTypesSchema>
+type PLCBaseTypesLowercase = Lowercase<PLCBaseTypes>
+
+export { PLCBaseTypes, PLCBaseTypesLowercase, PLCBaseTypesSchema }
diff --git a/src_old/types/PLC/units/data-type.ts b/src_old/types/PLC/units/data-type.ts
new file mode 100644
index 000000000..4af33c08a
--- /dev/null
+++ b/src_old/types/PLC/units/data-type.ts
@@ -0,0 +1,113 @@
+import { z } from 'zod'
+
+const dataTypeSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  derivation: z.discriminatedUnion('type', [
+    /** This array needs to be reviewed */
+    z.object({
+      type: z.literal('array'),
+      baseType: z.enum([
+        'bool',
+        'sint',
+        'int',
+        'dint',
+        'lint',
+        'usint',
+        'uint',
+        'udint',
+        'ulint',
+        'real',
+        'lreal',
+        'time',
+        'date',
+        'tod',
+        'dt',
+        'string',
+        'byte',
+        'word',
+        'dword',
+        'lword',
+        /** Can also be a local datatype - created by the user */
+      ]),
+      /** This property needs to be updated to validate if the right number is higher than the left */
+      dimensions: z.array(z.string().regex(/^(\d+)\.\.(\d+)$/)),
+    }),
+    /** This enumerated needs to be reviewed */
+    z.object({
+      type: z.literal('enumerated'),
+      values: z.array(z.string()),
+      /** The initial value must be one of the values created */
+      initialValue: z.string(),
+    }),
+    /** This structure needs to be reviewed */
+    z.object({
+      type: z.literal('structure'),
+      elements: z.array(
+        z.object({
+          id: z.number(),
+          name: z.string(),
+          type: z.discriminatedUnion('type', [
+            z.object({
+              type: z.literal('base-type'),
+              value: z.enum([
+                'bool',
+                'sint',
+                'int',
+                'dint',
+                'lint',
+                'usint',
+                'uint',
+                'udint',
+                'ulint',
+                'real',
+                'lreal',
+                'time',
+                'date',
+                'tod',
+                'dt',
+                'string',
+                'byte',
+                'word',
+                'dword',
+                'lword',
+              ]),
+            }),
+            z.object({
+              type: z.literal('array'),
+              value: z.object({
+                baseType: z.enum([
+                  'bool',
+                  'sint',
+                  'int',
+                  'dint',
+                  'lint',
+                  'usint',
+                  'uint',
+                  'udint',
+                  'ulint',
+                  'real',
+                  'lreal',
+                  'time',
+                  'date',
+                  'tod',
+                  'dt',
+                  'string',
+                  'byte',
+                  'word',
+                  'dword',
+                  'lword',
+                ]),
+                /** This property needs to be updated to validate if the right number is higher than the left */
+                dimensions: z.string().regex(/^(\d+)\.\.(\d+)$/),
+              }),
+            }),
+          ]),
+        }),
+      ),
+    }),
+  ]),
+})
+
+type IDatatype = z.infer<typeof dataTypeSchema>
+export { dataTypeSchema, IDatatype }
diff --git a/src_old/types/PLC/units/function-block.ts b/src_old/types/PLC/units/function-block.ts
new file mode 100644
index 000000000..01ca77d6f
--- /dev/null
+++ b/src_old/types/PLC/units/function-block.ts
@@ -0,0 +1,16 @@
+import { PLCLanguagesShortenedForm } from '@root/shared/data'
+import { z } from 'zod'
+
+import { PLCVariableSchema } from './variable'
+
+const PLCFunctionBlockSchema = z.object({
+  language: z.enum(PLCLanguagesShortenedForm),
+  name: z.string(),
+  variables: z.array(PLCVariableSchema),
+  body: z.string(),
+  documentation: z.string(),
+})
+
+type PLCFunctionBlock = z.infer<typeof PLCFunctionBlockSchema>
+
+export { PLCFunctionBlock, PLCFunctionBlockSchema }
diff --git a/src_old/types/PLC/units/function.ts b/src_old/types/PLC/units/function.ts
new file mode 100644
index 000000000..a8981f3da
--- /dev/null
+++ b/src_old/types/PLC/units/function.ts
@@ -0,0 +1,17 @@
+import { baseTypes, PLCLanguagesShortenedForm } from '@root/shared/data'
+import { z } from 'zod'
+
+import { PLCVariableSchema } from './variable'
+
+const PLCFunctionSchema = z.object({
+  language: z.enum(PLCLanguagesShortenedForm),
+  name: z.string(),
+  returnType: z.enum(baseTypes),
+  variables: z.array(PLCVariableSchema),
+  body: z.string(),
+  documentation: z.string(),
+})
+
+type PLCFunction = z.infer<typeof PLCFunctionSchema>
+
+export { PLCFunction, PLCFunctionSchema }
diff --git a/src_old/types/PLC/units/instance.ts b/src_old/types/PLC/units/instance.ts
new file mode 100644
index 000000000..3dc8f7fad
--- /dev/null
+++ b/src_old/types/PLC/units/instance.ts
@@ -0,0 +1,12 @@
+import { z } from 'zod'
+
+const PLCInstanceSchema = z.object({
+  id: z.string().optional(),
+  name: z.string(), // TODO: This should be homologate. Concept: An unique identifier for the instance object.
+  task: z.string(), // TODO: Implement this validation. This task must be one of the objects in the "tasks" array defined right above.
+  program: z.string(), // TODO: Implement this validation. This program must be one of the user's defined pou of program type.
+})
+
+type PLCInstance = z.infer<typeof PLCInstanceSchema>
+
+export { PLCInstance, PLCInstanceSchema }
diff --git a/src_old/types/PLC/units/library.ts b/src_old/types/PLC/units/library.ts
new file mode 100644
index 000000000..51abe1bdd
--- /dev/null
+++ b/src_old/types/PLC/units/library.ts
@@ -0,0 +1,119 @@
+/**
+ * This file contains schemas to validate the shape of the libraries in the OpenPLC project.
+ * The libraries are used to define the functions and function blocks that will be used in the PLC.
+ * The schemas are defined here using Zod, but isn't being instantiated. This will be done in the Library file.
+ * The following schemas are defined: BaseLibrarySchema, BaseLibraryPouSchema, BaseLibraryVariableSchema.
+ *
+ * The schemas can be extended to add more properties, or modify the existent if needed.
+ * @author: Autonomy Logic
+ */
+import z from 'zod'
+
+/**
+ * This is the basic types common to all the libraries.
+ */
+const baseTypeSchema = z.enum([
+  'BOOL',
+  'SINT',
+  'INT',
+  'DINT',
+  'LINT',
+  'USINT',
+  'UINT',
+  'UDINT',
+  'ULINT',
+  'REAL',
+  'LREAL',
+  'TIME',
+  'DATE',
+  'TOD',
+  'DT',
+  'STRING',
+  'BYTE',
+  'WORD',
+  'DWORD',
+  'LWORD',
+])
+
+const genericTypeSchema = z.object({
+  ANY: z.union([
+    baseTypeSchema,
+    z.literal('ANY_INT'),
+    z.literal('ANY_BIT'),
+    z.literal('ANY_STRING'),
+    z.literal('ANY_REAL'),
+    z.literal('ANY_DATE'),
+    z.literal('ANY_CHAR'),
+    z.literal('ANY_CHARS'),
+    z.literal('ANY_NUM'),
+    z.literal('ANY_INTEGRAL'),
+    z.literal('ANY_SIGNED'),
+    z.literal('ANY_UNSIGNED'),
+    z.literal('ANY_MAGNITUDE'),
+    z.literal('ANY_ELEMENTARY'),
+  ]),
+  ANY_INT: baseTypeSchema.extract(['SINT', 'INT', 'DINT', 'LINT', 'USINT', 'UINT', 'UDINT', 'ULINT']),
+  ANY_BIT: baseTypeSchema.extract(['BOOL', 'BYTE', 'WORD', 'DWORD', 'LWORD']),
+  ANY_STRING: baseTypeSchema.extract(['STRING']),
+  ANY_REAL: baseTypeSchema.extract(['REAL', 'LREAL']),
+  ANY_DATE: baseTypeSchema.extract(['TIME', 'DATE', 'TOD', 'DT']),
+  ANY_CHAR: z.enum(['CHAR', 'WCHAR']),
+  ANY_CHARS: z.union([z.literal('ANY_CHAR'), z.array(z.literal('ANY_STRING'))]), // Should be reviewed
+  ANY_NUM: z.union([z.literal('ANY_INT'), z.literal('ANY_REAL')]),
+  ANY_INTEGRAL: z.union([z.literal('ANY_INT'), z.literal('ANY_BIT')]),
+  ANY_SIGNED: baseTypeSchema.extract(['SINT', 'INT', 'DINT', 'LINT']),
+  ANY_UNSIGNED: baseTypeSchema.extract(['USINT', 'UINT', 'UDINT', 'ULINT']),
+  ANY_MAGNITUDE: z.union([z.literal('ANY_REAL'), z.literal('ANY_INT'), z.literal('TIME')]),
+  ANY_ELEMENTARY: z.union([
+    z.literal('ANY_MAGNITUDE'),
+    z.literal('ANY_BIT'),
+    z.literal('ANY_CHARS'),
+    z.literal('ANY_DATE'),
+  ]),
+})
+
+/**
+ * This schema defines the structure of the variables that are used in the functions and function blocks.
+ */
+const BaseLibraryVariableSchema = z.object({
+  name: z.string(),
+  class: z.enum(['input', 'output', 'local']), // This can be reviewed if needed.
+  type: z.object({
+    definition: z.literal('base-type'),
+    value: baseTypeSchema,
+  }), // In some especial cases, this can be a complex type.
+  location: z.string().optional(), // TODO: Add a regex to validate the location.
+  initialValue: z.lazy((): z.Schema<unknown> => BaseLibraryVariableSchema.pick({ type: true })).optional(), // Define the type as a key in the same object
+  documentation: z.string().optional(),
+})
+
+/**
+ * This schema defines the structure of the functions and function blocks that are used in the PLC.
+ */
+const BaseLibraryPouSchema = z.object({
+  name: z.string(),
+  type: z.enum(['function', 'function-block']), // This can be reviewed if needed.
+  language: z.enum(['il', 'st', 'ld', 'sfc', 'fbd']), // This can be reviewed if needed, possibly only ST will be used.
+  variables: z.array(BaseLibraryVariableSchema),
+  body: z.string(),
+  documentation: z.string(),
+  extensible: z.boolean().optional(),
+})
+type BaseLibraryPou = z.infer<typeof BaseLibraryPouSchema>
+
+/**
+ * This schema defines the structure of the libraries that are used in the PLC.
+ */
+const BaseLibrarySchema = z.object({
+  name: z.string(),
+  author: z.string(),
+  version: z.string(),
+  stPath: z.string(), // Path to the txt file
+  cPath: z.string(), // Path to the C file
+  // dataTypes: z.array(z.string()), // List of data types
+  // variables: z.array(BaseLibraryVariableSchema),
+  pous: z.array(BaseLibraryPouSchema),
+})
+
+export { BaseLibraryPouSchema, BaseLibrarySchema, BaseLibraryVariableSchema, baseTypeSchema, genericTypeSchema }
+export type { BaseLibraryPou }
diff --git a/src_old/types/PLC/units/program.ts b/src_old/types/PLC/units/program.ts
new file mode 100644
index 000000000..1fc20a37e
--- /dev/null
+++ b/src_old/types/PLC/units/program.ts
@@ -0,0 +1,16 @@
+import { PLCLanguagesShortenedForm } from '@root/shared/data'
+import { z } from 'zod'
+
+import { PLCVariableSchema } from './variable'
+
+const PLCProgramSchema = z.object({
+  language: z.enum(PLCLanguagesShortenedForm),
+  name: z.string(),
+  variables: z.array(PLCVariableSchema),
+  body: z.string(),
+  documentation: z.string(),
+})
+
+type PLCProgram = z.infer<typeof PLCProgramSchema>
+
+export { PLCProgram, PLCProgramSchema }
diff --git a/src_old/types/PLC/units/task.ts b/src_old/types/PLC/units/task.ts
new file mode 100644
index 000000000..98ffdac2a
--- /dev/null
+++ b/src_old/types/PLC/units/task.ts
@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const PLCTaskSchema = z.object({
+  id: z.string().optional(),
+  name: z.string(), // TODO: This should be homologate. Concept: An unique identifier for the task object.
+  triggering: z.enum(['CYCLIC', 'INTERRUPT']),
+  interval: z.string(), // TODO: Must have a regex validation for this. Probably a new modal must be created to handle this.
+  priority: z.number(), // TODO: implement this validation. This must be a positive integer from 0 to 100
+})
+
+type PLCTask = z.infer<typeof PLCTaskSchema>
+
+export { PLCTask, PLCTaskSchema }
diff --git a/src_old/types/PLC/units/variable.ts b/src_old/types/PLC/units/variable.ts
new file mode 100644
index 000000000..bab00047c
--- /dev/null
+++ b/src_old/types/PLC/units/variable.ts
@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+import { PLCBaseTypesSchema } from './base-types'
+
+const PLCVariableSchema = z.object({
+  id: z.string().optional(),
+  name: z.string(),
+  class: z.enum(['input', 'output', 'inOut', 'external', 'local', 'temp', 'global']).optional(),
+  type: z.discriminatedUnion('definition', [
+    z.object({
+      definition: z.literal('base-type'),
+      value: PLCBaseTypesSchema,
+    }),
+    z.object({
+      definition: z.literal('user-data-type'),
+      value: z.string(),
+    }),
+    z.object({
+      definition: z.literal('array'),
+      value: z.string(),
+      data: z.object({
+        baseType: z.discriminatedUnion('definition', [
+          z.object({
+            definition: z.literal('base-type'),
+            value: PLCBaseTypesSchema,
+          }),
+          z.object({
+            definition: z.literal('user-data-type'),
+            value: z.string(),
+          }),
+        ]),
+        dimensions: z.array(z.object({ dimension: z.string() })),
+      }),
+    }),
+    z.object({
+      definition: z.literal('derived'),
+      value: z.string(),
+    }),
+  ]),
+  location: z.string(),
+  initialValue: z.string().or(z.null()).optional(),
+  documentation: z.string(),
+  debug: z.boolean(),
+})
+
+type PLCVariable = z.infer<typeof PLCVariableSchema>
+
+const PLCGlobalVariableSchema = PLCVariableSchema.extend({
+  class: z.literal('global'),
+})
+
+type PLCGlobalVariable = z.infer<typeof PLCGlobalVariableSchema>
+type PLCVariableType = z.infer<typeof PLCVariableSchema>['type']
+
+export { PLCGlobalVariable, PLCGlobalVariableSchema, PLCVariable, PLCVariableSchema, PLCVariableType }
diff --git a/src_old/types/PLC/variable-reference.ts b/src_old/types/PLC/variable-reference.ts
new file mode 100644
index 000000000..76788b3bf
--- /dev/null
+++ b/src_old/types/PLC/variable-reference.ts
@@ -0,0 +1,57 @@
+import { PLCVariable } from './open-plc'
+
+/**
+ * Composite key for identifying a variable reference in the system.
+ * Replaces the previous UUID-based identification.
+ */
+export type VariableReference = {
+  pouName: string
+  variableName: string
+  variableType: PLCVariable['type']
+}
+
+/**
+ * Normalized form for lookups and comparisons.
+ * Names are converted to lowercase for case-insensitive matching.
+ */
+export type NormalizedVariableReference = {
+  pouName: string
+  variableName: string
+  variableType: PLCVariable['type']
+}
+
+/**
+ * Scope determines where to search for variables.
+ */
+export type VariableScope = 'local' | 'global'
+
+/**
+ * Extended reference that includes scope information.
+ */
+export type ScopedVariableReference = VariableReference & {
+  scope: VariableScope
+}
+
+/**
+ * Replaces the current LadderBlockConnectedVariables type.
+ * Removes handleTableId (ID-based) and uses name+type instead.
+ */
+export type BlockConnectedVariable = {
+  handleName: string
+  type: 'input' | 'output'
+  variableRef: VariableReference | null
+  variable: PLCVariable | undefined
+}
+
+export type BlockConnectedVariables = BlockConnectedVariable[]
+
+/**
+ * Replaces the current variable field in node data.
+ * Used for contacts, coils, and block instances.
+ */
+export type ElementVariableAssociation = {
+  ref: VariableReference
+  variable: PLCVariable | undefined
+  isValid: boolean
+  validationError?: string
+}
diff --git a/src_old/types/PLC/xml-data/codesys/base-diagram.ts b/src_old/types/PLC/xml-data/codesys/base-diagram.ts
new file mode 100644
index 000000000..5d9d0fa60
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/base-diagram.ts
@@ -0,0 +1,71 @@
+import { formatDate } from '@root/utils'
+import { z } from 'zod'
+
+import { dataTypeSchema } from './data-types/data-types-diagram'
+import { pousSchema } from './pous/pous-diagram'
+import { taskXMLSchema } from './task/task-diagram'
+import { variableXMLSchema } from './variable/variable-diagram'
+
+const baseXmlSchema = z.object({
+  project: z.object({
+    '@xmlns': z.string().default('http://www.plcopen.org/xml/tc6_0200'),
+
+    fileHeader: z.object({
+      '@companyName': z.string().default('Unknown'),
+      '@productName': z.string().default('Unnamed'),
+      '@productVersion': z.string().default('1'),
+      '@creationDateTime': z.string().default(formatDate(new Date())),
+    }),
+
+    contentHeader: z.object({
+      '@name': z.string().default('Unnamed'),
+      '@modificationDateTime': z.string().default(formatDate(new Date())),
+      coordinateInfo: z.object({
+        fbd: z.object({
+          scaling: z.object({
+            '@x': z.string().default('16'),
+            '@y': z.string().default('16'),
+          }),
+        }),
+        ld: z.object({
+          scaling: z.object({
+            '@x': z.string().default('16'),
+            '@y': z.string().default('16'),
+          }),
+        }),
+        sfc: z.object({
+          scaling: z.object({
+            '@x': z.string().default('16'),
+            '@y': z.string().default('16'),
+          }),
+        }),
+      }),
+    }),
+
+    types: z.object({
+      dataTypes: dataTypeSchema,
+      pous: pousSchema,
+    }),
+
+    instances: z.object({
+      configurations: z.object({
+        configuration: z.object({
+          '@name': z.string().default('Config0'),
+          resource: z.object({
+            '@name': z.string().default('Res0'),
+            task: z.array(taskXMLSchema),
+          }),
+          globalVars: z
+            .object({
+              variable: z.array(variableXMLSchema).optional(),
+            })
+            .optional(),
+        }),
+      }),
+    }),
+  }),
+})
+type BaseXml = z.infer<typeof baseXmlSchema>
+
+export { baseXmlSchema }
+export type { BaseXml }
diff --git a/src_old/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts b/src_old/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts
new file mode 100644
index 000000000..9d6b208f3
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/data-types/array/data-type-array.ts
@@ -0,0 +1,14 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const dataTypeArraySchema = z.object({
+  dimension: z.array(
+    z.object({
+      '@lower': z.string(),
+      '@upper': z.string(),
+    }),
+  ),
+  baseType: z.object(baseTypes.reduce((acc, type) => ({ ...acc, [type]: z.string().optional() }), {})),
+})
+
+export { dataTypeArraySchema }
diff --git a/src_old/types/PLC/xml-data/codesys/data-types/data-types-diagram.ts b/src_old/types/PLC/xml-data/codesys/data-types/data-types-diagram.ts
new file mode 100644
index 000000000..398079196
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/data-types/data-types-diagram.ts
@@ -0,0 +1,27 @@
+import { z } from 'zod'
+
+import { dataTypeArraySchema } from './array/data-type-array'
+import { dataTypeEnumSchema } from './enum/data-type-enum'
+import { dataTypeStructSchema } from './struct/data-type-struct'
+
+const dataTypeSchema = z.object({
+  dataType: z.array(
+    z.object({
+      '@name': z.string(),
+      baseType: z.object({
+        array: dataTypeArraySchema.optional(),
+        enum: dataTypeEnumSchema.optional(),
+        struct: dataTypeStructSchema.optional(),
+      }),
+      initialValue: z
+        .object({
+          simpleValue: z.object({
+            '@value': z.string(),
+          }),
+        })
+        .optional(),
+    }),
+  ),
+})
+
+export { dataTypeSchema }
diff --git a/src_old/types/PLC/xml-data/codesys/data-types/enum/data-type-enum.ts b/src_old/types/PLC/xml-data/codesys/data-types/enum/data-type-enum.ts
new file mode 100644
index 000000000..b8013dbb0
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/data-types/enum/data-type-enum.ts
@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const dataTypeEnumSchema = z.object({
+  values: z.object({
+    value: z.array(
+      z.object({
+        '@name': z.string(),
+      }),
+    ),
+  }),
+})
+
+export { dataTypeEnumSchema }
diff --git a/src_old/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts b/src_old/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts
new file mode 100644
index 000000000..aa813f0f8
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/data-types/struct/data-type-struct.ts
@@ -0,0 +1,22 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const dataTypeStructSchema = z.object({
+  variable: z.array(
+    z.object({
+      '@name': z.string(),
+      type: z
+        .object(baseTypes.reduce((acc, type) => Object.assign(acc, { [type]: z.string().optional() }), {}))
+        .optional(),
+      initialValue: z
+        .object({
+          simpleValue: z.object({
+            '@value': z.string(),
+          }),
+        })
+        .optional(),
+    }),
+  ),
+})
+
+export { dataTypeStructSchema }
diff --git a/src_old/types/PLC/xml-data/codesys/index.ts b/src_old/types/PLC/xml-data/codesys/index.ts
new file mode 100644
index 000000000..0c797a53a
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/index.ts
@@ -0,0 +1,3 @@
+export * from './base-diagram'
+export * from './pous/languages/il-diagram'
+export * from './pous/languages/ladder-diagram'
diff --git a/src_old/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts b/src_old/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts
new file mode 100644
index 000000000..f286b9454
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/pous/interface/interface-diagram.ts
@@ -0,0 +1,58 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+import { variableXMLSchema } from '../../variable/variable-diagram'
+
+const interfaceXMLSchema = z.object({
+  returnType: z
+    .object(
+      Object.fromEntries(
+        baseTypes.map((type) => [
+          type,
+          z
+            .union([
+              z.string(),
+              z.object({
+                '@name': z.string(),
+              }),
+            ])
+            .optional(),
+        ]),
+      ),
+    )
+    .optional(),
+  inputVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  outputVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  inOutVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  externalVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  localVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  tempVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+})
+type InterfaceXML = z.infer<typeof interfaceXMLSchema>
+
+export { interfaceXMLSchema }
+export type { InterfaceXML }
diff --git a/src_old/types/PLC/xml-data/codesys/pous/languages/fbd-diagram.ts b/src_old/types/PLC/xml-data/codesys/pous/languages/fbd-diagram.ts
new file mode 100644
index 000000000..c86df8434
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/pous/languages/fbd-diagram.ts
@@ -0,0 +1,239 @@
+/**
+ * ----------------------------------------------------------------
+ * This file is part of OpenPLC documentation.
+ * Here is defined the shape of the mapped data structure for the Fbd Diagram language.
+ * ----------------------------------------------------------------
+ */
+
+import { z } from 'zod'
+
+/**
+ * blockSchema is a zod schema for the block element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the block.
+ * - @typeName: a string that represents the type name of the block.
+ * - @instanceName: a string that represents the instance name of the block.
+ * - @width: a number that represents the width of the block.
+ * - @height: a number that represents the height of the block.
+ * - position: an object that represents the position of the block. It includes x and y coordinates.
+ * - inVariable: an array of objects that represent the input variables of the block. Each object includes a @formalParameter and a connectionPointIn.
+ * - outVariable: an array of objects that represent the output variables of the block. Each object includes a formalParameter and a connectionPointOut'.
+ * Each connectionPointIn and connectionPointOut' includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection..
+ */
+const blockSchema = z.object({
+  '@localId': z.string(),
+  '@typeName': z.string(),
+  '@instanceName': z.string().optional(),
+  '@executionOrderId': z.number().optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  inputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointIn: z.object({
+          connection: z.array(
+            z.object({
+              '@refLocalId': z.string().optional(), // was just @localId, but it seems to be a reference to other element @localId.
+              '@formalParameter': z.string().optional(),
+            }),
+          ),
+        }),
+      }),
+    ),
+  }),
+  /**
+   * 'inOutVariable' is an array of objects that represent the inOut variables of the block.
+   * @wip This is a guess, we need to confirm this.
+   */
+  inOutVariables: z.string(),
+  outputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointOut: z.object({
+          expression: z.string().optional(),
+        }),
+      }),
+    ),
+  }),
+})
+type BlockFbdXML = z.infer<typeof blockSchema>
+
+/**
+ * inSchema is a zod schema for the input variable element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the input variable.
+ * - @width: a number that represents the width of the input variable.
+ * - @height: a number that represents the height of the input variable.
+ * - @negated: a boolean that represents if the input variable is negated.
+ * - position: an object that represents the position of the input variable. It includes x and y coordinates.
+ * - connectionPointOut': an object that represents the connection point out of the input variable. It includes a relPosition object with x and y coordinates.
+ * - expression: a string that represents the expression of the input variable.
+ */
+const inVariableSchema = z.object({
+  '@localId': z.string(),
+  '@executionOrderId': z.number(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.string().optional(),
+  expression: z.string(),
+})
+type InVariableFbdXML = z.infer<typeof inVariableSchema>
+
+/**
+ * outSchema is a zod schema for the output variable element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the output variable.
+ * - @width: a number that represents the width of the output variable.
+ * - @height: a number that represents the height of the output variable.
+ * - @negated: a boolean that represents if the output variable is negated.
+ * - position: an object that represents the position of the output variable. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the output variable. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - expression: a string that represents the expression of the output variable.
+ */
+const outVariableSchema = z.object({
+  '@localId': z.string(),
+  '@executionOrderId': z.number(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+      }),
+    ),
+  }),
+  expression: z.string(),
+})
+type OutVariableFbdXML = z.infer<typeof outVariableSchema>
+
+/**
+ * connectorSchema is a zod schema for the connector element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @name: a string that represents the name of the connector.
+ * - @localId: a string that represents the local identifier of the connector.
+ * - @width: a number that represents the width of the connector.
+ * - @height: a number that represents the height of the connector.
+ * - position: an object that represents the position of the connector. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the connector. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * Each connection also includes a @formalParameter.
+ */
+const connectorSchema = z.object({
+  '@name': z.string(),
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+      }),
+    ),
+  }),
+})
+type ConnectorFbdXML = z.infer<typeof connectorSchema>
+
+/**
+ * continuationSchema is a zod schema for the continuation element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @name: a string that represents the name of the continuation.
+ * - @localId: a string that represents the local identifier of the continuation.
+ * - @width: a number that represents the width of the continuation.
+ * - @height: a number that represents the height of the continuation.
+ * - position: an object that represents the position of the continuation. It includes x and y coordinates.
+ * - connectionPointOut: an object that represents the connection point out of the continuation. It includes a relPosition object with x and y coordinates.
+ */
+const continuationSchema = z.object({
+  '@name': z.string(),
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+})
+type ContinuationFbdXML = z.infer<typeof continuationSchema>
+
+const commentSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  content: z.object({
+    xhtml: z.object({
+      '@xmlns': z.string().default('http://www.w3.org/1999/xhtml'),
+      $: z.string(),
+    }),
+  }),
+})
+type CommentFbdXML = z.infer<typeof commentSchema>
+
+/**
+ * Fbd Diagram XML data types.
+ */
+const fbdXMLSchema = z.object({
+  block: z.array(blockSchema),
+  inVariable: z.array(inVariableSchema),
+  outVariable: z.array(outVariableSchema),
+  connector: z.array(connectorSchema),
+  continuation: z.array(continuationSchema),
+  comment: z.array(commentSchema),
+})
+type FbdXML = z.infer<typeof fbdXMLSchema>
+
+export {
+  blockSchema,
+  commentSchema,
+  connectorSchema,
+  continuationSchema,
+  fbdXMLSchema,
+  inVariableSchema,
+  outVariableSchema,
+}
+export type {
+  BlockFbdXML,
+  CommentFbdXML,
+  ConnectorFbdXML,
+  ContinuationFbdXML,
+  FbdXML,
+  InVariableFbdXML,
+  OutVariableFbdXML,
+}
diff --git a/src_old/types/PLC/xml-data/codesys/pous/languages/il-diagram.ts b/src_old/types/PLC/xml-data/codesys/pous/languages/il-diagram.ts
new file mode 100644
index 000000000..f1e6f49d1
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/pous/languages/il-diagram.ts
@@ -0,0 +1,12 @@
+import { z } from 'zod'
+
+const ilXMLSchema = z.object({
+  xhtml: z.object({
+    '@xmlns': z.string().default('http://www.w3.org/1999/xhtml'),
+    $: z.string(),
+  }),
+})
+type IlXML = z.infer<typeof ilXMLSchema>
+
+export { ilXMLSchema }
+export type { IlXML }
diff --git a/src_old/types/PLC/xml-data/codesys/pous/languages/ladder-diagram.ts b/src_old/types/PLC/xml-data/codesys/pous/languages/ladder-diagram.ts
new file mode 100644
index 000000000..5bedba43d
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/pous/languages/ladder-diagram.ts
@@ -0,0 +1,284 @@
+/**
+ * ----------------------------------------------------------------
+ * This file is part of OpenPLC documentation.
+ * Here is defined the shape of the mapped data structure for the Ladder Diagram language.
+ * ----------------------------------------------------------------
+ */
+
+import { z } from 'zod'
+
+/**
+ * leftPowerRailSchema is a zod schema for the left power rail of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the left power rail.
+ * - @width: a number that represents the width of the left power rail.
+ * - @height: a number that represents the height of the left power rail.
+ * - position: an object that represents the global position of the left power rail. It includes x and y coordinates.
+ * - connectionPointOut: an object that represents the connection point out of the left power rail. It includes a relPosition object with x and y coordinates.
+ */
+const leftPowerRailSchema = z.object({
+  '@localId': z.string(), //@localId
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.object({
+    '@formalParameter': z.string(),
+  }),
+})
+type LeftPowerRailLadderXML = z.infer<typeof leftPowerRailSchema>
+
+/**
+ * rightPowerRailSchema is a zod schema for the right power rail of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the right power rail.
+ * - @width: a number that represents the width of the right power rail.
+ * - @height: a number that represents the height of the right power rail.
+ * - position: an object that represents the global position of the right power rail. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the right power rail. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId (reference to other block) and an array of 'positions'. Each position is an object that includes x and y coordinates representing the path of the connection.
+ */
+const rightPowerRailSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  // This is our handles.
+  connectionPointIn: z.string(),
+})
+type RightPowerRailLadderXML = z.infer<typeof rightPowerRailSchema>
+
+/**
+ * blockSchema is a zod schema for the block element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the block.
+ * - @typeName: a string that represents the type name of the block.
+ * - @instanceName: a string that represents the instance name of the block.
+ * - @width: a number that represents the width of the block.
+ * - @height: a number that represents the height of the block.
+ * - position: an object that represents the position of the block. It includes x and y coordinates.
+ * - inVariable: an array of objects that represent the input variables of the block. Each object includes a @formalParameter and a connectionPointIn.
+ * - outVariable: an array of objects that represent the output variables of the block. Each object includes a formalParameter and a connectionPointOut'.
+ * Each connectionPointIn and connectionPointOut' includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection..
+ */
+const blockSchema = z.object({
+  '@localId': z.string(),
+  '@typeName': z.string(),
+  '@instanceName': z.string().optional(),
+  '@executionOrderId': z.number().optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  inputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointIn: z.object({
+          connection: z.array(
+            z.object({
+              '@refLocalId': z.string(), // was just @localId, but it seems to be a reference to other element @localId.
+            }),
+          ),
+        }),
+      }),
+    ),
+  }),
+  /**
+   * 'inOutVariable' is an array of objects that represent the inOut variables of the block.
+   * @wip This is a guess, we need to confirm this.
+   */
+  inOutVariables: z.string(),
+  outputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointOut: z.object({
+          expression: z.string().optional(),
+        }),
+      }),
+    ),
+  }),
+})
+type BlockLadderXML = z.infer<typeof blockSchema>
+
+/**
+ * contactSchema is a zod schema for the contact element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the contact.
+ * - @negated: a boolean that represents if the contact is negated.
+ * - @edge: a string that represents the edges of the contact (rising, falling, or empty).
+ * - @width: a number that represents the width of the contact.
+ * - @height: a number that represents the height of the contact.
+ * - position: an object that represents the position of the contact. It includes x and y coordinates.
+ * - variable: a string that represents the variable of the contact.
+ * - connectionPointIn': an object that represents the connection point in of the contact. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - connectionPointOut': an object that represents the connection point out of the contact. It includes a relPosition object with x and y coordinates.
+ */
+const contactSchema = z.object({
+  '@localId': z.string(),
+  '@negated': z.boolean(),
+  '@edge': z.enum(['rising', 'falling']).optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@executionOrderId': z.number().optional(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+      }),
+    ),
+  }),
+  connectionPointOut: z.string(),
+  variable: z.string(),
+})
+type ContactLadderXML = z.infer<typeof contactSchema>
+
+/**
+ * coilSchema is a zod schema for the coil element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the coil.
+ * - @negated: a boolean that represents if the coil is negated.
+ * - @edge: a string that represents the edges of the coil (rising, falling, or empty).
+ * - @storage: a string that represents the storage of the coil (set, reset, or empty).
+ * - @width: a number that represents the width of the coil.
+ * - @height: a number that represents the height of the coil.
+ * - position: an object that represents the position of the coil. It includes x and y coordinates.
+ * - variable: a string that represents the variable of the coil.
+ * - connectionPointIn: an object that represents the connection point in of the coil. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - connectionPointOut: an object that represents the connection point out of the coil. It includes a relPosition object with x and y coordinates.
+ */
+const coilSchema = z.object({
+  '@localId': z.string(),
+  '@negated': z.boolean(),
+  '@edge': z.enum(['rising', 'falling']).optional(),
+  '@storage': z.enum(['set', 'reset']).optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@executionOrderId': z.number().optional(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+      }),
+    ),
+  }),
+  connectionPointOut: z.string(),
+  variable: z.string(),
+})
+type CoilLadderXML = z.infer<typeof coilSchema>
+
+/**
+ * inSchema is a zod schema for the input variable element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the input variable.
+ * - @width: a number that represents the width of the input variable.
+ * - @height: a number that represents the height of the input variable.
+ * - @negated: a boolean that represents if the input variable is negated.
+ * - position: an object that represents the position of the input variable. It includes x and y coordinates.
+ * - connectionPointOut': an object that represents the connection point out of the input variable. It includes a relPosition object with x and y coordinates.
+ * - expression: a string that represents the expression of the input variable.
+ */
+const inVariableSchema = z.object({
+  '@localId': z.string(),
+  '@executionOrderId': z.number(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.string().optional(),
+  expression: z.string(),
+})
+type InVariableLadderXML = z.infer<typeof inVariableSchema>
+
+/**
+ * outSchema is a zod schema for the output variable element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the output variable.
+ * - @width: a number that represents the width of the output variable.
+ * - @height: a number that represents the height of the output variable.
+ * - @negated: a boolean that represents if the output variable is negated.
+ * - position: an object that represents the position of the output variable. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the output variable. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - expression: a string that represents the expression of the output variable.
+ */
+const outVariableSchema = z.object({
+  '@localId': z.string(),
+  '@executionOrderId': z.number(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+      }),
+    ),
+  }),
+  expression: z.string(),
+})
+type OutVariableLadderXML = z.infer<typeof outVariableSchema>
+
+/**
+ * Ladder Diagram XML data types.
+ */
+const ladderXMLSchema = z.object({
+  leftPowerRail: z.array(leftPowerRailSchema),
+  rightPowerRail: z.array(rightPowerRailSchema),
+  block: z.array(blockSchema),
+  contact: z.array(contactSchema),
+  coil: z.array(coilSchema),
+  inVariable: z.array(inVariableSchema),
+  outVariable: z.array(outVariableSchema),
+})
+type LadderXML = z.infer<typeof ladderXMLSchema>
+
+export {
+  blockSchema,
+  coilSchema,
+  contactSchema,
+  inVariableSchema,
+  ladderXMLSchema,
+  leftPowerRailSchema,
+  outVariableSchema,
+  rightPowerRailSchema,
+}
+export type {
+  BlockLadderXML,
+  CoilLadderXML,
+  ContactLadderXML,
+  InVariableLadderXML,
+  LadderXML,
+  LeftPowerRailLadderXML,
+  OutVariableLadderXML,
+  RightPowerRailLadderXML,
+}
diff --git a/src_old/types/PLC/xml-data/codesys/pous/languages/st-diagram.ts b/src_old/types/PLC/xml-data/codesys/pous/languages/st-diagram.ts
new file mode 100644
index 000000000..58fb99896
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/pous/languages/st-diagram.ts
@@ -0,0 +1,12 @@
+import { z } from 'zod'
+
+const stXMLSchema = z.object({
+  xhtml: z.object({
+    '@xmlns': z.string().default('http://www.w3.org/1999/xhtml'),
+    $: z.string(),
+  }),
+})
+type StXML = z.infer<typeof stXMLSchema>
+
+export { stXMLSchema }
+export type { StXML }
diff --git a/src_old/types/PLC/xml-data/codesys/pous/pous-diagram.ts b/src_old/types/PLC/xml-data/codesys/pous/pous-diagram.ts
new file mode 100644
index 000000000..6f587e7ce
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/pous/pous-diagram.ts
@@ -0,0 +1,28 @@
+import { z } from 'zod'
+
+import { interfaceXMLSchema } from './interface/interface-diagram'
+import { fbdXMLSchema } from './languages/fbd-diagram'
+import { ilXMLSchema } from './languages/il-diagram'
+import { ladderXMLSchema } from './languages/ladder-diagram'
+import { stXMLSchema } from './languages/st-diagram'
+
+const pousSchema = z.object({
+  pou: z.array(
+    z.object({
+      '@name': z.string(),
+      '@pouType': z.enum(['program', 'function', 'functionBlock']),
+      interface: interfaceXMLSchema,
+      body: z.object({
+        IL: ilXMLSchema.optional(),
+        ST: stXMLSchema.optional(),
+        LD: ladderXMLSchema.optional(),
+        FBD: fbdXMLSchema.optional(),
+        SFC: z.string().optional(),
+      }),
+    }),
+  ),
+})
+type PousXML = z.infer<typeof pousSchema>
+
+export { pousSchema }
+export type { PousXML }
diff --git a/src_old/types/PLC/xml-data/codesys/task/task-diagram.ts b/src_old/types/PLC/xml-data/codesys/task/task-diagram.ts
new file mode 100644
index 000000000..8d34e07e2
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/task/task-diagram.ts
@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+const pouInstanceSchema = z.object({
+  '@name': z.string(),
+  '@typeName': z.string(),
+})
+type PouInstance = z.infer<typeof pouInstanceSchema>
+
+const taskXMLSchema = z.object({
+  '@name': z.string(),
+  '@priority': z.string(),
+  '@interval': z.string().nullable(),
+  '@single': z.string().nullable(),
+  pouInstance: z.array(
+    z.object({
+      '@name': z.string(),
+      '@typeName': z.string(),
+    }),
+  ),
+})
+type TaskXML = z.infer<typeof taskXMLSchema>
+
+export { pouInstanceSchema, taskXMLSchema }
+export type { PouInstance, TaskXML }
diff --git a/src_old/types/PLC/xml-data/codesys/variable/variable-diagram.ts b/src_old/types/PLC/xml-data/codesys/variable/variable-diagram.ts
new file mode 100644
index 000000000..7c48760cd
--- /dev/null
+++ b/src_old/types/PLC/xml-data/codesys/variable/variable-diagram.ts
@@ -0,0 +1,27 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const variableXMLSchema = z.object({
+  '@name': z.string(),
+  '@address': z.string().optional(),
+  type: z.object(baseTypes.reduce((acc, type) => ({ ...acc, [type]: z.string().optional() }), {})).optional(),
+  initialValue: z
+    .object({
+      simpleValue: z.object({
+        '@value': z.string(),
+      }),
+    })
+    .or(z.null())
+    .optional(),
+  documentation: z
+    .object({
+      'xhtml:p': z.object({
+        $: z.string(),
+      }),
+    })
+    .optional(),
+})
+type VariableXML = z.infer<typeof variableXMLSchema>
+
+export { variableXMLSchema }
+export type { VariableXML }
diff --git a/src_old/types/PLC/xml-data/old-editor/base-diagram.ts b/src_old/types/PLC/xml-data/old-editor/base-diagram.ts
new file mode 100644
index 000000000..fb495f516
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/base-diagram.ts
@@ -0,0 +1,78 @@
+import { formatDate } from '@root/utils'
+import { z } from 'zod'
+
+import { dataTypeSchema } from './data-types/data-types-diagram'
+import { pousSchema } from './pous/pous-diagram'
+import { taskXMLSchema } from './task/task-diagram'
+import { variableXMLSchema } from './variable/variable-diagram'
+
+const baseXmlSchema = z.object({
+  project: z.object({
+    '@xmlns': z.string().default('http://www.plcopen.org/xml/tc6_0201'),
+    '@xmlns:xsd': z.string().default('http://www.w3.org/2001/XMLSchema-instance'),
+    '@xmlns:xhtml': z.string().default('http://www.w3.org/1999/xhtml'),
+    '@xmlns:ns1': z.string().default('http://www.plcopen.org/xml/tc6_0201'),
+    '@xsi:schemaLocation': z
+      .string()
+      .default('http://www.plcopen.org/xml/tc6_0200 http://www.plcopen.org/xml/tc6_0200')
+      .optional(),
+
+    fileHeader: z.object({
+      '@companyName': z.string().default('Unknown'),
+      '@productName': z.string().default('Unnamed'),
+      '@productVersion': z.string().default('1'),
+      '@creationDateTime': z.string().default(formatDate(new Date())),
+    }),
+
+    contentHeader: z.object({
+      '@name': z.string().default('Unnamed'),
+      '@modificationDateTime': z.string().default(formatDate(new Date())),
+      coordinateInfo: z.object({
+        fbd: z.object({
+          scaling: z.object({
+            '@x': z.string().default('10'),
+            '@y': z.string().default('10'),
+          }),
+        }),
+        ld: z.object({
+          scaling: z.object({
+            '@x': z.string().default('10'),
+            '@y': z.string().default('10'),
+          }),
+        }),
+        sfc: z.object({
+          scaling: z.object({
+            '@x': z.string().default('10'),
+            '@y': z.string().default('10'),
+          }),
+        }),
+      }),
+    }),
+
+    types: z.object({
+      dataTypes: dataTypeSchema,
+      pous: pousSchema,
+    }),
+
+    instances: z.object({
+      configurations: z.object({
+        configuration: z.object({
+          '@name': z.string().default('Config0'),
+          resource: z.object({
+            '@name': z.string().default('Res0'),
+            task: z.array(taskXMLSchema),
+          }),
+          globalVars: z
+            .object({
+              variable: z.array(variableXMLSchema).optional(),
+            })
+            .optional(),
+        }),
+      }),
+    }),
+  }),
+})
+type BaseXml = z.infer<typeof baseXmlSchema>
+
+export { baseXmlSchema }
+export type { BaseXml }
diff --git a/src_old/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts b/src_old/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts
new file mode 100644
index 000000000..9d6b208f3
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/data-types/array/data-type-array.ts
@@ -0,0 +1,14 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const dataTypeArraySchema = z.object({
+  dimension: z.array(
+    z.object({
+      '@lower': z.string(),
+      '@upper': z.string(),
+    }),
+  ),
+  baseType: z.object(baseTypes.reduce((acc, type) => ({ ...acc, [type]: z.string().optional() }), {})),
+})
+
+export { dataTypeArraySchema }
diff --git a/src_old/types/PLC/xml-data/old-editor/data-types/data-types-diagram.ts b/src_old/types/PLC/xml-data/old-editor/data-types/data-types-diagram.ts
new file mode 100644
index 000000000..398079196
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/data-types/data-types-diagram.ts
@@ -0,0 +1,27 @@
+import { z } from 'zod'
+
+import { dataTypeArraySchema } from './array/data-type-array'
+import { dataTypeEnumSchema } from './enum/data-type-enum'
+import { dataTypeStructSchema } from './struct/data-type-struct'
+
+const dataTypeSchema = z.object({
+  dataType: z.array(
+    z.object({
+      '@name': z.string(),
+      baseType: z.object({
+        array: dataTypeArraySchema.optional(),
+        enum: dataTypeEnumSchema.optional(),
+        struct: dataTypeStructSchema.optional(),
+      }),
+      initialValue: z
+        .object({
+          simpleValue: z.object({
+            '@value': z.string(),
+          }),
+        })
+        .optional(),
+    }),
+  ),
+})
+
+export { dataTypeSchema }
diff --git a/src_old/types/PLC/xml-data/old-editor/data-types/enum/data-type-enum.ts b/src_old/types/PLC/xml-data/old-editor/data-types/enum/data-type-enum.ts
new file mode 100644
index 000000000..b8013dbb0
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/data-types/enum/data-type-enum.ts
@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const dataTypeEnumSchema = z.object({
+  values: z.object({
+    value: z.array(
+      z.object({
+        '@name': z.string(),
+      }),
+    ),
+  }),
+})
+
+export { dataTypeEnumSchema }
diff --git a/src_old/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts b/src_old/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts
new file mode 100644
index 000000000..aa813f0f8
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/data-types/struct/data-type-struct.ts
@@ -0,0 +1,22 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const dataTypeStructSchema = z.object({
+  variable: z.array(
+    z.object({
+      '@name': z.string(),
+      type: z
+        .object(baseTypes.reduce((acc, type) => Object.assign(acc, { [type]: z.string().optional() }), {}))
+        .optional(),
+      initialValue: z
+        .object({
+          simpleValue: z.object({
+            '@value': z.string(),
+          }),
+        })
+        .optional(),
+    }),
+  ),
+})
+
+export { dataTypeStructSchema }
diff --git a/src_old/types/PLC/xml-data/old-editor/index.ts b/src_old/types/PLC/xml-data/old-editor/index.ts
new file mode 100644
index 000000000..0c797a53a
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/index.ts
@@ -0,0 +1,3 @@
+export * from './base-diagram'
+export * from './pous/languages/il-diagram'
+export * from './pous/languages/ladder-diagram'
diff --git a/src_old/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts b/src_old/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts
new file mode 100644
index 000000000..f286b9454
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/pous/interface/interface-diagram.ts
@@ -0,0 +1,58 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+import { variableXMLSchema } from '../../variable/variable-diagram'
+
+const interfaceXMLSchema = z.object({
+  returnType: z
+    .object(
+      Object.fromEntries(
+        baseTypes.map((type) => [
+          type,
+          z
+            .union([
+              z.string(),
+              z.object({
+                '@name': z.string(),
+              }),
+            ])
+            .optional(),
+        ]),
+      ),
+    )
+    .optional(),
+  inputVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  outputVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  inOutVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  externalVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  localVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+  tempVars: z
+    .object({
+      variable: z.array(variableXMLSchema).optional(),
+    })
+    .optional(),
+})
+type InterfaceXML = z.infer<typeof interfaceXMLSchema>
+
+export { interfaceXMLSchema }
+export type { InterfaceXML }
diff --git a/src_old/types/PLC/xml-data/old-editor/pous/languages/fbd-diagram.ts b/src_old/types/PLC/xml-data/old-editor/pous/languages/fbd-diagram.ts
new file mode 100644
index 000000000..d02d6702f
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/pous/languages/fbd-diagram.ts
@@ -0,0 +1,327 @@
+/**
+ * ----------------------------------------------------------------
+ * This file is part of OpenPLC documentation.
+ * Here is defined the shape of the mapped data structure for the Fbd Diagram language.
+ * ----------------------------------------------------------------
+ */
+
+import { z } from 'zod'
+
+/**
+ * blockSchema is a zod schema for the block element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the block.
+ * - @typeName: a string that represents the type name of the block.
+ * - @instanceName: a string that represents the instance name of the block.
+ * - @width: a number that represents the width of the block.
+ * - @height: a number that represents the height of the block.
+ * - position: an object that represents the position of the block. It includes x and y coordinates.
+ * - inVariable: an array of objects that represent the input variables of the block. Each object includes a @formalParameter and a connectionPointIn.
+ * - outVariable: an array of objects that represent the output variables of the block. Each object includes a formalParameter and a connectionPointOut'.
+ * Each connectionPointIn and connectionPointOut' includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection..
+ */
+const blockSchema = z.object({
+  '@localId': z.string(),
+  '@typeName': z.string(),
+  '@instanceName': z.string().optional(),
+  '@executionOrderId': z.number().optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  inputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointIn: z.object({
+          relPosition: z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+          connection: z.array(
+            z.object({
+              '@refLocalId': z.string(), // was just @localId, but it seems to be a reference to other element @localId.
+              '@formalParameter': z.string().optional(),
+              position: z.array(
+                z.object({
+                  '@x': z.number(),
+                  '@y': z.number(),
+                }),
+              ),
+            }),
+          ),
+        }),
+      }),
+    ),
+  }),
+  /**
+   * 'inOutVariable' is an array of objects that represent the inOut variables of the block.
+   * @wip This is a guess, we need to confirm this.
+   */
+  inOutVariables: z.string(),
+  outputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointOut: z.object({
+          relPosition: z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        }),
+      }),
+    ),
+  }),
+})
+type BlockFbdXML = z.infer<typeof blockSchema>
+
+/**
+ * inSchema is a zod schema for the input variable element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the input variable.
+ * - @width: a number that represents the width of the input variable.
+ * - @height: a number that represents the height of the input variable.
+ * - @negated: a boolean that represents if the input variable is negated.
+ * - position: an object that represents the position of the input variable. It includes x and y coordinates.
+ * - connectionPointOut': an object that represents the connection point out of the input variable. It includes a relPosition object with x and y coordinates.
+ * - expression: a string that represents the expression of the input variable.
+ */
+const inVariableSchema = z.object({
+  '@localId': z.string(),
+  '@executionOrderId': z.number(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+  expression: z.string(),
+})
+type InVariableFbdXML = z.infer<typeof inVariableSchema>
+
+/**
+ * inOutSchema is a zod schema for the inOut variable element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the inOut variable.
+ * - @width: a number that represents the width of the inOut variable.
+ * - @height: a number that represents the height of the inOut variable.
+ * - @negatedOut: a boolean that represents if the output of the inOut variable is negated.
+ * - @negatedIn: a boolean that represents if the input of the inOut variable is negated.
+ * - position: an object that represents the position of the inOut variable. It includes x and y coordinates.
+ * - connectionPointIn': an object that represents the connection point in of the inOut variable. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - connectionPointOut: an object that represents the connection point out of the inOut variable. It includes a relPosition object with x and y coordinates.
+ * - expression: a string that represents the expression of the inOut variable.
+ */
+const inOutVariableSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negatedOut': z.boolean(),
+  '@negatedIn': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+  expression: z.string(),
+})
+type InOutVariableFbdXML = z.infer<typeof inOutVariableSchema>
+
+/**
+ * outSchema is a zod schema for the output variable element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the output variable.
+ * - @width: a number that represents the width of the output variable.
+ * - @height: a number that represents the height of the output variable.
+ * - @negated: a boolean that represents if the output variable is negated.
+ * - position: an object that represents the position of the output variable. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the output variable. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - expression: a string that represents the expression of the output variable.
+ */
+const outVariableSchema = z.object({
+  '@localId': z.string(),
+  '@executionOrderId': z.number(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+  expression: z.string(),
+})
+type OutVariableFbdXML = z.infer<typeof outVariableSchema>
+
+/**
+ * connectorSchema is a zod schema for the connector element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @name: a string that represents the name of the connector.
+ * - @localId: a string that represents the local identifier of the connector.
+ * - @width: a number that represents the width of the connector.
+ * - @height: a number that represents the height of the connector.
+ * - position: an object that represents the position of the connector. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the connector. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * Each connection also includes a @formalParameter.
+ */
+const connectorSchema = z.object({
+  '@name': z.string(),
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+})
+type ConnectorFbdXML = z.infer<typeof connectorSchema>
+
+/**
+ * continuationSchema is a zod schema for the continuation element of the Fbd Diagram.
+ * It includes the following properties:
+ * - @name: a string that represents the name of the continuation.
+ * - @localId: a string that represents the local identifier of the continuation.
+ * - @width: a number that represents the width of the continuation.
+ * - @height: a number that represents the height of the continuation.
+ * - position: an object that represents the position of the continuation. It includes x and y coordinates.
+ * - connectionPointOut: an object that represents the connection point out of the continuation. It includes a relPosition object with x and y coordinates.
+ */
+const continuationSchema = z.object({
+  '@name': z.string(),
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+})
+type ContinuationFbdXML = z.infer<typeof continuationSchema>
+
+const commentSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  content: z.object({
+    'xhtml:p': z.object({
+      $: z.string(),
+    }),
+  }),
+})
+type CommentFbdXML = z.infer<typeof commentSchema>
+
+/**
+ * Fbd Diagram XML data types.
+ */
+const fbdXMLSchema = z.object({
+  block: z.array(blockSchema),
+  inVariable: z.array(inVariableSchema),
+  inOutVariable: z.array(inOutVariableSchema),
+  outVariable: z.array(outVariableSchema),
+  connector: z.array(connectorSchema),
+  continuation: z.array(continuationSchema),
+  comment: z.array(commentSchema),
+})
+type FbdXML = z.infer<typeof fbdXMLSchema>
+
+export {
+  blockSchema,
+  commentSchema,
+  connectorSchema,
+  continuationSchema,
+  fbdXMLSchema,
+  inOutVariableSchema,
+  inVariableSchema,
+  outVariableSchema,
+}
+export type {
+  BlockFbdXML,
+  CommentFbdXML,
+  ConnectorFbdXML,
+  ContinuationFbdXML,
+  FbdXML,
+  InOutVariableFbdXML,
+  InVariableFbdXML,
+  OutVariableFbdXML,
+}
diff --git a/src_old/types/PLC/xml-data/old-editor/pous/languages/il-diagram.ts b/src_old/types/PLC/xml-data/old-editor/pous/languages/il-diagram.ts
new file mode 100644
index 000000000..a31287d3f
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/pous/languages/il-diagram.ts
@@ -0,0 +1,11 @@
+import { z } from 'zod'
+
+const ilXMLSchema = z.object({
+  'xhtml:p': z.object({
+    $: z.string(),
+  }),
+})
+type IlXML = z.infer<typeof ilXMLSchema>
+
+export { ilXMLSchema }
+export type { IlXML }
diff --git a/src_old/types/PLC/xml-data/old-editor/pous/languages/ladder-diagram.ts b/src_old/types/PLC/xml-data/old-editor/pous/languages/ladder-diagram.ts
new file mode 100644
index 000000000..418085948
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/pous/languages/ladder-diagram.ts
@@ -0,0 +1,416 @@
+/**
+ * ----------------------------------------------------------------
+ * This file is part of OpenPLC documentation.
+ * Here is defined the shape of the mapped data structure for the Ladder Diagram language.
+ * ----------------------------------------------------------------
+ */
+
+import { z } from 'zod'
+
+/**
+ * leftPowerRailSchema is a zod schema for the left power rail of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the left power rail.
+ * - @width: a number that represents the width of the left power rail.
+ * - @height: a number that represents the height of the left power rail.
+ * - position: an object that represents the global position of the left power rail. It includes x and y coordinates.
+ * - connectionPointOut: an object that represents the connection point out of the left power rail. It includes a relPosition object with x and y coordinates.
+ */
+const leftPowerRailSchema = z.object({
+  '@localId': z.string(), //@localId
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.object({
+    '@formalParameter': z.string(),
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+})
+type LeftPowerRailLadderXML = z.infer<typeof leftPowerRailSchema>
+
+/**
+ * rightPowerRailSchema is a zod schema for the right power rail of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the right power rail.
+ * - @width: a number that represents the width of the right power rail.
+ * - @height: a number that represents the height of the right power rail.
+ * - position: an object that represents the global position of the right power rail. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the right power rail. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId (reference to other block) and an array of 'positions'. Each position is an object that includes x and y coordinates representing the path of the connection.
+ */
+const rightPowerRailSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  // This is our handles.
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+})
+type RightPowerRailLadderXML = z.infer<typeof rightPowerRailSchema>
+
+/**
+ * blockSchema is a zod schema for the block element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the block.
+ * - @typeName: a string that represents the type name of the block.
+ * - @instanceName: a string that represents the instance name of the block.
+ * - @width: a number that represents the width of the block.
+ * - @height: a number that represents the height of the block.
+ * - position: an object that represents the position of the block. It includes x and y coordinates.
+ * - inVariable: an array of objects that represent the input variables of the block. Each object includes a @formalParameter and a connectionPointIn.
+ * - outVariable: an array of objects that represent the output variables of the block. Each object includes a formalParameter and a connectionPointOut'.
+ * Each connectionPointIn and connectionPointOut' includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection..
+ */
+const blockSchema = z.object({
+  '@localId': z.string(),
+  '@typeName': z.string(),
+  '@instanceName': z.string().optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@executionOrderId': z.number().optional(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  inputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointIn: z.object({
+          relPosition: z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+          connection: z.array(
+            z.object({
+              '@refLocalId': z.string(), // was just @localId, but it seems to be a reference to other element @localId.
+              position: z.array(
+                z.object({
+                  '@x': z.number(),
+                  '@y': z.number(),
+                }),
+              ),
+            }),
+          ),
+        }),
+      }),
+    ),
+  }),
+  /**
+   * 'inOutVariable' is an array of objects that represent the inOut variables of the block.
+   * @wip This is a guess, we need to confirm this.
+   */
+  inOutVariables: z.string(),
+  outputVariables: z.object({
+    variable: z.array(
+      z.object({
+        '@formalParameter': z.string(),
+        connectionPointOut: z.object({
+          relPosition: z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+          expression: z.string().optional(),
+        }),
+      }),
+    ),
+  }),
+})
+type BlockLadderXML = z.infer<typeof blockSchema>
+
+/**
+ * contactSchema is a zod schema for the contact element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the contact.
+ * - @negated: a boolean that represents if the contact is negated.
+ * - @edge: a string that represents the edges of the contact (rising, falling, or empty).
+ * - @width: a number that represents the width of the contact.
+ * - @height: a number that represents the height of the contact.
+ * - position: an object that represents the position of the contact. It includes x and y coordinates.
+ * - variable: a string that represents the variable of the contact.
+ * - connectionPointIn': an object that represents the connection point in of the contact. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - connectionPointOut': an object that represents the connection point out of the contact. It includes a relPosition object with x and y coordinates.
+ */
+const contactSchema = z.object({
+  '@localId': z.string(),
+  '@negated': z.boolean(),
+  '@edge': z.enum(['rising', 'falling']).optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@executionOrderId': z.number().optional(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+  variable: z.string(),
+})
+type ContactLadderXML = z.infer<typeof contactSchema>
+
+/**
+ * coilSchema is a zod schema for the coil element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the coil.
+ * - @negated: a boolean that represents if the coil is negated.
+ * - @edge: a string that represents the edges of the coil (rising, falling, or empty).
+ * - @storage: a string that represents the storage of the coil (set, reset, or empty).
+ * - @width: a number that represents the width of the coil.
+ * - @height: a number that represents the height of the coil.
+ * - position: an object that represents the position of the coil. It includes x and y coordinates.
+ * - variable: a string that represents the variable of the coil.
+ * - connectionPointIn: an object that represents the connection point in of the coil. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - connectionPointOut: an object that represents the connection point out of the coil. It includes a relPosition object with x and y coordinates.
+ */
+const coilSchema = z.object({
+  '@localId': z.string(),
+  '@negated': z.boolean(),
+  '@edge': z.enum(['rising', 'falling']).optional(),
+  '@storage': z.enum(['set', 'reset']).optional(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@executionOrderId': z.number().optional(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+  variable: z.string(),
+})
+type CoilLadderXML = z.infer<typeof coilSchema>
+
+/**
+ * inSchema is a zod schema for the input variable element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the input variable.
+ * - @width: a number that represents the width of the input variable.
+ * - @height: a number that represents the height of the input variable.
+ * - @negated: a boolean that represents if the input variable is negated.
+ * - position: an object that represents the position of the input variable. It includes x and y coordinates.
+ * - connectionPointOut': an object that represents the connection point out of the input variable. It includes a relPosition object with x and y coordinates.
+ * - expression: a string that represents the expression of the input variable.
+ */
+const inVariableSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+  expression: z.string(),
+})
+type InVariableLadderXML = z.infer<typeof inVariableSchema>
+
+/**
+ * inOutSchema is a zod schema for the inOut variable element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the inOut variable.
+ * - @width: a number that represents the width of the inOut variable.
+ * - @height: a number that represents the height of the inOut variable.
+ * - @negatedOut: a boolean that represents if the output of the inOut variable is negated.
+ * - @negatedIn: a boolean that represents if the input of the inOut variable is negated.
+ * - position: an object that represents the position of the inOut variable. It includes x and y coordinates.
+ * - connectionPointIn': an object that represents the connection point in of the inOut variable. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - connectionPointOut: an object that represents the connection point out of the inOut variable. It includes a relPosition object with x and y coordinates.
+ * - expression: a string that represents the expression of the inOut variable.
+ */
+const inOutVariableSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negatedOut': z.boolean(),
+  '@negatedIn': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+  connectionPointOut: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+  }),
+  expression: z.string(),
+})
+type InOutVariableLadderXML = z.infer<typeof inOutVariableSchema>
+
+/**
+ * outSchema is a zod schema for the output variable element of the Ladder Diagram.
+ * It includes the following properties:
+ * - @localId: a string that represents the local identifier of the output variable.
+ * - @width: a number that represents the width of the output variable.
+ * - @height: a number that represents the height of the output variable.
+ * - @negated: a boolean that represents if the output variable is negated.
+ * - position: an object that represents the position of the output variable. It includes x and y coordinates.
+ * - connectionPointIn: an object that represents the connection point in of the output variable. It includes a relPosition object with x and y coordinates and an array of connections.
+ * Each connection is an object that includes a @refLocalId and an array of position. Each position is an object that includes x and y coordinates representing the path of the connection.
+ * - expression: a string that represents the expression of the output variable.
+ */
+const outVariableSchema = z.object({
+  '@localId': z.string(),
+  '@width': z.number(),
+  '@height': z.number(),
+  '@negated': z.boolean(),
+  position: z.object({
+    '@x': z.number(),
+    '@y': z.number(),
+  }),
+  connectionPointIn: z.object({
+    relPosition: z.object({
+      '@x': z.number(),
+      '@y': z.number(),
+    }),
+    connection: z.array(
+      z.object({
+        '@refLocalId': z.string(),
+        '@formalParameter': z.string().optional(),
+        position: z.array(
+          z.object({
+            '@x': z.number(),
+            '@y': z.number(),
+          }),
+        ),
+      }),
+    ),
+  }),
+  expression: z.string(),
+})
+type OutVariableLadderXML = z.infer<typeof outVariableSchema>
+
+/**
+ * Ladder Diagram XML data types.
+ */
+const ladderXMLSchema = z.object({
+  leftPowerRail: z.array(leftPowerRailSchema),
+  rightPowerRail: z.array(rightPowerRailSchema),
+  block: z.array(blockSchema),
+  contact: z.array(contactSchema),
+  coil: z.array(coilSchema),
+  inVariable: z.array(inVariableSchema),
+  inOutVariable: z.array(inOutVariableSchema),
+  outVariable: z.array(outVariableSchema),
+})
+type LadderXML = z.infer<typeof ladderXMLSchema>
+
+export {
+  blockSchema,
+  coilSchema,
+  contactSchema,
+  inOutVariableSchema,
+  inVariableSchema,
+  ladderXMLSchema,
+  leftPowerRailSchema,
+  outVariableSchema,
+  rightPowerRailSchema,
+}
+export type {
+  BlockLadderXML,
+  CoilLadderXML,
+  ContactLadderXML,
+  InOutVariableLadderXML,
+  InVariableLadderXML,
+  LadderXML,
+  LeftPowerRailLadderXML,
+  OutVariableLadderXML,
+  RightPowerRailLadderXML,
+}
diff --git a/src_old/types/PLC/xml-data/old-editor/pous/languages/st-diagram.ts b/src_old/types/PLC/xml-data/old-editor/pous/languages/st-diagram.ts
new file mode 100644
index 000000000..66873aead
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/pous/languages/st-diagram.ts
@@ -0,0 +1,11 @@
+import { z } from 'zod'
+
+const stXMLSchema = z.object({
+  'xhtml:p': z.object({
+    $: z.string(),
+  }),
+})
+type StXML = z.infer<typeof stXMLSchema>
+
+export { stXMLSchema }
+export type { StXML }
diff --git a/src_old/types/PLC/xml-data/old-editor/pous/pous-diagram.ts b/src_old/types/PLC/xml-data/old-editor/pous/pous-diagram.ts
new file mode 100644
index 000000000..4fb5deeba
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/pous/pous-diagram.ts
@@ -0,0 +1,35 @@
+import { z } from 'zod'
+
+import { interfaceXMLSchema } from './interface/interface-diagram'
+import { fbdXMLSchema } from './languages/fbd-diagram'
+import { ilXMLSchema } from './languages/il-diagram'
+import { ladderXMLSchema } from './languages/ladder-diagram'
+import { stXMLSchema } from './languages/st-diagram'
+
+const pousSchema = z.object({
+  pou: z.array(
+    z.object({
+      '@name': z.string(),
+      '@pouType': z.enum(['program', 'function', 'functionBlock']),
+      interface: interfaceXMLSchema,
+      body: z.object({
+        IL: ilXMLSchema.optional(),
+        ST: stXMLSchema.optional(),
+        LD: ladderXMLSchema.optional(),
+        FBD: fbdXMLSchema.optional(),
+        SFC: z.string().optional(),
+      }),
+      documentation: z
+        .object({
+          'xhtml:p': z.object({
+            $: z.string(),
+          }),
+        })
+        .optional(),
+    }),
+  ),
+})
+type PousXML = z.infer<typeof pousSchema>
+
+export { pousSchema }
+export type { PousXML }
diff --git a/src_old/types/PLC/xml-data/old-editor/task/task-diagram.ts b/src_old/types/PLC/xml-data/old-editor/task/task-diagram.ts
new file mode 100644
index 000000000..8d34e07e2
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/task/task-diagram.ts
@@ -0,0 +1,24 @@
+import { z } from 'zod'
+
+const pouInstanceSchema = z.object({
+  '@name': z.string(),
+  '@typeName': z.string(),
+})
+type PouInstance = z.infer<typeof pouInstanceSchema>
+
+const taskXMLSchema = z.object({
+  '@name': z.string(),
+  '@priority': z.string(),
+  '@interval': z.string().nullable(),
+  '@single': z.string().nullable(),
+  pouInstance: z.array(
+    z.object({
+      '@name': z.string(),
+      '@typeName': z.string(),
+    }),
+  ),
+})
+type TaskXML = z.infer<typeof taskXMLSchema>
+
+export { pouInstanceSchema, taskXMLSchema }
+export type { PouInstance, TaskXML }
diff --git a/src_old/types/PLC/xml-data/old-editor/variable/variable-diagram.ts b/src_old/types/PLC/xml-data/old-editor/variable/variable-diagram.ts
new file mode 100644
index 000000000..7c48760cd
--- /dev/null
+++ b/src_old/types/PLC/xml-data/old-editor/variable/variable-diagram.ts
@@ -0,0 +1,27 @@
+import { baseTypes } from '@root/shared/data'
+import { z } from 'zod'
+
+const variableXMLSchema = z.object({
+  '@name': z.string(),
+  '@address': z.string().optional(),
+  type: z.object(baseTypes.reduce((acc, type) => ({ ...acc, [type]: z.string().optional() }), {})).optional(),
+  initialValue: z
+    .object({
+      simpleValue: z.object({
+        '@value': z.string(),
+      }),
+    })
+    .or(z.null())
+    .optional(),
+  documentation: z
+    .object({
+      'xhtml:p': z.object({
+        $: z.string(),
+      }),
+    })
+    .optional(),
+})
+type VariableXML = z.infer<typeof variableXMLSchema>
+
+export { variableXMLSchema }
+export type { VariableXML }
diff --git a/src_old/types/clipboard.ts b/src_old/types/clipboard.ts
new file mode 100644
index 000000000..b5c845530
--- /dev/null
+++ b/src_old/types/clipboard.ts
@@ -0,0 +1,38 @@
+import { edgeSchema, nodeSchema } from '@root/renderer/store/slices/react-flow'
+import z from 'zod'
+
+export const clipboardSchema = z.discriminatedUnion('language', [
+  z.object({
+    language: z.literal('fbd'),
+    content: z.object({
+      nodes: z.array(nodeSchema),
+      edges: z.array(edgeSchema),
+    }),
+  }),
+  z.object({
+    language: z.literal('ld'),
+    content: z.string(),
+  }),
+  z.object({
+    language: z.literal('st'),
+    content: z.object({
+      src: z.string(),
+      width: z.number().optional(),
+      height: z.number().optional(),
+    }),
+  }),
+  z.object({
+    language: z.literal('il'),
+    content: z.string(),
+  }),
+  z.object({
+    language: z.literal('sfc'),
+    content: z.string(),
+  }),
+  z.object({
+    language: z.literal('other'),
+    content: z.string(),
+  }),
+])
+
+export type ClipboardType = z.infer<typeof clipboardSchema>
diff --git a/src_old/types/common/dataType.ts b/src_old/types/common/dataType.ts
new file mode 100644
index 000000000..423af1f23
--- /dev/null
+++ b/src_old/types/common/dataType.ts
@@ -0,0 +1,89 @@
+import { z } from 'zod'
+
+const _dataTypeSchema = z.object({
+  '@name': z.string(),
+  baseType: z.array(
+    z.object({
+      derivationType: z.object({
+        directly: z.object({
+          type: z.enum([
+            'BOOL',
+            'SINT',
+            'INT',
+            'DINT',
+            'LINT',
+            'USINT',
+            'UINT',
+            'UDINT',
+            'ULINT',
+            'REAL',
+            'LREAL',
+            'TIME',
+            'DATE',
+            'TOD',
+            'DT',
+            'STRING',
+            'BYTE',
+            'WORD',
+            'DWORD',
+            'LWORD',
+          ]),
+        }),
+        subrange: z.object({
+          subrangeUnsigned: z.object({
+            range: z.array(
+              z.object({
+                '@lower': z.string().default('0'),
+                '@upper': z.string().default('0'),
+                baseType: z.object({
+                  type: z.enum(['UDINT', 'INT', 'USINT', 'LINT', 'DINT', 'UINT', 'ULINT', 'SINT']),
+                }),
+              }),
+            ),
+          }),
+        }),
+        enumerated: z.object({
+          enum: z.object({
+            values: z.object({
+              value: z.object({
+                '@name': z.string(),
+              }),
+            }),
+          }),
+        }),
+        array: z.object({
+          array: z.object({
+            dimension: z.array(
+              z.object({
+                '@lower': z.string(),
+                '@upper': z.string(),
+                baseType: z.object({
+                  derived: z.object({
+                    '@name': z.string(),
+                  }),
+                }),
+              }),
+            ),
+          }),
+        }),
+        struct: z.object({
+          struct: z.object({
+            variable: z.array(
+              z.object({
+                '@name': z.string(),
+                type: z.enum(['BOOL', 'INT', 'DINT']),
+              }),
+            ),
+          }),
+        }),
+      }),
+    }),
+  ),
+  initialValue: z
+    .object({
+      simpleValue: z.any(),
+    })
+    .optional(),
+})
+
+export type DataTypeShape = z.infer<typeof _dataTypeSchema>
diff --git a/src_old/types/common/pou.ts b/src_old/types/common/pou.ts
new file mode 100644
index 000000000..9d17843f7
--- /dev/null
+++ b/src_old/types/common/pou.ts
@@ -0,0 +1,76 @@
+import { z } from 'zod'
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const pouSchema = z.object({
+  '@name': z.string(),
+  '@pouType': z.enum(['program', 'function']),
+  interface: z.object({
+    returnType: z.enum(['BOOL', 'INT', 'DINT']),
+    localVars: z
+      .object({
+        variables: z.array(
+          z.object({
+            '@name': z.string(),
+            type: z.enum(['BOOL', 'INT', 'DINT']),
+            initialValue: z.any(),
+          }),
+        ),
+      })
+      .optional(),
+  }),
+  body: z.object({
+    IL: z
+      .object({
+        'xhtml:p': z.string(),
+      })
+      .optional(),
+    ST: z
+      .object({
+        'xhtml:p': z.string(),
+      })
+      .optional(),
+  }),
+  documentation: z
+    .object({
+      'xhtml:p': z.string(),
+    })
+    .optional(),
+})
+
+export type PouShape = z.infer<typeof pouSchema>
+
+const ILPouAttributes = {
+  interface: {
+    returnType: ['BOOL', 'INT', 'DINT'],
+  },
+}
+const STPouAttributes = {}
+const DefaultGraphicalPOUBody = {
+  LD: {},
+  FBD: {},
+  SFC: {},
+}
+const DefaultTextualPOUBody = {
+  IL: {
+    'xhtml:p': {
+      $: '', // REVIEW: Must turn this node into a CDATA tag with xmlbuilder
+    },
+  },
+  ST: {
+    'xhtml:p': '<![CDATA[Dummy body data for pou mock]]>',
+  },
+}
+// interface: {
+//   returnType: { BOOL: {} },
+//   localVars: {
+//     variable: {
+//       '@name': 'LocalVar0',
+//       type: { DINT: {} },
+//       initialValue: { simpleValue: { '@value': '0' } },
+//     },
+//   },
+// },
+
+// documentation: {
+//   'xhtml:p': '<![CDATA[Dummy description for pou mock]]>',
+// },
diff --git a/src_old/types/common/project.ts b/src_old/types/common/project.ts
new file mode 100644
index 000000000..cef9f1940
--- /dev/null
+++ b/src_old/types/common/project.ts
@@ -0,0 +1,164 @@
+// import { z } from 'zod'
+
+// import { CONSTANTS, formatDate } from '@/utils'
+
+// const { types } = CONSTANTS
+
+// const DefaultProjectShape = {
+//   project: {
+//     '@xmlns:ns1': 'http://www.plcopen.org/xml/tc6.xsd',
+//     '@xmlns:xhtml': 'http://www.w3.org/1999/xhtml',
+//     '@xmlns:xsd': 'http://www.w3.org/2001/XMLSchema',
+//     '@xmlns': 'http://www.plcopen.org/xml/tc6_0201',
+//     fileHeader: {
+//       '@companyName': 'Unknown',
+//       '@productName': 'Unnamed',
+//       '@productVersion': '1',
+//       '@creationDateTime': formatDate(new Date()),
+//     },
+//     contentHeader: {
+//       '@name': 'Unnamed',
+//       '@modificationDateTime': formatDate(new Date()),
+//       coordinateInfo: {
+//         fbd: {
+//           scaling: {
+//             '@x': '10',
+//             '@y': '10',
+//           },
+//         },
+//         ld: {
+//           scaling: {
+//             '@x': '10',
+//             '@y': '10',
+//           },
+//         },
+//         sfc: {
+//           scaling: {
+//             '@x': '10',
+//             '@y': '10',
+//           },
+//         },
+//       },
+//     },
+//     types: {
+//       dataTypes: {},
+//       pous: {
+//         pou: [
+//           {
+//             '@name': 'program0',
+//             '@pouType': 'program',
+//             interface: {
+//               returnType: 'BOOL',
+//               localVars: {
+//                 variable: {
+//                   '@name': 'LocalVar0',
+//                   type: 'INT',
+//                   initialValue: { simpleValue: { '@value': '0' } },
+//                 },
+//               },
+//             },
+//             body: {
+//               IL: {
+//                 'xhtml:p': {
+//                   $: 'Data test',
+//                 },
+//               },
+//               ST: {
+//                 'xhtml:p': {
+//                   $: 'Data test',
+//                 },
+//               },
+//             },
+//             documentation: {
+//               'xhtml:p': {
+//                 $: 'Doc test',
+//               },
+//             },
+//           },
+//         ],
+//       },
+//     },
+//     instances: {
+//       configurations: {
+//         configuration: {
+//           '@name': 'Config0',
+//           resource: {
+//             '@name': 'Res0',
+//           },
+//         },
+//       },
+//     },
+//   },
+// }
+
+// export type ProjectDTO = z.infer<typeof ProjectXMLShape>
+
+// const ProjectXMLShape = z.object({
+//   project: z.object({
+//     '@xmlns:ns1': z.string().default('http://www.plcopen.org/xml/tc6.xsd'),
+//     '@xmlns:xhtml': z.string().default('http://www.w3.org/1999/xhtml'),
+//     '@xmlns:xsd': z.string().default('http://www.w3.org/2001/XMLSchema'),
+//     '@xmlns': z.string().default('http://www.plcopen.org/xml/tc6_0201'),
+//     fileHeader: z.object({
+//       '@companyName': z.string().default('Unknown'),
+//       '@productName': z.string().default('Unnamed'),
+//       '@productVersion': z.string().default('1'),
+//       '@creationDateTime': z.string().default(formatDate(new Date())),
+//     }),
+//     contentHeader: z.object({
+//       '@name': z.string().default('Unnamed'),
+//       '@modificationDateTime': z.string().default(formatDate(new Date())),
+//       coordinateInfo: z.object({
+//         fbd: z.object({
+//           scaling: z.object({
+//             '@x': z.string().default('10'),
+//             '@y': z.string().default('10'),
+//           }),
+//         }),
+//         ld: z.object({
+//           scaling: z.object({
+//             '@x': z.string().default('10'),
+//             '@y': z.string().default('10'),
+//           }),
+//           sfd: z.object({
+//             scaling: z.object({
+//               '@x': z.string().default('10'),
+//               '@y': z.string().default('10'),
+//             }),
+//           }),
+//         }),
+//       }),
+//     }),
+//     types: z.object({
+//       dataTypes: z.object({}),
+//       pous: z.object({
+//         pou: z.array(
+//           z.object({
+//             '@name': z.string(),
+//             '@pouType': z.string().refine((t) => Object.values(types).includes(t), {
+//               message: 'Invalid POU type',
+//             }),
+//             body: z.record(
+//               z.enum(['IL', 'ST']),
+//               z.object({
+//                 'xhtml:p': z.object({
+//                   $: z.string(),
+//                 }),
+//               }),
+//             ),
+//           }),
+//         ),
+//       }),
+//     }),
+//     instances: z.object({
+//       configurations: z.object({
+//         configuration: z.object({
+//           '@name': z.string().default('Config0'),
+//           resource: z.object({
+//             '@name': z.string(),
+//           }),
+//         }),
+//       }),
+//     }),
+//   }),
+// })
diff --git a/src_old/types/debugger.ts b/src_old/types/debugger.ts
new file mode 100644
index 000000000..cdb2d25c2
--- /dev/null
+++ b/src_old/types/debugger.ts
@@ -0,0 +1,53 @@
+/**
+ * Function Block Instance Info
+ * Represents information about a specific FB instance for debugging
+ */
+export interface FbInstanceInfo {
+  /** FB type name (e.g., "Calculate_PID", "TON") */
+  fbTypeName: string
+
+  /** Program POU name containing this instance (e.g., "main") */
+  programName: string
+
+  /** Instance name from Resources configuration (e.g., "INSTANCE0") */
+  programInstanceName: string
+
+  /** FB variable name in the program (e.g., "MOTOR_SPEED0") */
+  fbVariableName: string
+
+  /** Unique key for this instance: `${programName}:${fbVariableName}` */
+  key: string
+}
+
+/**
+ * Debug Tree Node Interface
+ * Represents a node in the hierarchical debugger variable tree
+ */
+export interface DebugTreeNode {
+  /** Display name (e.g., "TON0", "favorite_person", "name") */
+  name: string
+
+  /** Full debug path (e.g., "RES0__INSTANCE0.TON0.EN") */
+  fullPath: string
+
+  /** Editor key format (e.g., "main:TON0.EN") */
+  compositeKey: string
+
+  /** IEC type or "STRUCT", "ARRAY", "FB" */
+  type: string
+
+  /** true for arrays, structs, FBs */
+  isComplex: boolean
+
+  /** UI state for expansion */
+  isExpanded?: boolean
+
+  /** Sub-variables for complex types */
+  children?: DebugTreeNode[]
+
+  /** Only for leaf nodes - index in debug.c */
+  debugIndex?: number
+
+  /** For array nodes [start, end] */
+  arrayIndices?: number[]
+}
diff --git a/src_old/types/plc-status.ts b/src_old/types/plc-status.ts
new file mode 100644
index 000000000..8389249c0
--- /dev/null
+++ b/src_old/types/plc-status.ts
@@ -0,0 +1,17 @@
+/**
+ * PLC runtime status values
+ * These represent the possible states of the OpenPLC Runtime
+ */
+export const PLC_VALID_STATUSES = ['INIT', 'RUNNING', 'STOPPED', 'ERROR', 'EMPTY', 'UNKNOWN'] as const
+
+/**
+ * Type representing valid PLC runtime status values
+ */
+export type PlcStatus = (typeof PLC_VALID_STATUSES)[number]
+
+/**
+ * Type guard to check if a string is a valid PLC status
+ */
+export function isValidPlcStatus(status: string): status is PlcStatus {
+  return PLC_VALID_STATUSES.includes(status as PlcStatus)
+}
diff --git a/src_old/types/transfer.ts b/src_old/types/transfer.ts
new file mode 100644
index 000000000..3d4a071f7
--- /dev/null
+++ b/src_old/types/transfer.ts
@@ -0,0 +1,52 @@
+import { z } from 'zod'
+
+const IPouTemplateSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(3).default('PouDefault'),
+  type: z.enum(['program', 'function', 'functionBlock']).default('program'),
+  languageCodification: z.enum(['Graphical', 'Textual']).default('Textual'),
+  language: z.enum(['IL', 'ST', 'LD', 'SFC', 'FBD']).default('IL'),
+  body: z.string().optional(),
+  ref: z.string().optional(),
+})
+
+type IPouTemplate = z.infer<typeof IPouTemplateSchema>
+
+const IDataTypeTemplateSchema = z.object({
+  id: z.number().optional(),
+  derivationType: z.enum(['Directly', 'SubRange', 'Enumerated', 'Array', 'Structure']).default('Directly'),
+  baseType: z.string().optional(),
+  value: z.string().default(''),
+  ref: z.string().optional(),
+})
+
+type IDataTypeTemplate = z.infer<typeof IDataTypeTemplateSchema>
+
+const IVariableTemplateSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(3).default('VariableDefault'),
+  class: z.string().optional(),
+  type: z.string().optional(),
+  location: z.string().optional(),
+  initialValue: z.string().default(''),
+  documentation: z.string().optional(),
+  debug: z.boolean().default(false),
+  ref: z.string().optional(),
+})
+
+type IVariableTemplate = z.infer<typeof IVariableTemplateSchema>
+type IProjectData = {
+  pous: IPouTemplate[]
+  dataTypes: IDataTypeTemplate[]
+  variables: IVariableTemplate[]
+}
+
+export {
+  type IDataTypeTemplate,
+  IDataTypeTemplateSchema,
+  type IPouTemplate,
+  IPouTemplateSchema,
+  IProjectData,
+  type IVariableTemplate,
+  IVariableTemplateSchema,
+}
diff --git a/src/utils/PLC/array-codegen-helpers.ts b/src_old/utils/PLC/array-codegen-helpers.ts
similarity index 100%
rename from src/utils/PLC/array-codegen-helpers.ts
rename to src_old/utils/PLC/array-codegen-helpers.ts
diff --git a/src/utils/PLC/array-variable-utils.ts b/src_old/utils/PLC/array-variable-utils.ts
similarity index 100%
rename from src/utils/PLC/array-variable-utils.ts
rename to src_old/utils/PLC/array-variable-utils.ts
diff --git a/src2/frontend/utils/PLC/extensible-block-variables.ts b/src_old/utils/PLC/extensible-block-variables.ts
similarity index 100%
rename from src2/frontend/utils/PLC/extensible-block-variables.ts
rename to src_old/utils/PLC/extensible-block-variables.ts
diff --git a/src_old/utils/PLC/pou-file-extensions.ts b/src_old/utils/PLC/pou-file-extensions.ts
new file mode 100644
index 000000000..c59631b08
--- /dev/null
+++ b/src_old/utils/PLC/pou-file-extensions.ts
@@ -0,0 +1,110 @@
+/**
+ * Language to file extension mapping
+ */
+const LANGUAGE_TO_EXTENSION: Record<string, string> = {
+  st: '.st',
+  il: '.il',
+  ld: '.ld',
+  fbd: '.fbd',
+  python: '.py',
+  cpp: '.cpp',
+}
+
+/**
+ * POU type to IEC start keyword mapping
+ */
+const POU_TYPE_TO_START_KEYWORD: Record<string, string> = {
+  program: 'PROGRAM',
+  function: 'FUNCTION',
+  'function-block': 'FUNCTION_BLOCK',
+}
+
+/**
+ * POU type to folder name mapping
+ */
+const POU_TYPE_TO_FOLDER: Record<string, string> = {
+  program: 'programs',
+  function: 'functions',
+  'function-block': 'function-blocks',
+}
+
+/**
+ * POU type to IEC end keyword mapping
+ */
+const POU_TYPE_TO_END_KEYWORD: Record<string, string> = {
+  program: 'END_PROGRAM',
+  function: 'END_FUNCTION',
+  'function-block': 'END_FUNCTION_BLOCK',
+}
+
+/**
+ * Get file extension for a given language
+ * @param language - The language code (st, il, ld, fbd, python, cpp)
+ * @returns The file extension including the dot (e.g., '.st')
+ * @throws Error if language is not supported
+ */
+export const getExtensionFromLanguage = (language: string): string => {
+  const extension = LANGUAGE_TO_EXTENSION[language.toLowerCase()]
+  if (!extension) {
+    throw new Error(`Unsupported language: ${language}`)
+  }
+  return extension
+}
+
+/**
+ * Get language code from a file extension
+ * @param extension - The file extension (with or without dot)
+ * @returns The language code
+ * @throws Error if extension is not supported
+ */
+export const getLanguageFromExtension = (extension: string): string => {
+  const normalizedExtension = extension.startsWith('.') ? extension : `.${extension}`
+
+  const language = Object.entries(LANGUAGE_TO_EXTENSION).find(([, ext]) => ext === normalizedExtension)?.[0]
+
+  if (!language) {
+    throw new Error(`Unsupported extension: ${extension}`)
+  }
+  return language
+}
+
+/**
+ * Get IEC start keyword for a given POU type
+ * @param pouType - The POU type (program, function, function-block)
+ * @returns The IEC start keyword (e.g., 'PROGRAM', 'FUNCTION', 'FUNCTION_BLOCK')
+ * @throws Error if POU type is not supported
+ */
+export const getStartKeyword = (pouType: string): string => {
+  const keyword = POU_TYPE_TO_START_KEYWORD[pouType]
+  if (!keyword) {
+    throw new Error(`Unsupported POU type: ${pouType}`)
+  }
+  return keyword
+}
+
+/**
+ * Get IEC end keyword for a given POU type
+ * @param pouType - The POU type (program, function, function-block)
+ * @returns The IEC end keyword (e.g., 'END_PROGRAM', 'END_FUNCTION', 'END_FUNCTION_BLOCK')
+ * @throws Error if POU type is not supported
+ */
+export const getEndKeyword = (pouType: string): string => {
+  const keyword = POU_TYPE_TO_END_KEYWORD[pouType]
+  if (!keyword) {
+    throw new Error(`Unsupported POU type: ${pouType}`)
+  }
+  return keyword
+}
+
+/**
+ * Get folder name for a given POU type
+ * @param pouType - The POU type (program, function, function-block)
+ * @returns The folder name (e.g., 'programs', 'functions', 'function-blocks')
+ */
+export const getFolderFromPouType = (pouType: string): string => {
+  const folder = POU_TYPE_TO_FOLDER[pouType]
+  if (!folder) {
+    throw new Error(`Unknown POU type: ${pouType}`)
+  }
+  return folder
+}
diff --git a/src/utils/PLC/pou-text-parser.ts b/src_old/utils/PLC/pou-text-parser.ts
similarity index 100%
rename from src/utils/PLC/pou-text-parser.ts
rename to src_old/utils/PLC/pou-text-parser.ts
diff --git a/src/utils/PLC/pou-text-serializer.ts b/src_old/utils/PLC/pou-text-serializer.ts
similarity index 100%
rename from src/utils/PLC/pou-text-serializer.ts
rename to src_old/utils/PLC/pou-text-serializer.ts
diff --git a/src/utils/PLC/preprocess-pous.ts b/src_old/utils/PLC/preprocess-pous.ts
similarity index 100%
rename from src/utils/PLC/preprocess-pous.ts
rename to src_old/utils/PLC/preprocess-pous.ts
diff --git a/src2/frontend/utils/variable-types.ts b/src_old/utils/PLC/variable-types.ts
similarity index 100%
rename from src2/frontend/utils/variable-types.ts
rename to src_old/utils/PLC/variable-types.ts
diff --git a/src_old/utils/PLC/wrap-unsupported-comments.ts b/src_old/utils/PLC/wrap-unsupported-comments.ts
new file mode 100644
index 000000000..115095098
--- /dev/null
+++ b/src_old/utils/PLC/wrap-unsupported-comments.ts
@@ -0,0 +1,92 @@
+/**
+ * Wraps unsupported comment styles into IEC 61131-3 standard comments.
+ * Converts // and slash-star comments into (* *) format.
+ * This is needed because the MatIEC compiler only accepts (* *) comment blocks.
+ *
+ * This function should only be applied to ST and IL code, NOT to Python or C++ code.
+ *
+ * Escape handling: Backslash escapes are handled by counting consecutive backslashes.
+ * The $ character is treated as an escape character for any following character, which is
+ * a custom extension and not strictly IEC 61131-3 compliant (standard only allows $$, $', $").
+ *
+ * @param value - The code string to process
+ * @returns The code with unsupported comments wrapped in (* *)
+ */
+export const wrapUnsupportedComments = (value: string): string => {
+  let stringContext = '' // either empty for non-string or " || ' to signal type of string
+  let commentContext = '' // either empty for non-comment or // || (* || /*
+  let cBlockDepth = 0 // track nesting depth of {{ ... }} C code blocks
+  let outValue = value
+    .split('')
+    .map((iChar, i, original) => {
+      const nextTwoChars = original.slice(i, i + 2).join('') // inclusive of iChar
+      const lastTwoChars = original.slice(i - 2, i).join('') // exclusive of iChar
+
+      if (nextTwoChars === '{{') {
+        cBlockDepth++
+      } else if (lastTwoChars === '}}') {
+        cBlockDepth--
+      }
+
+      if (cBlockDepth > 0) {
+        return iChar
+      }
+
+      /* CONTEXTUALIZE STRINGS */
+      if (stringContext) {
+        let backslashCount = 0
+        for (let j = i - 1; j >= 0 && original[j] === '\\'; j--) {
+          backslashCount++
+        }
+        if (backslashCount % 2 === 1 || original[i - 1] === '$') {
+          return iChar
+        } else if (iChar == stringContext) {
+          stringContext = ''
+          return iChar
+        }
+        return iChar
+      }
+      // test for string context (exclude comment context)
+      if (`'"`.includes(iChar) && !commentContext) {
+        // NOTE: "" / WSTRING (utf-16) currently unsupported by editor, but am future proofing
+        stringContext = iChar
+        return iChar
+      }
+      // CONTEXTUALIZE COMMENTS
+      if (commentContext) {
+        if ('//' == commentContext && (nextTwoChars == '\r\n' || iChar == '\n')) {
+          commentContext = ''
+          return '*)' + iChar
+        }
+        if ('(*' == commentContext && lastTwoChars == '*)') {
+          commentContext = ''
+          return iChar
+        }
+        if ('/*' == commentContext && lastTwoChars == '*/' && original.slice(i - 3, i - 1).join('') != '/*') {
+          // the term with slice -3 .. -1 is for a sneaky case where /*/ would otherwise be interpreted as a closed comment
+          commentContext = ''
+          return '*)' + iChar
+        }
+        const prevTwoChars = original.slice(i - 1, i + 1).join('') // INCLUSIVE of iChar
+        if ('(*' != commentContext && prevTwoChars == '*)') {
+          return '_' + iChar // for the case where a non-(**) comment contains a closing *) - need to break it or this workaround doesn't work
+        }
+        return iChar
+      }
+      // test for comment context (exclude string context)
+      if (['//', '(*', '/*'].includes(nextTwoChars) && !stringContext) {
+        commentContext = nextTwoChars
+        if (['//', '/*'].includes(commentContext)) {
+          // patch for comments unsupported by matiec (*only these are supported*)
+          return '(*' + iChar // yes, will keep the original comment chars, it is inconsequential
+        }
+        return iChar
+      }
+      return iChar
+    })
+    .join('')
+  if (commentContext) {
+    outValue += '*)'
+  }
+  return outValue
+}
diff --git a/src/utils/PLC/xml-generator.ts b/src_old/utils/PLC/xml-generator.ts
similarity index 100%
rename from src/utils/PLC/xml-generator.ts
rename to src_old/utils/PLC/xml-generator.ts
diff --git a/src/utils/PLC/xml-generator/codesys/base-xml.ts b/src_old/utils/PLC/xml-generator/codesys/base-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/base-xml.ts
rename to src_old/utils/PLC/xml-generator/codesys/base-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/codesys/data-type-xml.ts b/src_old/utils/PLC/xml-generator/codesys/data-type-xml.ts
new file mode 100644
index 000000000..1a6b4cc4f
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/codesys/data-type-xml.ts
@@ -0,0 +1,156 @@
+import { PLCDataType } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/codesys'
+
+const parseDimensions = (dimensions: Array<{ dimension: string }>) => {
+  return (
+    dimensions?.map((dimension) => {
+      if (!dimension?.dimension || typeof dimension.dimension !== 'string') {
+        throw new Error(`Invalid dimension format: ${dimension.dimension}`)
+      }
+      const [lower, upper] = dimension.dimension.split('..')
+      if (!lower || !upper) {
+        throw new Error(`Invalid dimension range: ${dimension.dimension}`)
+      }
+      return { '@lower': lower, '@upper': upper }
+    }) || []
+  )
+}
+
+export const codeSysParseDataTypesToXML = (xml: BaseXml, dataTypes: PLCDataType[]) => {
+  dataTypes.forEach((dataType) => {
+    switch (dataType.derivation) {
+      case 'array':
+        xml.project.types.dataTypes.dataType.push({
+          '@name': dataType.name,
+          baseType: {
+            array: {
+              dimension: parseDimensions(dataType.dimensions),
+              baseType: {
+                [dataType.baseType.definition === 'user-data-type'
+                  ? 'derived'
+                  : dataType.baseType.value === 'string'
+                    ? 'string'
+                    : dataType.baseType.value.toUpperCase()]:
+                  dataType.baseType.definition === 'user-data-type' ? { '@name': dataType.baseType.value } : '',
+              },
+            },
+          },
+          initialValue: dataType.initialValue
+            ? {
+                simpleValue: {
+                  '@value': dataType.initialValue,
+                },
+              }
+            : undefined,
+        })
+        break
+
+      case 'enumerated':
+        xml.project.types.dataTypes.dataType.push({
+          '@name': dataType.name,
+          baseType: {
+            enum: {
+              values: {
+                value: dataType.values.map((value) => {
+                  return {
+                    '@name': value.description,
+                  }
+                }),
+              },
+            },
+          },
+          initialValue: dataType.initialValue
+            ? {
+                simpleValue: {
+                  '@value': dataType.initialValue,
+                },
+              }
+            : undefined,
+        })
+        break
+
+      case 'structure':
+        xml.project.types.dataTypes.dataType.push({
+          '@name': dataType.name,
+          baseType: {
+            struct: {
+              variable: dataType.variable.map((variable) => {
+                switch (variable.type.definition) {
+                  case 'base-type':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        [variable.type.value === 'string' ? 'string' : variable.type.value.toUpperCase()]: '',
+                      },
+                      initialValue: variable.initialValue?.simpleValue.value
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue?.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                  case 'user-data-type':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        derived: { '@name': variable.type.value },
+                      },
+                      initialValue: variable.initialValue?.simpleValue.value
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue?.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                  case 'array':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        array: {
+                          dimension: parseDimensions(variable.type.data.dimensions),
+                          baseType: {
+                            [variable.type.data.baseType.definition === 'user-data-type'
+                              ? 'derived'
+                              : variable.type.data.baseType.value === 'string'
+                                ? 'string'
+                                : variable.type.data.baseType.value.toUpperCase()]:
+                              variable.type.data.baseType.definition === 'user-data-type'
+                                ? { '@name': variable.type.data.baseType.value }
+                                : '',
+                          },
+                        },
+                      },
+                      initialValue: variable.initialValue
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                  case 'derived':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        derived: { '@name': variable.type.value },
+                      },
+                      initialValue: variable.initialValue
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                }
+              }),
+            },
+          },
+        })
+    }
+  })
+
+  return xml
+}
diff --git a/src_old/utils/PLC/xml-generator/codesys/index.ts b/src_old/utils/PLC/xml-generator/codesys/index.ts
new file mode 100644
index 000000000..7b00e0738
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/codesys/index.ts
@@ -0,0 +1,4 @@
+export * from './base-xml'
+export * from './data-type-xml'
+export * from './instances-xml'
+export * from './pou-xml'
diff --git a/src_old/utils/PLC/xml-generator/codesys/instances-xml.ts b/src_old/utils/PLC/xml-generator/codesys/instances-xml.ts
new file mode 100644
index 000000000..374ff8d0e
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/codesys/instances-xml.ts
@@ -0,0 +1,66 @@
+import { PLCConfiguration } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/codesys'
+import { PouInstance, TaskXML } from '@root/types/PLC/xml-data/codesys/task/task-diagram'
+
+export const codeSysInstanceToXml = (xml: BaseXml, configuration: PLCConfiguration) => {
+  const { instances, tasks, globalVariables } = configuration.resource
+
+  tasks.forEach((task) => {
+    const i: PouInstance[] =
+      instances
+        .filter((i) => i.task === task.name)
+        .map((i) => {
+          return {
+            '@name': i.name,
+            '@typeName': i.program,
+          }
+        }) || []
+
+    const t: TaskXML = {
+      '@name': task.name,
+      '@priority': task.priority.toString(),
+      '@interval': task.triggering === 'Cyclic' ? task.interval.toString() : null,
+      '@single': task.triggering === 'Interrupt' ? '' : null,
+      pouInstance: i,
+    }
+
+    if (!xml.project.instances.configurations.configuration.resource.task) {
+      xml.project.instances.configurations.configuration.resource.task = []
+    }
+    xml.project.instances.configurations.configuration.resource.task.push(t)
+  })
+
+  globalVariables.forEach((variable) => {
+    const v = {
+      '@name': variable.name,
+      '@address': variable.location,
+      type: {
+        [variable.type.value.toUpperCase()]: '',
+      },
+      initialValue: variable.initialValue
+        ? {
+            simpleValue: {
+              '@value': variable.initialValue,
+            },
+          }
+        : null,
+      documentation: {
+        'xhtml:p': {
+          $: variable.documentation === '' ? ' ' : variable.documentation,
+        },
+      },
+    }
+
+    if (!xml.project.instances.configurations.configuration.globalVars) {
+      xml.project.instances.configurations.configuration.globalVars = {
+        variable: [],
+      }
+    }
+    if (!xml.project.instances.configurations.configuration.globalVars.variable) {
+      xml.project.instances.configurations.configuration.globalVars.variable = []
+    }
+    xml.project.instances.configurations.configuration.globalVars.variable.push(v)
+  })
+
+  return xml
+}
diff --git a/src/utils/PLC/xml-generator/codesys/language/fbd-xml.ts b/src_old/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
rename to src_old/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/codesys/language/il-xml.ts b/src_old/utils/PLC/xml-generator/codesys/language/il-xml.ts
new file mode 100644
index 000000000..32ad6c7f3
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/codesys/language/il-xml.ts
@@ -0,0 +1,22 @@
+import { IlXML } from '@root/types/PLC/xml-data/codesys'
+
+const ilToXML = (value: string) => {
+  const ilXML: {
+    body: {
+      IL: IlXML
+    }
+  } = {
+    body: {
+      IL: {
+        xhtml: {
+          '@xmlns': 'http://www.w3.org/1999/xhtml',
+          $: value,
+        },
+      },
+    },
+  }
+
+  return ilXML
+}
+
+export { ilToXML }
diff --git a/src/utils/PLC/xml-generator/codesys/language/ladder-xml.ts b/src_old/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
rename to src_old/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/codesys/language/st-xml.ts b/src_old/utils/PLC/xml-generator/codesys/language/st-xml.ts
new file mode 100644
index 000000000..b446dc5b3
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/codesys/language/st-xml.ts
@@ -0,0 +1,22 @@
+import { StXML } from '@root/types/PLC/xml-data/codesys/pous/languages/st-diagram'
+
+const stToXML = (value: string) => {
+  const stXML: {
+    body: {
+      ST: StXML
+    }
+  } = {
+    body: {
+      ST: {
+        xhtml: {
+          '@xmlns': 'http://www.w3.org/1999/xhtml',
+          $: value,
+        },
+      },
+    },
+  }
+
+  return stXML
+}
+
+export { stToXML }
diff --git a/src/utils/PLC/xml-generator/codesys/pou-xml.ts b/src_old/utils/PLC/xml-generator/codesys/pou-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/codesys/pou-xml.ts
rename to src_old/utils/PLC/xml-generator/codesys/pou-xml.ts
diff --git a/src/utils/PLC/xml-generator/old-editor/base-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/base-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/base-xml.ts
rename to src_old/utils/PLC/xml-generator/old-editor/base-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/old-editor/data-type-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/data-type-xml.ts
new file mode 100644
index 000000000..f58c6d60e
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/old-editor/data-type-xml.ts
@@ -0,0 +1,156 @@
+import { PLCDataType } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/old-editor'
+
+const parseDimensions = (dimensions: Array<{ dimension: string }>) => {
+  return (
+    dimensions?.map((dimension) => {
+      if (!dimension?.dimension || typeof dimension.dimension !== 'string') {
+        throw new Error(`Invalid dimension format: ${dimension.dimension}`)
+      }
+      const [lower, upper] = dimension.dimension.split('..')
+      if (!lower || !upper) {
+        throw new Error(`Invalid dimension range: ${dimension.dimension}`)
+      }
+      return { '@lower': lower, '@upper': upper }
+    }) || []
+  )
+}
+
+export const oldEditorParseDataTypesToXML = (xml: BaseXml, dataTypes: PLCDataType[]) => {
+  dataTypes.forEach((dataType) => {
+    switch (dataType.derivation) {
+      case 'array':
+        xml.project.types.dataTypes.dataType.push({
+          '@name': dataType.name,
+          baseType: {
+            array: {
+              dimension: parseDimensions(dataType.dimensions),
+              baseType: {
+                [dataType.baseType.definition === 'user-data-type'
+                  ? 'derived'
+                  : dataType.baseType.value === 'string'
+                    ? 'string'
+                    : dataType.baseType.value.toUpperCase()]:
+                  dataType.baseType.definition === 'user-data-type' ? { '@name': dataType.baseType.value } : '',
+              },
+            },
+          },
+          initialValue: dataType.initialValue
+            ? {
+                simpleValue: {
+                  '@value': dataType.initialValue,
+                },
+              }
+            : undefined,
+        })
+        break
+
+      case 'enumerated':
+        xml.project.types.dataTypes.dataType.push({
+          '@name': dataType.name,
+          baseType: {
+            enum: {
+              values: {
+                value: dataType.values.map((value) => {
+                  return {
+                    '@name': value.description,
+                  }
+                }),
+              },
+            },
+          },
+          initialValue: dataType.initialValue
+            ? {
+                simpleValue: {
+                  '@value': dataType.initialValue,
+                },
+              }
+            : undefined,
+        })
+        break
+
+      case 'structure':
+        xml.project.types.dataTypes.dataType.push({
+          '@name': dataType.name,
+          baseType: {
+            struct: {
+              variable: dataType.variable.map((variable) => {
+                switch (variable.type.definition) {
+                  case 'base-type':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        [variable.type.value === 'string' ? 'string' : variable.type.value.toUpperCase()]: '',
+                      },
+                      initialValue: variable.initialValue?.simpleValue.value
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue?.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                  case 'user-data-type':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        derived: { '@name': variable.type.value },
+                      },
+                      initialValue: variable.initialValue?.simpleValue.value
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue?.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                  case 'array':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        array: {
+                          dimension: parseDimensions(variable.type.data.dimensions),
+                          baseType: {
+                            [variable.type.data.baseType.definition === 'user-data-type'
+                              ? 'derived'
+                              : variable.type.data.baseType.value === 'string'
+                                ? 'string'
+                                : variable.type.data.baseType.value.toUpperCase()]:
+                              variable.type.data.baseType.definition === 'user-data-type'
+                                ? { '@name': variable.type.data.baseType.value }
+                                : '',
+                          },
+                        },
+                      },
+                      initialValue: variable.initialValue
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                  case 'derived':
+                    return {
+                      '@name': variable.name,
+                      type: {
+                        derived: { '@name': variable.type.value },
+                      },
+                      initialValue: variable.initialValue
+                        ? {
+                            simpleValue: {
+                              '@value': variable.initialValue.simpleValue.value,
+                            },
+                          }
+                        : undefined,
+                    }
+                }
+              }),
+            },
+          },
+        })
+    }
+  })
+
+  return xml
+}
diff --git a/src_old/utils/PLC/xml-generator/old-editor/index.ts b/src_old/utils/PLC/xml-generator/old-editor/index.ts
new file mode 100644
index 000000000..874bd2115
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/old-editor/index.ts
@@ -0,0 +1,5 @@
+export * from './base-xml'
+export * from './data-type-xml'
+export * from './instances-xml'
+export * from './pou-xml'
+export * from './type-xml'
diff --git a/src_old/utils/PLC/xml-generator/old-editor/instances-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/instances-xml.ts
new file mode 100644
index 000000000..3df25215f
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/old-editor/instances-xml.ts
@@ -0,0 +1,67 @@
+import { PLCConfiguration } from '@root/types/PLC/open-plc'
+import { BaseXml } from '@root/types/PLC/xml-data/old-editor'
+import { PouInstance, TaskXML } from '@root/types/PLC/xml-data/old-editor/task/task-diagram'
+import { VariableXML } from '@root/types/PLC/xml-data/old-editor/variable/variable-diagram'
+
+import { convertTypeToXml } from './type-xml'
+
+export const oldEditorInstanceToXml = (xml: BaseXml, configuration: PLCConfiguration) => {
+  const { instances, tasks, globalVariables } = configuration.resource
+
+  tasks.forEach((task) => {
+    const i: PouInstance[] =
+      instances
+        .filter((i) => i.task === task.name)
+        .map((i) => {
+          return {
+            '@name': i.name,
+            '@typeName': i.program,
+          }
+        }) || []
+
+    const t: TaskXML = {
+      '@name': task.name,
+      '@priority': task.priority.toString(),
+      '@interval': task.triggering === 'Cyclic' ? task.interval.toString() : null,
+      '@single': task.triggering === 'Interrupt' ? '' : null,
+      pouInstance: i,
+    }
+
+    if (!xml.project.instances.configurations.configuration.resource.task) {
+      xml.project.instances.configurations.configuration.resource.task = []
+    }
+    xml.project.instances.configurations.configuration.resource.task.push(t)
+  })
+
+  globalVariables.forEach((variable) => {
+    const v: VariableXML = {
+      '@name': variable.name,
+      '@address': variable.location || undefined,
+      type: convertTypeToXml(variable.type),
+      initialValue: variable.initialValue
+        ? {
+            simpleValue: {
+              '@value': variable.initialValue,
+            },
+          }
+        : null,
+      documentation: {
+        'xhtml:p': {
+          $: variable.documentation === '' ? ' ' : variable.documentation,
+        },
+      },
+    }
+
+    if (!xml.project.instances.configurations.configuration.globalVars) {
+      xml.project.instances.configurations.configuration.globalVars = {
+        variable: [],
+      }
+    }
+    if (!xml.project.instances.configurations.configuration.globalVars.variable) {
+      xml.project.instances.configurations.configuration.globalVars.variable = []
+    }
+    xml.project.instances.configurations.configuration.globalVars.variable.push(v)
+  })
+
+  return xml
+}
diff --git a/src/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts
rename to src_old/utils/PLC/xml-generator/old-editor/language/fbd-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/old-editor/language/il-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/language/il-xml.ts
new file mode 100644
index 000000000..0b70ca8b0
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/old-editor/language/il-xml.ts
@@ -0,0 +1,21 @@
+import { IlXML } from '@root/types/PLC/xml-data/old-editor'
+
+const ilToXML = (value: string) => {
+  const ilXML: {
+    body: {
+      IL: IlXML
+    }
+  } = {
+    body: {
+      IL: {
+        'xhtml:p': {
+          $: value,
+        },
+      },
+    },
+  }
+
+  return ilXML
+}
+
+export { ilToXML }
diff --git a/src/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts
rename to src_old/utils/PLC/xml-generator/old-editor/language/ladder-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/old-editor/language/st-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/language/st-xml.ts
new file mode 100644
index 000000000..1d09683f9
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/old-editor/language/st-xml.ts
@@ -0,0 +1,21 @@
+import { StXML } from '@root/types/PLC/xml-data/old-editor/pous/languages/st-diagram'
+
+const stToXML = (value: string) => {
+  const stXML: {
+    body: {
+      ST: StXML
+    }
+  } = {
+    body: {
+      ST: {
+        'xhtml:p': {
+          $: value,
+        },
+      },
+    },
+  }
+
+  return stXML
+}
+
+export { stToXML }
diff --git a/src/utils/PLC/xml-generator/old-editor/pou-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/pou-xml.ts
similarity index 100%
rename from src/utils/PLC/xml-generator/old-editor/pou-xml.ts
rename to src_old/utils/PLC/xml-generator/old-editor/pou-xml.ts
diff --git a/src_old/utils/PLC/xml-generator/old-editor/type-xml.ts b/src_old/utils/PLC/xml-generator/old-editor/type-xml.ts
new file mode 100644
index 000000000..66d41509a
--- /dev/null
+++ b/src_old/utils/PLC/xml-generator/old-editor/type-xml.ts
@@ -0,0 +1,45 @@
+import { PLCVariable } from '@root/types/PLC/open-plc'
+
+type VariableType = PLCVariable['type']
+
+/**
+ * Converts a PLC variable type to its XML representation for the old editor format.
+ * Handles base types, arrays, derived types, and user-data-types.
+ */
+export const convertTypeToXml = (type: VariableType): Record<string, unknown> => {
+  if (type.definition === 'array') {
+    return {
+      array: {
+        dimension: type.data.dimensions.map((dimension) => {
+          const lower = dimension.dimension.split('..')[0]
+          const upper = dimension.dimension.split('..')[1]
+          return {
+            '@lower': lower,
+            '@upper': upper,
+          }
+        }),
+        baseType: {
+          [type.data.baseType.definition === 'user-data-type'
+            ? 'derived'
+            : type.data.baseType.value === 'string'
+              ? type.data.baseType.value
+              : type.data.baseType.value.toUpperCase()]:
+            type.data.baseType.definition === 'user-data-type' ? { '@name': type.data.baseType.value } : '',
+        },
+      },
+    }
+  }
+
+  if (type.definition === 'derived' || type.definition === 'user-data-type') {
+    return {
+      derived: {
+        '@name': type.value,
+      },
+    }
+  }
+
+  // base-type
+  return {
+    [type.value === 'string' ? type.value : type.value.toUpperCase()]: '',
+  }
+}
diff --git a/src/utils/buffer-to-string-array.ts b/src_old/utils/buffer-to-string-array.ts
similarity index 100%
rename from src/utils/buffer-to-string-array.ts
rename to src_old/utils/buffer-to-string-array.ts
diff --git a/src/utils/classNames.ts b/src_old/utils/classNames.ts
similarity index 100%
rename from src/utils/classNames.ts
rename to src_old/utils/classNames.ts
diff --git a/src2/frontend/utils/cn.ts b/src_old/utils/cn.ts
similarity index 100%
rename from src2/frontend/utils/cn.ts
rename to src_old/utils/cn.ts
diff --git a/src/utils/constants.ts b/src_old/utils/constants.ts
similarity index 100%
rename from src/utils/constants.ts
rename to src_old/utils/constants.ts
diff --git a/src/utils/convertToPath.ts b/src_old/utils/convertToPath.ts
similarity index 100%
rename from src/utils/convertToPath.ts
rename to src_old/utils/convertToPath.ts
diff --git a/src/utils/cpp/addCppLocalVariables.ts b/src_old/utils/cpp/addCppLocalVariables.ts
similarity index 100%
rename from src/utils/cpp/addCppLocalVariables.ts
rename to src_old/utils/cpp/addCppLocalVariables.ts
diff --git a/src/utils/cpp/generateCBlocksCode.ts b/src_old/utils/cpp/generateCBlocksCode.ts
similarity index 100%
rename from src/utils/cpp/generateCBlocksCode.ts
rename to src_old/utils/cpp/generateCBlocksCode.ts
diff --git a/src/utils/cpp/generateCBlocksHeader.ts b/src_old/utils/cpp/generateCBlocksHeader.ts
similarity index 100%
rename from src/utils/cpp/generateCBlocksHeader.ts
rename to src_old/utils/cpp/generateCBlocksHeader.ts
diff --git a/src/utils/cpp/generateSTCode.ts b/src_old/utils/cpp/generateSTCode.ts
similarity index 100%
rename from src/utils/cpp/generateSTCode.ts
rename to src_old/utils/cpp/generateSTCode.ts
diff --git a/src_old/utils/cpp/validateCppCode.ts b/src_old/utils/cpp/validateCppCode.ts
new file mode 100644
index 000000000..d7cefd6b4
--- /dev/null
+++ b/src_old/utils/cpp/validateCppCode.ts
@@ -0,0 +1,30 @@
+type ValidationResult = {
+  valid: boolean
+  error?: string
+}
+
+const validateCppCode = (code: string): ValidationResult => {
+  const setupRegex = /void\s+setup\s*\(\s*\)/
+  const hasSetup = setupRegex.test(code)
+
+  if (!hasSetup) {
+    return {
+      valid: false,
+      error: 'C/C++ Function Block must declare a void setup() function',
+    }
+  }
+
+  const loopRegex = /void\s+loop\s*\(\s*\)/
+  const hasLoop = loopRegex.test(code)
+
+  if (!hasLoop) {
+    return {
+      valid: false,
+      error: 'C/C++ Function Block must declare a void loop() function',
+    }
+  }
+
+  return { valid: true }
+}
+
+export { validateCppCode, type ValidationResult }
diff --git a/src2/frontend/utils/debug-parser.ts b/src_old/utils/debug-parser.ts
similarity index 100%
rename from src2/frontend/utils/debug-parser.ts
rename to src_old/utils/debug-parser.ts
diff --git a/src/utils/debug-tree-traversal.ts b/src_old/utils/debug-tree-traversal.ts
similarity index 100%
rename from src/utils/debug-tree-traversal.ts
rename to src_old/utils/debug-tree-traversal.ts
diff --git a/src2/frontend/utils/debug-variable-finder.ts b/src_old/utils/debug-variable-finder.ts
similarity index 100%
rename from src2/frontend/utils/debug-variable-finder.ts
rename to src_old/utils/debug-variable-finder.ts
diff --git a/src_old/utils/default-zod-schema-values.ts b/src_old/utils/default-zod-schema-values.ts
new file mode 100644
index 000000000..d0b010b5e
--- /dev/null
+++ b/src_old/utils/default-zod-schema-values.ts
@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import {
+  ZodArray,
+  ZodBoolean,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodEnum,
+  ZodLiteral,
+  ZodNullable,
+  ZodNumber,
+  ZodObject,
+  ZodOptional,
+  ZodRecord,
+  ZodString,
+  ZodTuple,
+  ZodTypeAny,
+  ZodUnion,
+} from 'zod'
+
+export const getDefaultSchemaValues = (schema: ZodTypeAny): unknown => {
+  if (schema instanceof ZodDefault) return schema._def.defaultValue()
+  if (schema instanceof ZodObject) {
+    const shape = schema.shape
+    return Object.fromEntries(Object.entries(shape).map(([k, v]) => [k, getDefaultSchemaValues(v as ZodTypeAny)]))
+  }
+  if (schema instanceof ZodArray) return []
+  if (schema instanceof ZodString) return ''
+  if (schema instanceof ZodNumber) return 0
+  if (schema instanceof ZodBoolean) return false
+  if (schema instanceof ZodEnum) return schema.options[0]
+  if (schema instanceof ZodLiteral) return schema._def.value
+  if (schema instanceof ZodRecord) return {}
+  if (schema instanceof ZodNullable) return null
+  if (schema instanceof ZodOptional) return getDefaultSchemaValues(schema._def.innerType as ZodTypeAny)
+  if (schema instanceof ZodUnion) return getDefaultSchemaValues(schema._def.options[0] as ZodTypeAny)
+  if (schema instanceof ZodDiscriminatedUnion) return getDefaultSchemaValues(schema._def.options[0] as ZodTypeAny)
+  if (schema instanceof ZodTuple) return (schema.items as ZodTypeAny[]).map(getDefaultSchemaValues)
+  return null
+}
diff --git a/src/utils/device.ts b/src_old/utils/device.ts
similarity index 100%
rename from src/utils/device.ts
rename to src_old/utils/device.ts
diff --git a/src/utils/formatDate.ts b/src_old/utils/formatDate.ts
similarity index 100%
rename from src/utils/formatDate.ts
rename to src_old/utils/formatDate.ts
diff --git a/src/utils/formatTimestamp.ts b/src_old/utils/formatTimestamp.ts
similarity index 100%
rename from src/utils/formatTimestamp.ts
rename to src_old/utils/formatTimestamp.ts
diff --git a/src/utils/formatters/POU.ts b/src_old/utils/formatters/POU.ts
similarity index 100%
rename from src/utils/formatters/POU.ts
rename to src_old/utils/formatters/POU.ts
diff --git a/src/utils/formatters/index.ts b/src_old/utils/formatters/index.ts
similarity index 100%
rename from src/utils/formatters/index.ts
rename to src_old/utils/formatters/index.ts
diff --git a/src/utils/formatters/string.ts b/src_old/utils/formatters/string.ts
similarity index 100%
rename from src/utils/formatters/string.ts
rename to src_old/utils/formatters/string.ts
diff --git a/src/utils/generate-iec-string-to-variables.ts b/src_old/utils/generate-iec-string-to-variables.ts
similarity index 100%
rename from src/utils/generate-iec-string-to-variables.ts
rename to src_old/utils/generate-iec-string-to-variables.ts
diff --git a/src/utils/generate-iec-variables-to-string.ts b/src_old/utils/generate-iec-variables-to-string.ts
similarity index 100%
rename from src/utils/generate-iec-variables-to-string.ts
rename to src_old/utils/generate-iec-variables-to-string.ts
diff --git a/src/utils/generate-pou-copy-unique-name.ts b/src_old/utils/generate-pou-copy-unique-name.ts
similarity index 100%
rename from src/utils/generate-pou-copy-unique-name.ts
rename to src_old/utils/generate-pou-copy-unique-name.ts
diff --git a/src/utils/generate-string-to-instance-configuration.ts b/src_old/utils/generate-string-to-instance-configuration.ts
similarity index 100%
rename from src/utils/generate-string-to-instance-configuration.ts
rename to src_old/utils/generate-string-to-instance-configuration.ts
diff --git a/src/utils/generateUUID.ts b/src_old/utils/generateUUID.ts
similarity index 100%
rename from src/utils/generateUUID.ts
rename to src_old/utils/generateUUID.ts
diff --git a/src/utils/i18n.ts b/src_old/utils/i18n.ts
similarity index 100%
rename from src/utils/i18n.ts
rename to src_old/utils/i18n.ts
diff --git a/src/utils/index.ts b/src_old/utils/index.ts
similarity index 100%
rename from src/utils/index.ts
rename to src_old/utils/index.ts
diff --git a/src2/frontend/utils/keywords.ts b/src_old/utils/keywords.ts
similarity index 100%
rename from src2/frontend/utils/keywords.ts
rename to src_old/utils/keywords.ts
diff --git a/src/utils/mac-address-parser.ts b/src_old/utils/mac-address-parser.ts
similarity index 100%
rename from src/utils/mac-address-parser.ts
rename to src_old/utils/mac-address-parser.ts
diff --git a/src/utils/migrate-project-to-name-type-system.ts b/src_old/utils/migrate-project-to-name-type-system.ts
similarity index 100%
rename from src/utils/migrate-project-to-name-type-system.ts
rename to src_old/utils/migrate-project-to-name-type-system.ts
diff --git a/src/utils/modbus/generate-modbus-master-config.ts b/src_old/utils/modbus/generate-modbus-master-config.ts
similarity index 100%
rename from src/utils/modbus/generate-modbus-master-config.ts
rename to src_old/utils/modbus/generate-modbus-master-config.ts
diff --git a/src/utils/modbus/generate-modbus-slave-config.ts b/src_old/utils/modbus/generate-modbus-slave-config.ts
similarity index 100%
rename from src/utils/modbus/generate-modbus-slave-config.ts
rename to src_old/utils/modbus/generate-modbus-slave-config.ts
diff --git a/src2/frontend/utils/new-graphical-editor-node-id.ts b/src_old/utils/new-graphical-editor-node-id.ts
similarity index 100%
rename from src2/frontend/utils/new-graphical-editor-node-id.ts
rename to src_old/utils/new-graphical-editor-node-id.ts
diff --git a/src/utils/object-to-yaml.ts b/src_old/utils/object-to-yaml.ts
similarity index 100%
rename from src/utils/object-to-yaml.ts
rename to src_old/utils/object-to-yaml.ts
diff --git a/src_old/utils/opcua/__tests__/generate-opcua-config.test.ts b/src_old/utils/opcua/__tests__/generate-opcua-config.test.ts
new file mode 100644
index 000000000..8050c4f2a
--- /dev/null
+++ b/src_old/utils/opcua/__tests__/generate-opcua-config.test.ts
@@ -0,0 +1,548 @@
+import type { OpcUaServerConfig, PLCServer } from '@root/types/PLC/open-plc'
+
+import { generateOpcUaConfig, parseDebugFile, validateOpcUaConfig } from '../generate-opcua-config'
+import { OpcUaConfigError, resolveArrayIndex, resolveStructureIndices, resolveVariableIndex } from '../resolve-indices'
+import type { PLCInstanceInfo } from '../types'
+
+// Sample debug.c content for testing
+// Uses INSTANCE0 as the instance name (matching the sampleInstances below)
+const sampleDebugContent = `
+#define VAR_COUNT 18
+
+debug_vars_t debug_vars[] = {
+  { &(RES0__INSTANCE0.MOTOR_SPEED), INT_ENUM },
+  { &(RES0__INSTANCE0.TEMPERATURE), REAL_ENUM },
+  { &(RES0__INSTANCE0.IS_RUNNING), BOOL_ENUM },
+  { &(RES0__INSTANCE0.SENSOR.value.TEMP), REAL_ENUM },
+  { &(RES0__INSTANCE0.SENSOR.value.PRESSURE), REAL_ENUM },
+  { &(RES0__INSTANCE0.TEMPS.value.table[0]), REAL_ENUM },
+  { &(RES0__INSTANCE0.TEMPS.value.table[1]), REAL_ENUM },
+  { &(RES0__INSTANCE0.TEMPS.value.table[2]), REAL_ENUM },
+  { &(CONFIG0__GLOBAL_VAR), INT_ENUM },
+  { &(CONFIG0__SYSTEM_STATE), BOOL_ENUM },
+  { &(RES0__INSTANCE0.TIMER0.ET), TIME_ENUM },
+  { &(RES0__INSTANCE0.TIMER0.Q), BOOL_ENUM },
+  { &(RES0__INSTANCE0.NESTED_STRUCT.value.INNER.value.VALUE1), INT_ENUM },
+  { &(RES0__INSTANCE0.NESTED_STRUCT.value.INNER.value.VALUE2), REAL_ENUM },
+  { &(RES0__INSTANCE0.FB_ARRAY.value.table[0].ET), TIME_ENUM },
+  { &(RES0__INSTANCE0.FB_ARRAY.value.table[0].Q), BOOL_ENUM },
+  { &(RES0__INSTANCE0.FB_ARRAY.value.table[1].ET), TIME_ENUM },
+  { &(RES0__INSTANCE0.FB_ARRAY.value.table[1].Q), BOOL_ENUM },
+};
+`
+
+// Sample instances array representing the Resources configuration
+const sampleInstances: PLCInstanceInfo[] = [
+  {
+    name: 'INSTANCE0',
+    task: 'Task0',
+    program: 'main',
+  },
+]
+
+// Sample OPC-UA server configuration
+const createSampleConfig = (): OpcUaServerConfig => ({
+  server: {
+    enabled: true,
+    name: 'Test OPC-UA Server',
+    applicationUri: 'urn:test:opcua:server',
+    productUri: 'urn:test:runtime',
+    bindAddress: '0.0.0.0',
+    port: 4840,
+    endpointPath: '/test/opcua',
+  },
+  cycleTimeMs: 100,
+  securityProfiles: [
+    {
+      id: 'profile-1',
+      name: 'insecure',
+      enabled: true,
+      securityPolicy: 'None',
+      securityMode: 'None',
+      authMethods: ['Anonymous'],
+    },
+  ],
+  security: {
+    serverCertificateStrategy: 'auto_self_signed',
+    serverCertificateCustom: null,
+    serverPrivateKeyCustom: null,
+    trustedClientCertificates: [],
+  },
+  users: [
+    {
+      id: 'user-1',
+      type: 'password',
+      username: 'admin',
+      passwordHash: '$2b$12$test',
+      certificateId: null,
+      role: 'engineer',
+    },
+  ],
+  addressSpace: {
+    namespaceUri: 'urn:test:opcua:namespace',
+    nodes: [],
+  },
+})
+
+describe('parseDebugFile', () => {
+  it('should parse debug variables from debug.c content', () => {
+    const variables = parseDebugFile(sampleDebugContent)
+
+    expect(variables).toHaveLength(18)
+    expect(variables[0]).toEqual({
+      name: 'RES0__INSTANCE0.MOTOR_SPEED',
+      type: 'INT_ENUM',
+      index: 0,
+    })
+    expect(variables[8]).toEqual({
+      name: 'CONFIG0__GLOBAL_VAR',
+      type: 'INT_ENUM',
+      index: 8,
+    })
+  })
+
+  it('should return empty array for invalid content', () => {
+    const variables = parseDebugFile('no debug vars here')
+    expect(variables).toHaveLength(0)
+  })
+
+  it('should handle empty content', () => {
+    const variables = parseDebugFile('')
+    expect(variables).toHaveLength(0)
+  })
+})
+
+describe('resolveVariableIndex', () => {
+  const debugVariables = parseDebugFile(sampleDebugContent)
+
+  it('should resolve simple program variable', () => {
+    const node = {
+      id: 'test-1',
+      pouName: 'main',
+      variablePath: 'MOTOR_SPEED',
+      variableType: 'INT',
+      nodeId: 'PLC.Main.MotorSpeed',
+      browseName: 'MotorSpeed',
+      displayName: 'Motor Speed',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'variable' as const,
+    }
+
+    const index = resolveVariableIndex(node, debugVariables, sampleInstances)
+    expect(index).toBe(0)
+  })
+
+  it('should resolve global variable', () => {
+    const node = {
+      id: 'test-2',
+      pouName: 'GVL',
+      variablePath: 'GLOBAL_VAR',
+      variableType: 'INT',
+      nodeId: 'PLC.GVL.GlobalVar',
+      browseName: 'GlobalVar',
+      displayName: 'Global Variable',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'variable' as const,
+    }
+
+    const index = resolveVariableIndex(node, debugVariables, sampleInstances)
+    expect(index).toBe(8)
+  })
+
+  it('should throw error for non-existent variable', () => {
+    const node = {
+      id: 'test-3',
+      pouName: 'main',
+      variablePath: 'NON_EXISTENT',
+      variableType: 'INT',
+      nodeId: 'PLC.Main.NonExistent',
+      browseName: 'NonExistent',
+      displayName: 'Non Existent',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'variable' as const,
+    }
+
+    expect(() => resolveVariableIndex(node, debugVariables, sampleInstances)).toThrow(OpcUaConfigError)
+  })
+
+  it('should throw error when program has no instance in Resources', () => {
+    const node = {
+      id: 'test-4',
+      pouName: 'unknown_program',
+      variablePath: 'SOME_VAR',
+      variableType: 'INT',
+      nodeId: 'PLC.Unknown.SomeVar',
+      browseName: 'SomeVar',
+      displayName: 'Some Var',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'variable' as const,
+    }
+
+    expect(() => resolveVariableIndex(node, debugVariables, sampleInstances)).toThrow(OpcUaConfigError)
+  })
+})
+
+describe('resolveArrayIndex', () => {
+  const debugVariables = parseDebugFile(sampleDebugContent)
+
+  it('should resolve array starting index', () => {
+    const node = {
+      id: 'test-4',
+      pouName: 'main',
+      variablePath: 'TEMPS',
+      variableType: 'ARRAY[0..2] OF REAL',
+      nodeId: 'PLC.Main.Temps',
+      browseName: 'Temps',
+      displayName: 'Temperatures',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'array' as const,
+      arrayLength: 3,
+      elementType: 'REAL',
+    }
+
+    const index = resolveArrayIndex(node, debugVariables, sampleInstances)
+    expect(index).toBe(5) // First element [0] is at index 5
+  })
+})
+
+describe('resolveStructureIndices', () => {
+  const debugVariables = parseDebugFile(sampleDebugContent)
+
+  it('should resolve structure field indices', () => {
+    const node = {
+      id: 'test-5',
+      pouName: 'main',
+      variablePath: 'SENSOR',
+      variableType: 'SensorData',
+      nodeId: 'PLC.Main.Sensor',
+      browseName: 'Sensor',
+      displayName: 'Sensor Data',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'structure' as const,
+      fields: [
+        {
+          fieldPath: 'TEMP',
+          displayName: 'Temperature',
+          datatype: 'REAL',
+          initialValue: 0.0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: 'PRESSURE',
+          displayName: 'Pressure',
+          datatype: 'REAL',
+          initialValue: 0.0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+      ],
+    }
+
+    const resolvedFields = resolveStructureIndices(node, debugVariables, sampleInstances)
+    expect(resolvedFields).toHaveLength(2)
+    expect(resolvedFields[0].index).toBe(3) // SENSOR.value.TEMP
+    expect(resolvedFields[0].datatype).toBe('REAL') // Converted from REAL_ENUM
+    expect(resolvedFields[1].index).toBe(4) // SENSOR.value.PRESSURE
+    expect(resolvedFields[1].datatype).toBe('REAL') // Converted from REAL_ENUM
+  })
+
+  it('should convert debug.c type enums to IEC types', () => {
+    // This test verifies that types like "INT_ENUM", "BOOL_ENUM" are converted to "INT", "BOOL"
+    const node = {
+      id: 'test-fb-types',
+      pouName: 'main',
+      variablePath: 'TIMER0',
+      variableType: 'TON',
+      nodeId: 'PLC.Main.Timer0',
+      browseName: 'Timer0',
+      displayName: 'Timer 0',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'structure' as const,
+      fields: [
+        {
+          fieldPath: 'ET',
+          displayName: 'Elapsed Time',
+          datatype: 'TIME',
+          initialValue: 0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: 'Q',
+          displayName: 'Output',
+          datatype: 'BOOL',
+          initialValue: false,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+      ],
+    }
+
+    const resolvedFields = resolveStructureIndices(node, debugVariables, sampleInstances)
+    // TIME_ENUM should be converted to TIME
+    expect(resolvedFields[0].datatype).toBe('TIME')
+    // BOOL_ENUM should be converted to BOOL
+    expect(resolvedFields[1].datatype).toBe('BOOL')
+  })
+
+  it('should resolve function block with expanded leaf fields', () => {
+    // FB instance with its leaf variables expanded (like TON with ET and Q)
+    const node = {
+      id: 'test-fb-1',
+      pouName: 'main',
+      variablePath: 'TIMER0',
+      variableType: 'TON',
+      nodeId: 'PLC.Main.Timer0',
+      browseName: 'Timer0',
+      displayName: 'Timer 0',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'structure' as const, // FBs use 'structure' nodeType
+      fields: [
+        {
+          fieldPath: 'ET',
+          displayName: 'Elapsed Time',
+          datatype: 'TIME',
+          initialValue: 0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: 'Q',
+          displayName: 'Output',
+          datatype: 'BOOL',
+          initialValue: false,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+      ],
+    }
+
+    const resolvedFields = resolveStructureIndices(node, debugVariables, sampleInstances)
+    expect(resolvedFields).toHaveLength(2)
+    expect(resolvedFields[0].index).toBe(10) // TIMER0.ET (FB-style path, no .value.)
+    expect(resolvedFields[1].index).toBe(11) // TIMER0.Q
+  })
+
+  it('should resolve nested structure with deep field paths', () => {
+    // Nested structure: NESTED_STRUCT.INNER.VALUE1, NESTED_STRUCT.INNER.VALUE2
+    const node = {
+      id: 'test-nested-1',
+      pouName: 'main',
+      variablePath: 'NESTED_STRUCT',
+      variableType: 'OuterStruct',
+      nodeId: 'PLC.Main.NestedStruct',
+      browseName: 'NestedStruct',
+      displayName: 'Nested Structure',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'structure' as const,
+      fields: [
+        {
+          fieldPath: 'INNER.VALUE1',
+          displayName: 'Inner Value 1',
+          datatype: 'INT',
+          initialValue: 0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: 'INNER.VALUE2',
+          displayName: 'Inner Value 2',
+          datatype: 'REAL',
+          initialValue: 0.0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+      ],
+    }
+
+    const resolvedFields = resolveStructureIndices(node, debugVariables, sampleInstances)
+    expect(resolvedFields).toHaveLength(2)
+    expect(resolvedFields[0].index).toBe(12) // NESTED_STRUCT.value.INNER.value.VALUE1
+    expect(resolvedFields[1].index).toBe(13) // NESTED_STRUCT.value.INNER.value.VALUE2
+  })
+
+  it('should resolve array of FBs with expanded leaf fields', () => {
+    // Array of FBs: FB_ARRAY[0].ET, FB_ARRAY[0].Q, FB_ARRAY[1].ET, FB_ARRAY[1].Q
+    const node = {
+      id: 'test-fb-array-1',
+      pouName: 'main',
+      variablePath: 'FB_ARRAY',
+      variableType: 'ARRAY[0..1] OF TON',
+      nodeId: 'PLC.Main.FbArray',
+      browseName: 'FbArray',
+      displayName: 'FB Array',
+      description: '',
+      initialValue: 0,
+      permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+      nodeType: 'array' as const,
+      arrayLength: 2,
+      elementType: 'TON',
+      fields: [
+        {
+          fieldPath: '[0].ET',
+          displayName: '[0] Elapsed Time',
+          datatype: 'TIME',
+          initialValue: 0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: '[0].Q',
+          displayName: '[0] Output',
+          datatype: 'BOOL',
+          initialValue: false,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: '[1].ET',
+          displayName: '[1] Elapsed Time',
+          datatype: 'TIME',
+          initialValue: 0,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+        {
+          fieldPath: '[1].Q',
+          displayName: '[1] Output',
+          datatype: 'BOOL',
+          initialValue: false,
+          permissions: { viewer: 'r' as const, operator: 'r' as const, engineer: 'rw' as const },
+        },
+      ],
+    }
+
+    // Arrays with fields are treated like structures for resolution
+    const resolvedFields = resolveStructureIndices(node, debugVariables, sampleInstances)
+    expect(resolvedFields).toHaveLength(4)
+    expect(resolvedFields[0].index).toBe(14) // FB_ARRAY[0].ET
+    expect(resolvedFields[1].index).toBe(15) // FB_ARRAY[0].Q
+    expect(resolvedFields[2].index).toBe(16) // FB_ARRAY[1].ET
+    expect(resolvedFields[3].index).toBe(17) // FB_ARRAY[1].Q
+  })
+})
+
+describe('generateOpcUaConfig', () => {
+  it('should return null when no servers configured', () => {
+    const result = generateOpcUaConfig(undefined, sampleDebugContent, sampleInstances)
+    expect(result).toBeNull()
+  })
+
+  it('should return null when no OPC-UA server configured', () => {
+    const servers: PLCServer[] = [
+      {
+        name: 'modbus-server',
+        protocol: 'modbus-tcp',
+      },
+    ]
+    const result = generateOpcUaConfig(servers, sampleDebugContent, sampleInstances)
+    expect(result).toBeNull()
+  })
+
+  it('should return null when OPC-UA server is disabled', () => {
+    const config = createSampleConfig()
+    config.server.enabled = false
+
+    const servers: PLCServer[] = [
+      {
+        name: 'opcua-server',
+        protocol: 'opcua',
+        opcuaServerConfig: config,
+      },
+    ]
+
+    const result = generateOpcUaConfig(servers, sampleDebugContent, sampleInstances)
+    expect(result).toBeNull()
+  })
+
+  it('should generate valid JSON for enabled OPC-UA server', () => {
+    const config = createSampleConfig()
+    config.addressSpace.nodes = [
+      {
+        id: 'node-1',
+        pouName: 'main',
+        variablePath: 'MOTOR_SPEED',
+        variableType: 'INT',
+        nodeId: 'PLC.Main.MotorSpeed',
+        browseName: 'MotorSpeed',
+        displayName: 'Motor Speed',
+        description: 'Motor speed in RPM',
+        initialValue: 0,
+        permissions: { viewer: 'r', operator: 'rw', engineer: 'rw' },
+        nodeType: 'variable',
+      },
+    ]
+
+    const servers: PLCServer[] = [
+      {
+        name: 'opcua-server',
+        protocol: 'opcua',
+        opcuaServerConfig: config,
+      },
+    ]
+
+    const result = generateOpcUaConfig(servers, sampleDebugContent, sampleInstances)
+    expect(result).not.toBeNull()
+
+    const parsed = JSON.parse(result!)
+    expect(parsed).toBeInstanceOf(Array)
+    expect(parsed).toHaveLength(1)
+    expect(parsed[0].name).toBe('opcua_server')
+    expect(parsed[0].protocol).toBe('OPC-UA')
+    expect(parsed[0].config.server.endpoint_url).toBe('opc.tcp://0.0.0.0:4840/test/opcua')
+    expect(parsed[0].config.address_space.variables).toHaveLength(1)
+    expect(parsed[0].config.address_space.variables[0].index).toBe(0)
+  })
+})
+
+describe('validateOpcUaConfig', () => {
+  it('should return valid when config is correct', () => {
+    const config = createSampleConfig()
+    config.addressSpace.nodes = [
+      {
+        id: 'node-1',
+        pouName: 'main',
+        variablePath: 'MOTOR_SPEED',
+        variableType: 'INT',
+        nodeId: 'PLC.Main.MotorSpeed',
+        browseName: 'MotorSpeed',
+        displayName: 'Motor Speed',
+        description: '',
+        initialValue: 0,
+        permissions: { viewer: 'r', operator: 'r', engineer: 'rw' },
+        nodeType: 'variable',
+      },
+    ]
+
+    const result = validateOpcUaConfig(config, sampleDebugContent, sampleInstances)
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('should return errors when no security profiles enabled', () => {
+    const config = createSampleConfig()
+    config.securityProfiles[0].enabled = false
+
+    const result = validateOpcUaConfig(config, sampleDebugContent, sampleInstances)
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContain('At least one security profile must be enabled')
+  })
+
+  it('should return errors when username auth enabled without users', () => {
+    const config = createSampleConfig()
+    config.securityProfiles[0].authMethods = ['Username']
+    config.users = []
+
+    const result = validateOpcUaConfig(config, sampleDebugContent, sampleInstances)
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContain('Username authentication is enabled but no users are configured')
+  })
+})
diff --git a/src/utils/opcua/generate-opcua-config.ts b/src_old/utils/opcua/generate-opcua-config.ts
similarity index 100%
rename from src/utils/opcua/generate-opcua-config.ts
rename to src_old/utils/opcua/generate-opcua-config.ts
diff --git a/src_old/utils/opcua/index.ts b/src_old/utils/opcua/index.ts
new file mode 100644
index 000000000..e36b89b89
--- /dev/null
+++ b/src_old/utils/opcua/index.ts
@@ -0,0 +1,25 @@
+/**
+ * OPC-UA Configuration Utilities
+ *
+ * This module provides utilities for generating OPC-UA server configuration
+ * for the OpenPLC Runtime.
+ */
+
+export type {
+  RuntimeAddressSpace,
+  RuntimeArray,
+  RuntimeConfig,
+  RuntimePluginConfig,
+  RuntimeSecurityConfig,
+  RuntimeSecurityProfile,
+  RuntimeServerConfig,
+  RuntimeStructure,
+  RuntimeStructureField,
+  RuntimeTrustedCertificate,
+  RuntimeUser,
+  RuntimeVariable,
+  RuntimeVariablePermissions,
+} from './generate-opcua-config'
+export { generateOpcUaConfig, parseDebugFile, validateOpcUaConfig } from './generate-opcua-config'
+export { OpcUaConfigError, resolveArrayIndex, resolveStructureIndices, resolveVariableIndex } from './resolve-indices'
+export type { DebugVariable, PLCInstanceInfo, ResolvedField } from './types'
diff --git a/src/utils/opcua/resolve-indices.ts b/src_old/utils/opcua/resolve-indices.ts
similarity index 100%
rename from src/utils/opcua/resolve-indices.ts
rename to src_old/utils/opcua/resolve-indices.ts
diff --git a/src_old/utils/opcua/types.ts b/src_old/utils/opcua/types.ts
new file mode 100644
index 000000000..d3ce144e4
--- /dev/null
+++ b/src_old/utils/opcua/types.ts
@@ -0,0 +1,48 @@
+/**
+ * OPC-UA Configuration Types
+ * Types used for OPC-UA config generation and index resolution.
+ */
+
+/**
+ * Represents a PLC instance (program instantiation in Resources).
+ * Used to look up the instance name for a given program POU.
+ */
+export interface PLCInstanceInfo {
+  /** Instance name (e.g., "INSTANCE0") - this appears in debug.c */
+  name: string
+  /** Task name this instance runs under */
+  task: string
+  /** Program POU name being instantiated */
+  program: string
+}
+
+/**
+ * Represents a debug variable parsed from debug.c
+ */
+export interface DebugVariable {
+  /** Full variable path (e.g., "RES0__INSTANCE0.MOTOR_SPEED") */
+  name: string
+  /** IEC type (e.g., "INT", "BOOL", "REAL") */
+  type: string
+  /** Index in the debug_vars array */
+  index: number
+}
+
+/**
+ * Resolved field information for structures.
+ * Supports nested fields for complex types (FBs, structs within structs).
+ */
+export interface ResolvedField {
+  name: string
+  datatype: string
+  initialValue: boolean | number | string
+  /** Index in debug_vars array. Null for complex types that have nested fields. */
+  index: number | null
+  permissions: {
+    viewer: 'r' | 'w' | 'rw'
+    operator: 'r' | 'w' | 'rw'
+    engineer: 'r' | 'w' | 'rw'
+  }
+  /** Nested fields for complex types (FB instances, nested structs) */
+  fields?: ResolvedField[]
+}
diff --git a/src/utils/parse-resource-configuration-to-string.ts b/src_old/utils/parse-resource-configuration-to-string.ts
similarity index 100%
rename from src/utils/parse-resource-configuration-to-string.ts
rename to src_old/utils/parse-resource-configuration-to-string.ts
diff --git a/src/utils/parse-resource-string-to-configuration.ts b/src_old/utils/parse-resource-string-to-configuration.ts
similarity index 100%
rename from src/utils/parse-resource-string-to-configuration.ts
rename to src_old/utils/parse-resource-string-to-configuration.ts
diff --git a/src_old/utils/plc-status.ts b/src_old/utils/plc-status.ts
new file mode 100644
index 000000000..4de686e24
--- /dev/null
+++ b/src_old/utils/plc-status.ts
@@ -0,0 +1,22 @@
+import type { PlcStatus } from '@root/types/plc-status'
+import { isValidPlcStatus } from '@root/types/plc-status'
+
+/**
+ * Parses raw PLC status string from the runtime API
+ * Removes the 'STATUS:' prefix, newlines, and trims whitespace
+ *
+ * @param rawStatus - Raw status string from the runtime (e.g., "STATUS:RUNNING\n")
+ * @returns Cleaned status string or null if invalid
+ *
+ * @example
+ * parsePlcStatus("STATUS:RUNNING\n") // returns "RUNNING"
+ * parsePlcStatus("STOPPED") // returns "STOPPED"
+ * parsePlcStatus("INVALID") // returns null
+ */
+export function parsePlcStatus(rawStatus: string): PlcStatus | null {
+  const cleaned = rawStatus
+    .replace(/^STATUS:\s*/, '')
+    .replace(/[\r\n]+/g, '')
+    .trim()
+  return isValidPlcStatus(cleaned) ? cleaned : null
+}
diff --git a/src/utils/pou-helpers.ts b/src_old/utils/pou-helpers.ts
similarity index 100%
rename from src/utils/pou-helpers.ts
rename to src_old/utils/pou-helpers.ts
diff --git a/src/utils/python/addPythonLocalVariables.ts b/src_old/utils/python/addPythonLocalVariables.ts
similarity index 100%
rename from src/utils/python/addPythonLocalVariables.ts
rename to src_old/utils/python/addPythonLocalVariables.ts
diff --git a/src/utils/python/encodeCharactersFromVariable.ts b/src_old/utils/python/encodeCharactersFromVariable.ts
similarity index 100%
rename from src/utils/python/encodeCharactersFromVariable.ts
rename to src_old/utils/python/encodeCharactersFromVariable.ts
diff --git a/src/utils/python/generateSTCode.ts b/src_old/utils/python/generateSTCode.ts
similarity index 100%
rename from src/utils/python/generateSTCode.ts
rename to src_old/utils/python/generateSTCode.ts
diff --git a/src/utils/python/injectPythonCode.ts b/src_old/utils/python/injectPythonCode.ts
similarity index 100%
rename from src/utils/python/injectPythonCode.ts
rename to src_old/utils/python/injectPythonCode.ts
diff --git a/src/utils/python/injectPythonRuntime.ts b/src_old/utils/python/injectPythonRuntime.ts
similarity index 100%
rename from src/utils/python/injectPythonRuntime.ts
rename to src_old/utils/python/injectPythonRuntime.ts
diff --git a/src_old/utils/runtime-https-config.ts b/src_old/utils/runtime-https-config.ts
new file mode 100644
index 000000000..5f202037c
--- /dev/null
+++ b/src_old/utils/runtime-https-config.ts
@@ -0,0 +1,4 @@
+export function getRuntimeHttpsOptions(): { rejectUnauthorized: boolean } {
+  const shouldReject = process.env.RUNTIME_TLS_REJECT_UNAUTHORIZED === 'true'
+  return { rejectUnauthorized: shouldReject }
+}
diff --git a/src_old/utils/s7comm/generate-s7comm-config.ts b/src_old/utils/s7comm/generate-s7comm-config.ts
new file mode 100644
index 000000000..7146529f7
--- /dev/null
+++ b/src_old/utils/s7comm/generate-s7comm-config.ts
@@ -0,0 +1,193 @@
+import type { PLCServer } from '@root/types/PLC/open-plc'
+
+/**
+ * S7Comm Runtime Configuration Interfaces
+ * These interfaces define the JSON structure expected by the OpenPLC Runtime S7Comm plugin.
+ * The runtime uses snake_case naming convention, while the editor uses camelCase.
+ */
+
+interface S7CommRuntimeServerConfig {
+  enabled: boolean
+  bind_address: string
+  port: number
+  max_clients: number
+  work_interval_ms: number
+  send_timeout_ms: number
+  recv_timeout_ms: number
+  ping_timeout_ms: number
+  pdu_size: number
+}
+
+interface S7CommRuntimePlcIdentity {
+  name: string
+  module_type: string
+  serial_number: string
+  copyright: string
+  module_name: string
+}
+
+interface S7CommRuntimeBufferMapping {
+  type: string
+  start_buffer: number
+  bit_addressing?: boolean
+}
+
+interface S7CommRuntimeDataBlock {
+  db_number: number
+  description: string
+  size_bytes: number
+  mapping: S7CommRuntimeBufferMapping
+}
+
+interface S7CommRuntimeSystemArea {
+  enabled: boolean
+  size_bytes: number
+  mapping?: S7CommRuntimeBufferMapping
+}
+
+interface S7CommRuntimeSystemAreas {
+  pe_area?: S7CommRuntimeSystemArea
+  pa_area?: S7CommRuntimeSystemArea
+  mk_area?: S7CommRuntimeSystemArea
+}
+
+interface S7CommRuntimeLogging {
+  log_connections: boolean
+  log_data_access: boolean
+  log_errors: boolean
+}
+
+interface S7CommRuntimeConfig {
+  server: S7CommRuntimeServerConfig
+  plc_identity?: S7CommRuntimePlcIdentity
+  data_blocks: S7CommRuntimeDataBlock[]
+  system_areas?: S7CommRuntimeSystemAreas
+  logging?: S7CommRuntimeLogging
+}
+
+/**
+ * Generates the S7Comm configuration JSON for the runtime plugin.
+ * Converts camelCase properties to snake_case expected by the C plugin.
+ *
+ * @param servers - Array of configured PLC servers
+ * @returns JSON string for s7comm.json or null if no enabled S7Comm server
+ */
+export const generateS7CommConfig = (servers: PLCServer[] | undefined): string | null => {
+  if (!servers || servers.length === 0) {
+    return null
+  }
+
+  const s7commServer = servers.find((server) => server.protocol === 's7comm' && server.s7commSlaveConfig)
+
+  if (!s7commServer || !s7commServer.s7commSlaveConfig) {
+    return null
+  }
+
+  const config = s7commServer.s7commSlaveConfig
+
+  // Build the runtime configuration object
+  const runtimeConfig: S7CommRuntimeConfig = {
+    server: {
+      enabled: config.server.enabled,
+      bind_address: config.server.bindAddress,
+      port: config.server.port,
+      max_clients: config.server.maxClients,
+      work_interval_ms: config.server.workIntervalMs,
+      send_timeout_ms: config.server.sendTimeoutMs,
+      recv_timeout_ms: config.server.recvTimeoutMs,
+      ping_timeout_ms: config.server.pingTimeoutMs,
+      pdu_size: config.server.pduSize,
+    },
+    data_blocks: config.dataBlocks.map((db) => ({
+      db_number: db.dbNumber,
+      description: db.description,
+      size_bytes: db.sizeBytes,
+      mapping: {
+        type: db.mapping.type,
+        start_buffer: db.mapping.startBuffer,
+        ...(db.mapping.bitAddressing && { bit_addressing: db.mapping.bitAddressing }),
+      },
+    })),
+  }
+
+  // Add PLC identity if present
+  if (config.plcIdentity) {
+    runtimeConfig.plc_identity = {
+      name: config.plcIdentity.name,
+      module_type: config.plcIdentity.moduleType,
+      serial_number: config.plcIdentity.serialNumber,
+      copyright: config.plcIdentity.copyright,
+      module_name: config.plcIdentity.moduleName,
+    }
+  }
+
+  // Add system areas if present
+  if (config.systemAreas) {
+    const systemAreas: S7CommRuntimeSystemAreas = {}
+
+    if (config.systemAreas.peArea) {
+      systemAreas.pe_area = {
+        enabled: config.systemAreas.peArea.enabled,
+        size_bytes: config.systemAreas.peArea.sizeBytes,
+        ...(config.systemAreas.peArea.mapping && {
+          mapping: {
+            type: config.systemAreas.peArea.mapping.type,
+            start_buffer: config.systemAreas.peArea.mapping.startBuffer,
+          },
+        }),
+      }
+    }
+
+    if (config.systemAreas.paArea) {
+      systemAreas.pa_area = {
+        enabled: config.systemAreas.paArea.enabled,
+        size_bytes: config.systemAreas.paArea.sizeBytes,
+        ...(config.systemAreas.paArea.mapping && {
+          mapping: {
+            type: config.systemAreas.paArea.mapping.type,
+            start_buffer: config.systemAreas.paArea.mapping.startBuffer,
+          },
+        }),
+      }
+    }
+
+    if (config.systemAreas.mkArea) {
+      systemAreas.mk_area = {
+        enabled: config.systemAreas.mkArea.enabled,
+        size_bytes: config.systemAreas.mkArea.sizeBytes,
+        ...(config.systemAreas.mkArea.mapping && {
+          mapping: {
+            type: config.systemAreas.mkArea.mapping.type,
+            start_buffer: config.systemAreas.mkArea.mapping.startBuffer,
+          },
+        }),
+      }
+    }
+
+    if (Object.keys(systemAreas).length > 0) {
+      runtimeConfig.system_areas = systemAreas
+    }
+  }
+
+  // Add logging if present
+  if (config.logging) {
+    runtimeConfig.logging = {
+      log_connections: config.logging.logConnections,
+      log_data_access: config.logging.logDataAccess,
+      log_errors: config.logging.logErrors,
+    }
+  }
+
+  return JSON.stringify(runtimeConfig, null, 2)
+}
+
+export type {
+  S7CommRuntimeBufferMapping,
+  S7CommRuntimeConfig,
+  S7CommRuntimeDataBlock,
+  S7CommRuntimeLogging,
+  S7CommRuntimePlcIdentity,
+  S7CommRuntimeServerConfig,
+  S7CommRuntimeSystemArea,
+  S7CommRuntimeSystemAreas,
+}
diff --git a/src_old/utils/s7comm/index.ts b/src_old/utils/s7comm/index.ts
new file mode 100644
index 000000000..99d79f35c
--- /dev/null
+++ b/src_old/utils/s7comm/index.ts
@@ -0,0 +1,11 @@
+export type {
+  S7CommRuntimeBufferMapping,
+  S7CommRuntimeConfig,
+  S7CommRuntimeDataBlock,
+  S7CommRuntimeLogging,
+  S7CommRuntimePlcIdentity,
+  S7CommRuntimeServerConfig,
+  S7CommRuntimeSystemArea,
+  S7CommRuntimeSystemAreas,
+} from './generate-s7comm-config'
+export { generateS7CommConfig } from './generate-s7comm-config'
diff --git a/src/utils/svg-path-to-xy.ts b/src_old/utils/svg-path-to-xy.ts
similarity index 100%
rename from src/utils/svg-path-to-xy.ts
rename to src_old/utils/svg-path-to-xy.ts
diff --git a/src/utils/unsaved-label.ts b/src_old/utils/unsaved-label.ts
similarity index 100%
rename from src/utils/unsaved-label.ts
rename to src_old/utils/unsaved-label.ts
diff --git a/src/utils/validate-initial-value.ts b/src_old/utils/validate-initial-value.ts
similarity index 100%
rename from src/utils/validate-initial-value.ts
rename to src_old/utils/validate-initial-value.ts
diff --git a/src/utils/validate-ip-address.ts b/src_old/utils/validate-ip-address.ts
similarity index 100%
rename from src/utils/validate-ip-address.ts
rename to src_old/utils/validate-ip-address.ts
diff --git a/src/utils/yaml-to-object.ts b/src_old/utils/yaml-to-object.ts
similarity index 100%
rename from src/utils/yaml-to-object.ts
rename to src_old/utils/yaml-to-object.ts
diff --git a/tailwind.config.ts b/tailwind.config.ts
index 09b2265c1..f7b1decb7 100644
--- a/tailwind.config.ts
+++ b/tailwind.config.ts
@@ -1,7 +1,7 @@
 /** @type {import('tailwindcss').Config} */
 
 module.exports = {
-  content: ['./src/renderer/**/*.{js,jsx,ts,tsx,ejs,html}', './src/main/**/*.{js,jsx,ts,tsx,ejs,html}'],
+  content: ['./src/**/*.{js,jsx,ts,tsx,ejs,html}', './src_old/renderer/**/*.{js,jsx,ts,tsx,ejs,html}', './src_old/main/**/*.{js,jsx,ts,tsx,ejs,html}'],
   darkMode: 'media', // or 'media' or 'class'
   theme: {
     extend: {
diff --git a/tsconfig.json b/tsconfig.json
index 92e3ae2ad..26d8cc830 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -16,16 +16,16 @@
     "outDir": "configs/dll",
     "paths": {
       "@root/*": ["./src/*"],
-      "@process:main/*": ["./src/main/*"],
-      "@process:renderer/*": ["./src/renderer/*"],
-      "@components/*": ["./src/renderer/components/*"],
-      "@features/*": ["./src/renderer/features/*"],
-      "@contracts/*": ["./src/renderer/contracts/*"],
-      "@utils/*": ["./src/utils/*"],
-      "@shared/*": ["./src/shared/*"],
-      "@oplc-icons/*": ["./src/renderer/assets/icons/*"],
-      "@hooks/*": ["./src/renderer/hooks/*"],
-      "@data/*": ["./src/renderer/data/*"]
+      "@process:main/*": ["./src_old/main/*"],
+      "@process:renderer/*": ["./src_old/renderer/*"],
+      "@components/*": ["./src_old/renderer/components/*"],
+      "@features/*": ["./src_old/renderer/features/*"],
+      "@contracts/*": ["./src_old/renderer/contracts/*"],
+      "@utils/*": ["./src_old/utils/*"],
+      "@shared/*": ["./src_old/shared/*"],
+      "@oplc-icons/*": ["./src_old/renderer/assets/icons/*"],
+      "@hooks/*": ["./src_old/renderer/hooks/*"],
+      "@data/*": ["./src_old/renderer/data/*"]
     }
   },
   "exclude": ["test", "release/build", "release/app/dist", "configs/dll"]