Release v4.2.2 — alias-architecture rollup + transpiler toggle

.gitignore

@@ -51,11 +51,6 @@ resources/st-compiler/**.spec
 
 # External tool binaries (downloaded by scripts/download-binaries.ts)
 # arduino-cli stays committed since we don't own its releases
-resources/bin/**/xml2st
-resources/bin/**/xml2st.exe
-resources/bin/**/xml2st/
-resources/bin/.binary-metadata.json
-resources/bin/**/.binary-metadata.json
 resources/strucpp/
 
 # Playwright

configs/webpack/webpack.app-info.ts

@@ -1,13 +1,13 @@
 /**
- * App info configuration for webpack DefinePlugin
- * Provides version from package.json and build date
+ * App info configuration for webpack DefinePlugin.
+ *
+ * APP_VERSION is no longer injected here: the shared About modal imports it
+ * from src/frontend/data/constants/app-version.ts — the single source of
+ * truth shared byte-for-byte with openplc-web, so the two IDEs always show
+ * the same version. This file now only provides the per-app product name
+ * (APP_NAME, "OpenPLC Editor") and the build date.
  */
 
-import { resolve } from 'path'
-
-// Read version from package.json
-const packageJson = require(resolve(__dirname, '../../package.json'))
-
 /**
  * Get current date in YYYY-MM-DD format
  */
@@ -24,11 +24,10 @@ function getCurrentDate(): string {
  * In CI builds, BUILD_DATE can be set via environment variable
  */
 export function getAppInfoDefines() {
-  const version = packageJson.version as string
   const buildDate = process.env.BUILD_DATE || getCurrentDate()
 
   return {
-    APP_VERSION: JSON.stringify(version),
+    APP_NAME: JSON.stringify('OpenPLC Editor'),
     BUILD_DATE: JSON.stringify(buildDate),
   }
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "open-plc-editor",
   "description": "OpenPLC Editor - IDE capable of creating programs for the OpenPLC Runtime",
-  "version": "4.1.4",
+  "version": "4.2.2",
   "license": "GPL-3.0",
   "author": {
     "name": "Autonomy Logic"

release/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-plc-editor",
-  "version": "4.1.4",
+  "version": "4.2.2",
   "description": "OpenPLC Editor - IDE capable of creating programs for the OpenPLC Runtime",
   "license": "MIT",
   "author": {

src/backend/editor/compiler/__tests__/editor-compiler-platform-port.test.ts

@@ -129,7 +129,6 @@ describe('findHexInCompilationPath', () => {
 describe('createEditorCompilerPlatformPort', () => {
   function makeHandlers(overrides?: Partial<EditorCompilerHandlers>): EditorCompilerHandlers {
     return {
-      handleTranspileXMLtoST: jest.fn(),
       handleCompileArduinoProgram: jest.fn(),
       handleUploadProgram: jest.fn(),
       handleCoreInstallation: jest.fn(),
@@ -229,64 +228,6 @@ describe('createEditorCompilerPlatformPort', () => {
     expect(log).toHaveBeenCalledWith(expect.stringContaining('lib install failed'), 'warning')
   })
 
-  // ---- transpileXmlToSt — xml2stArgs forwarding (STRUCT drift regression) ----
-
-  it('transpileXmlToSt forwards args.xml2stArgs to handleTranspileXMLtoST verbatim', async () => {
-    // Regression guard for the editor/web STRUCT drift bug: the
-    // shared pipeline owns the xml2st flag set as an array of CLI
-    // tokens, and the editor adapter must thread that array into
-    // handleTranspileXMLtoST as the third positional arg — the
-    // handler then splices it straight into the spawned xml2st argv.
-    // Editor's local xml2st is trusted, so the adapter passes the
-    // array through verbatim (no filtering).
-    const handleTranspileXMLtoST = jest
-      .fn<
-        ReturnType<EditorCompilerHandlers['handleTranspileXMLtoST']>,
-        Parameters<EditorCompilerHandlers['handleTranspileXMLtoST']>
-      >()
-      .mockResolvedValue({ success: true, data: '' })
-    const tmp = mkdtempSync(join(tmpdir(), 'xml2st-args-'))
-    try {
-      const port = createEditorCompilerPlatformPort(
-        makeHandlers({ handleTranspileXMLtoST }),
-        makeContext({ sourceTargetFolderPath: tmp }),
-      )
-      // The handler stub never produces a program.st, so the readFile
-      // after the spawn-equivalent step throws — that's fine, we only
-      // care about the xml2stArgs argument forwarded to the handler.
-      await port.transpileXmlToSt({ xml: '<plc/>', xml2stArgs: ['--keep-structs'] }, () => undefined)
-      expect(handleTranspileXMLtoST).toHaveBeenCalledTimes(1)
-      const callArgs = handleTranspileXMLtoST.mock.calls[0]!
-      expect(callArgs[2]).toEqual(['--keep-structs'])
-    } finally {
-      rmSync(tmp, { recursive: true, force: true })
-    }
-  })
-
-  it('transpileXmlToSt forwards an empty xml2stArgs array verbatim', async () => {
-    // The adapter must not "helpfully" inject defaults when the
-    // pipeline asked for nothing — that would be the exact kind of
-    // silent drift the shared port contract exists to prevent.
-    const handleTranspileXMLtoST = jest
-      .fn<
-        ReturnType<EditorCompilerHandlers['handleTranspileXMLtoST']>,
-        Parameters<EditorCompilerHandlers['handleTranspileXMLtoST']>
-      >()
-      .mockResolvedValue({ success: true, data: '' })
-    const tmp = mkdtempSync(join(tmpdir(), 'xml2st-empty-args-'))
-    try {
-      const port = createEditorCompilerPlatformPort(
-        makeHandlers({ handleTranspileXMLtoST }),
-        makeContext({ sourceTargetFolderPath: tmp }),
-      )
-      await port.transpileXmlToSt({ xml: '<plc/>', xml2stArgs: [] }, () => undefined)
-      const callArgs = handleTranspileXMLtoST.mock.calls[0]!
-      expect(callArgs[2]).toEqual([])
-    } finally {
-      rmSync(tmp, { recursive: true, force: true })
-    }
-  })
-
   // ---- uploadArduinoBoard — port wiring (regression for issue #5) ----
 
   it('uploadArduinoBoard forwards args.port to the handler as communicationPort', async () => {

src/backend/editor/compiler/compiler-module.spec.ts

@@ -113,7 +113,6 @@ describe('CompilerModule', () => {
     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.strucppRuntimeDir).toBe('string')
   })
 

src/backend/editor/compiler/compiler-module.ts

@@ -26,6 +26,11 @@
 import { buildKnownPous, emitCompileErrorEvents } from '@root/backend/shared/library/program-build-helpers'
 import { runProgramBuildPipeline } from '@root/backend/shared/library/program-build-pipeline'
 import { loadStrucpp } from '@root/backend/shared/library/strucpp-runtime'
+import {
+  fromSchemaShape,
+  type SchemaProjectData,
+  transpileToSt as runJsonTranspiler,
+} from '@root/backend/shared/transpilers/st-transpiler'
 import type { KnownPou } from '@root/backend/shared/utils/PLC/split-program-st'
 
 /**
@@ -79,6 +84,7 @@
 
 import { assertPathContained } from '@root/backend/editor/utils/path-containment'
 import { getRuntimeHttpsOptions } from '@root/backend/editor/utils/runtime-https-config'
+import { isNewTranspilerEnabled } from '@root/backend/editor/utils/transpiler-mode'
 import { runCompilePipeline } from '@root/backend/shared/compile/pipeline'
 import { mergeStrucppRuntimeIntoSkeleton } from '@root/backend/shared/compile/steps/merge-strucpp-runtime-into-skeleton'
 import { readHalsFile } from '@root/backend/shared/firmware/hals-loader'
@@ -417,14 +423,6 @@
     }
   }
 
-  #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') {
@@ -433,6 +431,14 @@
     return spawn(arduinoCliBinaryPath, args)
   }
 
+  #executeXml2st(args: string[]) {
+    let xml2stBinaryPath = this.xml2stBinaryPath
+    if (CompilerModule.HOST_PLATFORM === 'win32') {
+      xml2stBinaryPath += '.exe'
+    }
+    return spawn(xml2stBinaryPath, args)
+  }
+
   // ############################################################################
   // =========================== Public methods =================================
   // ############################################################################
@@ -486,8 +492,8 @@
 
   checkStrucppAvailability(): MethodsResult<string> {
     try {
       const { getVersion } = loadStrucpp()
       return { success: true, data: getVersion() }
     } catch {
       throw new Error('STruC++ not available. Run "npm run setup:binaries" to install it.')
     }
@@ -2794,37 +2800,70 @@
       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
-    }
+    if (isNewTranspilerEnabled()) {
+      // JSON → ST in-process via `st-transpiler`.  Mirrors what
+      // `editor-compiler-platform-port.transpileToSt` does for the
+      // shared pipeline path, scoped down to the debug compile here.
+      try {
+        const ir = fromSchemaShape(projectData as unknown as SchemaProjectData)
+        const result = runJsonTranspiler(ir)
+        if (result.programSt === null || result.errors.length > 0) {
+          const message = result.errors.join('\n') || 'Failed to generate Structured Text'
+          _mainProcessPort.postMessage({
+            logLevel: 'error',
+            message: `${message}\nStopping debug compilation process.`,
+          })
+          _mainProcessPort.close()
+          return
+        }
+        for (const warning of result.warnings) {
+          _mainProcessPort.postMessage({ logLevel: 'info', message: warning })
+        }
+        await mkdir(sourceTargetFolderPath, { recursive: true })
+        const programStPath = join(sourceTargetFolderPath, 'program.st')
+        await writeFile(programStPath, result.programSt, 'utf-8')
+        _mainProcessPort.postMessage({ logLevel: 'info', message: `ST file generated at: ${programStPath}` })
+      } catch (error) {
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: `Error transpiling JSON to ST: ${getErrorMessage(error)}\nStopping debug compilation process.`,
+        })
+        _mainProcessPort.close()
+        return
+      }
+    } else {
+      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 })
-        },
-        ['--keep-structs'],
-      )
-    } catch (error) {
-      _mainProcessPort.postMessage({
-        logLevel: 'error',
-        message: `Error transpiling XML to ST: ${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 })
+          },
+          ['--keep-structs'],
+        )
+      } catch (error) {
+        _mainProcessPort.postMessage({
+          logLevel: 'error',
+          message: `Error transpiling XML to ST: ${error as string}\nStopping debug compilation process.`,
+        })
+        _mainProcessPort.close()
+        return
+      }
     }
 
     try {
@@ -2852,7 +2891,7 @@
           _mainProcessPort.postMessage({
             logLevel,
             message: data,
             ...(compileError ? { compileError } : {}),
           })
         },
         { hasCBlocks, pous: knownPous, libraries, missingLibraries },