diff --git a/src/backend/shared/transpilers/st-transpiler/__tests__/execute-element.test.ts b/src/backend/shared/transpilers/st-transpiler/__tests__/execute-element.test.ts
new file mode 100644
index 000000000..62cf8c6c0
--- /dev/null
+++ b/src/backend/shared/transpilers/st-transpiler/__tests__/execute-element.test.ts
@@ -0,0 +1,293 @@
+import { emitFbdBody } from '@root/backend/shared/transpilers/st-transpiler/walker/fbd'
+import { emitLdBody } from '@root/backend/shared/transpilers/st-transpiler/walker/ld'
+import type { RFBody, RFEdge, RFNode, RFRung } from '@root/backend/shared/transpilers/st-transpiler/walker/types'
+
+// Coverage for the Execute ("ST Block") element — a graphical box holding a
+// raw ST snippet, gated by whatever rung condition reaches its EN input and
+// passing power straight through on ENO.
+//
+// Semantics are pinned against a real CODESYS V3.5 SP22 PLCopen export
+// (`<block typeName="EXECUTE">` + a `.../plcopenxml/stcode` addData). The
+// decisive detail there: a coil downstream of an EXECUTE block references the
+// block's localId with NO `formalParameter` qualifier — plain rung
+// continuation — so `contact -> EXECUTE -> coil` yields `coil := contact`.
+
+let edgeId = 0
+const e = (source: string, target: string): RFEdge => ({ id: `e${edgeId++}`, source, target })
+
+const rail = (id: string, variant: 'left' | 'right', x: number): RFNode => ({
+  id,
+  type: 'powerRail',
+  position: { x, y: 30 },
+  data: { variant },
+})
+const contact = (id: string, name: string, x: number): RFNode => ({
+  id,
+  type: 'contact',
+  position: { x, y: 38 },
+  data: { variant: 'default', variable: { name } },
+})
+const coil = (id: string, name: string, x: number): RFNode => ({
+  id,
+  type: 'coil',
+  position: { x, y: 38 },
+  data: { variant: 'default', variable: { name }, executionOrder: 0 },
+})
+const execute = (id: string, code: string, x: number, executionOrder = 0): RFNode => ({
+  id,
+  type: 'execute',
+  position: { x, y: 38 },
+  data: { code, executionOrder },
+})
+const inVar = (id: string, name: string, x: number): RFNode => ({
+  id,
+  type: 'input-variable',
+  position: { x, y: 38 },
+  data: { variant: 'input-variable', variable: { name } },
+})
+const outVar = (id: string, name: string, x: number): RFNode => ({
+  id,
+  type: 'output-variable',
+  position: { x, y: 38 },
+  data: { variant: 'output-variable', variable: { name }, executionOrder: 0 },
+})
+
+const ldBody = (nodes: RFNode[], edges: RFEdge[]): RFBody => ({
+  rungs: [{ reactFlowViewport: [800, 200], nodes, edges }],
+})
+const fbdRung = (nodes: RFNode[], edges: RFEdge[]): RFRung => ({ nodes, edges })
+
+beforeEach(() => {
+  edgeId = 0
+})
+
+describe('Execute element — rung gating', () => {
+  it('gates the snippet on the rung condition and passes power through to the coil', () => {
+    // The exact topology from the CODESYS export:
+    //   leftPowerRail -> contact(myContact) -> EXECUTE -> coil(myCoil)
+    const body = ldBody(
+      [
+        rail('L', 'left', 0),
+        contact('C', 'myContact', 68),
+        execute('X', '// Comment in ST Block\nmyNewValue := myValue + 10;\n', 200),
+        coil('K', 'myCoil', 400),
+        rail('R', 'right', 600),
+      ],
+      [e('L', 'C'), e('C', 'X'), e('X', 'K'), e('K', 'R')],
+    )
+
+    const { bodySt, warnings } = emitLdBody(body)
+
+    expect(warnings).toEqual([])
+    expect(bodySt).toBe(
+      '\n' +
+        '  IF myContact THEN\n' +
+        '    // Comment in ST Block\n' +
+        '    myNewValue := myValue + 10;\n' +
+        '  END_IF;\n' +
+        '  myCoil := myContact;\n',
+    )
+  })
+
+  it('emits the snippet bare when the box sits directly on the left rail', () => {
+    // A trivially-true condition would only produce `IF TRUE THEN`, which is
+    // noise. The body runs every scan either way.
+    const body = ldBody(
+      [rail('L', 'left', 0), execute('X', 'counter := counter + 1;', 200), rail('R', 'right', 400)],
+      [e('L', 'X'), e('X', 'R')],
+    )
+
+    const { bodySt, warnings } = emitLdBody(body)
+
+    expect(warnings).toEqual([])
+    expect(bodySt).toBe('\n  counter := counter + 1;\n')
+  })
+
+  it('emits the snippet bare in FBD when EN is left unwired', () => {
+    const { bodySt, warnings } = emitFbdBody({
+      rung: fbdRung([execute('X', 'myNewVarFBD := myNewVarFBD + 222;', 0)], []),
+    })
+
+    expect(warnings).toEqual([])
+    expect(bodySt).toBe('\n  myNewVarFBD := myNewVarFBD + 222;\n')
+  })
+
+  it('combines a multi-contact rung condition into one IF', () => {
+    const body = ldBody(
+      [
+        rail('L', 'left', 0),
+        contact('C1', 'a', 68),
+        contact('C2', 'b', 140),
+        execute('X', 'total := total + 1;', 260),
+        rail('R', 'right', 500),
+      ],
+      [e('L', 'C1'), e('C1', 'C2'), e('C2', 'X'), e('X', 'R')],
+    )
+
+    const { bodySt, warnings } = emitLdBody(body)
+
+    expect(warnings).toEqual([])
+    // `b AND a`, not `a AND b` — `visitContact` emits each contact's own
+    // variable ahead of its upstream chain, so the term nearest the sink leads.
+    // That is the walker's established convention (it matches the python
+    // oracle) and is unchanged by the Execute element; asserted here only to
+    // pin that Execute consumes the condition like any other sink.
+    expect(bodySt).toBe('\n  IF b AND a THEN\n    total := total + 1;\n  END_IF;\n')
+  })
+})
+
+describe('Execute element — snippet re-indentation', () => {
+  it('preserves relative nesting and blank lines inside the generated IF', () => {
+    const code = ['IF a < 10 THEN', '    b := 1;', '', '    c := 2;', 'END_IF;'].join('\n')
+    const body = ldBody(
+      [rail('L', 'left', 0), contact('C', 'gate', 68), execute('X', code, 200), rail('R', 'right', 500)],
+      [e('L', 'C'), e('C', 'X'), e('X', 'R')],
+    )
+
+    const { bodySt } = emitLdBody(body)
+
+    expect(bodySt).toBe(
+      '\n' +
+        '  IF gate THEN\n' +
+        '    IF a < 10 THEN\n' +
+        '        b := 1;\n' +
+        '\n' + // blank lines stay blank, not trailing whitespace
+        '        c := 2;\n' +
+        '    END_IF;\n' +
+        '  END_IF;\n',
+    )
+  })
+
+  it('strips a common leading margin so an indented snippet is not double-indented', () => {
+    const code = ['    x := 1;', '    y := 2;'].join('\n')
+    const body = ldBody(
+      [rail('L', 'left', 0), execute('X', code, 200), rail('R', 'right', 400)],
+      [e('L', 'X'), e('X', 'R')],
+    )
+
+    expect(emitLdBody(body).bodySt).toBe('\n  x := 1;\n  y := 2;\n')
+  })
+
+  it('normalises CRLF endings and trims surrounding blank lines', () => {
+    // CODESYS writes a trailing newline for LD payloads but not FBD ones, so
+    // emission must not depend on either being present.
+    const body = ldBody(
+      [rail('L', 'left', 0), execute('X', '\r\n\r\nx := 1;\r\ny := 2;\r\n\r\n', 200), rail('R', 'right', 400)],
+      [e('L', 'X'), e('X', 'R')],
+    )
+
+    expect(emitLdBody(body).bodySt).toBe('\n  x := 1;\n  y := 2;\n')
+  })
+})
+
+describe('Execute element — ENO passthrough', () => {
+  it('does not wrap a downstream FBD assignment in an ENO check', () => {
+    // `getUsedEnoForNode` wraps an outVariable in `IF <block>.ENO THEN` when
+    // its single upstream is a *block* with EN wired. An Execute node must not
+    // trigger that: there is no `_TMP_..._ENO` for EXECUTE, so the downstream
+    // condition has to rebuild from the rung instead.
+    const { bodySt, warnings } = emitFbdBody({
+      rung: fbdRung(
+        [inVar('IV', 'flag', 0), execute('X', 'side := side + 1;', 200), outVar('OV', 'result', 400)],
+        [e('IV', 'X'), e('X', 'OV')],
+      ),
+    })
+
+    expect(warnings).toEqual([])
+    expect(bodySt).toBe('\n  IF flag THEN\n    side := side + 1;\n  END_IF;\n  result := flag;\n')
+    expect(bodySt).not.toContain('ENO')
+  })
+
+  it('feeds a chain of two Execute boxes from the same rung condition', () => {
+    const body = ldBody(
+      [
+        rail('L', 'left', 0),
+        contact('C', 'gate', 68),
+        execute('X1', 'first := 1;', 200),
+        execute('X2', 'second := 2;', 400),
+        coil('K', 'done', 600),
+        rail('R', 'right', 800),
+      ],
+      [e('L', 'C'), e('C', 'X1'), e('X1', 'X2'), e('X2', 'K'), e('K', 'R')],
+    )
+
+    const { bodySt, warnings } = emitLdBody(body)
+
+    expect(warnings).toEqual([])
+    expect(bodySt).toBe(
+      '\n' +
+        '  IF gate THEN\n    first := 1;\n  END_IF;\n' +
+        '  IF gate THEN\n    second := 2;\n  END_IF;\n' +
+        '  done := gate;\n',
+    )
+  })
+})
+
+describe('Execute element — ordering', () => {
+  it('honours an explicit executionOrder ahead of the positional sweep', () => {
+    // X2 sits to the LEFT of X1 but carries the higher order, so position
+    // alone would emit it first; the explicit order must win.
+    const body = ldBody(
+      [
+        rail('L', 'left', 0),
+        contact('C', 'gate', 68),
+        execute('X1', 'first := 1;', 400, 1),
+        execute('X2', 'second := 2;', 200, 2),
+        rail('R', 'right', 800),
+      ],
+      [e('L', 'C'), e('C', 'X1'), e('C', 'X2')],
+    )
+
+    const { bodySt } = emitLdBody(body)
+
+    expect(bodySt).toBe('\n  IF gate THEN\n    first := 1;\n  END_IF;\n  IF gate THEN\n    second := 2;\n  END_IF;\n')
+  })
+
+  it('falls back to left-to-right position when no order is set', () => {
+    const body = ldBody(
+      [
+        rail('L', 'left', 0),
+        contact('C', 'gate', 68),
+        execute('XB', 'b := 1;', 400),
+        execute('XA', 'a := 1;', 200),
+        rail('R', 'right', 800),
+      ],
+      [e('L', 'C'), e('C', 'XA'), e('C', 'XB')],
+    )
+
+    expect(emitLdBody(body).bodySt).toBe(
+      '\n  IF gate THEN\n    a := 1;\n  END_IF;\n  IF gate THEN\n    b := 1;\n  END_IF;\n',
+    )
+  })
+})
+
+describe('Execute element — malformed input', () => {
+  it('warns and emits nothing for an empty snippet', () => {
+    const body = ldBody(
+      [rail('L', 'left', 0), contact('C', 'gate', 68), execute('X', '   \n\n  ', 200), rail('R', 'right', 400)],
+      [e('L', 'C'), e('C', 'X'), e('X', 'R')],
+    )
+
+    const { bodySt, warnings } = emitLdBody(body)
+
+    expect(warnings).toEqual(['Execute block "X" is empty.'])
+    // No hollow `IF gate THEN END_IF;`
+    expect(bodySt).toBe('\n')
+  })
+
+  it('warns when the node payload has no code field', () => {
+    const body = ldBody(
+      [
+        rail('L', 'left', 0),
+        { id: 'X', type: 'execute', position: { x: 200, y: 38 }, data: { executionOrder: 0 } },
+        rail('R', 'right', 400),
+      ],
+      [e('L', 'X'), e('X', 'R')],
+    )
+
+    const { bodySt, warnings } = emitLdBody(body)
+
+    expect(warnings).toEqual(['execute node "X" has unrecognised data shape'])
+    expect(bodySt).toBe('\n')
+  })
+})
diff --git a/src/backend/shared/transpilers/st-transpiler/walker/README.md b/src/backend/shared/transpilers/st-transpiler/walker/README.md
index d6f932e55..62d853cbc 100644
--- a/src/backend/shared/transpilers/st-transpiler/walker/README.md
+++ b/src/backend/shared/transpilers/st-transpiler/walker/README.md
@@ -42,3 +42,19 @@ and the oracle is a walker bug, never an oracle bug — see the
 fixture corpus under `xml2st/fixtures/` and the test harness under
 `xml2st/shared-backend/transpilers/generate-st-from-react-flow/tests/`
 for the validation loop.
+
+### Exception: the `execute` node
+
+The `execute` ("Execute" / "ST Block") element is a **deliberate
+superset** of the python generator's vocabulary — it has no oracle
+equivalent, so the byte-parity rule above does not apply to it. Its
+semantics are instead pinned against a real CODESYS PLCopen export
+(`<block typeName="EXECUTE">` carrying its source in a
+`.../plcopenxml/stcode` `addData`), which establishes that:
+
+- the snippet runs gated by whatever rung condition reaches `EN`, and
+- `ENO` is a plain power passthrough — a coil downstream of an
+  EXECUTE block references the block with no `formalParameter`
+  qualifier, so `contact → EXECUTE → coil` yields `coil := contact`.
+
+See `__tests__/execute-element.test.ts`.
diff --git a/src/backend/shared/transpilers/st-transpiler/walker/connection-types.ts b/src/backend/shared/transpilers/st-transpiler/walker/connection-types.ts
index ce67686b7..05e7e1001 100644
--- a/src/backend/shared/transpilers/st-transpiler/walker/connection-types.ts
+++ b/src/backend/shared/transpilers/st-transpiler/walker/connection-types.ts
@@ -120,9 +120,12 @@ export function computeConnectionTypes(body: RFBody, ctx: TypeContext): Map<stri
         }
         break
       }
+      // `execute` is electrically a coil: BOOL in on `EN`, BOOL out on `ENO`,
+      // so whatever feeds its EN infers BOOL like any other rung element.
       case 'contact':
       case 'coil':
       case 'parallel':
+      case 'execute':
       case 'powerRail': {
         pt.assign(pt.extractRelated(pinOut(node.id)), 'BOOL')
         pt.types.set(pinIn(node.id), 'BOOL')
diff --git a/src/backend/shared/transpilers/st-transpiler/walker/ld.ts b/src/backend/shared/transpilers/st-transpiler/walker/ld.ts
index 57669b916..f6c22a156 100644
--- a/src/backend/shared/transpilers/st-transpiler/walker/ld.ts
+++ b/src/backend/shared/transpilers/st-transpiler/walker/ld.ts
@@ -32,6 +32,7 @@ import {
   asConnectorData,
   asContactData,
   asContinuationData,
+  asExecuteData,
   asParallelData,
   asPowerRailData,
   asVariableData,
@@ -230,6 +231,11 @@ export function emitLdBody(body: RFBody, typeContext?: TypeContext): EmitResult
         if (data.variant === 'output' || data.variant === 'inout') sinks.push(node)
       } else if (node.type === 'block') {
         sinks.push(node)
+      } else if (node.type === 'execute') {
+        // Always emits: the snippet is a side effect, so unlike a coil there
+        // is no output binding that could make it redundant. Empty and
+        // malformed payloads warn at emit time rather than being dropped here.
+        sinks.push(node)
       } else if (node.type === 'connector') {
         sinks.push(node)
       }
@@ -281,6 +287,7 @@ export function emitLdBody(body: RFBody, typeContext?: TypeContext): EmitResult
 function nodeExecutionOrder(node: RFNode): number {
   if (node.type === 'coil') return asCoilData(node.data)?.executionOrder ?? 0
   if (node.type === 'block') return asBlockData(node.data)?.executionOrder ?? 0
+  if (node.type === 'execute') return asExecuteData(node.data)?.executionOrder ?? 0
   if (isVariableNode(node)) return asVariableData(node.data)?.executionOrder ?? 0
   return 0
 }
@@ -330,6 +337,7 @@ function emitSink(state: WalkerState, node: RFNode): void {
     return
   }
   if (node.type === 'block') return emitStandaloneBlock(state, node)
+  if (node.type === 'execute') return emitExecuteNode(state, node)
   if (node.type === 'connector') return emitConnectorNode(state, node)
 }
 
@@ -555,6 +563,81 @@ function emitConnectorNode(state: WalkerState, node: RFNode): void {
   state.connectorExprs.set(data.name, pathsToChunks(paths))
 }
 
+/* ─────────────────────────── execute ("ST Block") ───────────────────────── */
+
+/**
+ * Re-indent a user-authored ST snippet to sit at `indent`.
+ *
+ * The snippet is stored exactly as typed, so it may carry a common leading
+ * margin. Strip that, then prefix every line with `indent`, preserving
+ * relative nesting. Blank lines stay blank rather than becoming trailing
+ * whitespace.
+ */
+function reindentSnippet(code: string, indent: string): string[] {
+  const lines = code.replace(/\r\n?/g, '\n').split('\n')
+  // Trailing-newline presence is inconsistent across sources (CODESYS writes
+  // one for LD payloads but not FBD), so normalise it away here.
+  while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop()
+  while (lines.length > 0 && lines[0].trim() === '') lines.shift()
+  if (lines.length === 0) return []
+
+  let margin = Infinity
+  for (const line of lines) {
+    if (line.trim() === '') continue
+    const leading = line.length - line.trimStart().length
+    if (leading < margin) margin = leading
+  }
+  if (!Number.isFinite(margin)) margin = 0
+
+  return lines.map((line) => (line.trim() === '' ? '\n' : `${indent}${line.slice(margin)}\n`))
+}
+
+/**
+ * Emit an Execute ("ST Block") element: the user's raw ST snippet, gated by
+ * the rung condition reaching its `EN` input.
+ *
+ * Gating is skipped when that condition is trivially true — no incoming edge
+ * (FBD with `EN` unwired) or a single path resolving to `TRUE` (an LD box on
+ * the left rail). Both mean "runs every scan", and emitting the body bare
+ * keeps the generated ST readable instead of burying it in `IF TRUE THEN`.
+ *
+ * The snippet is emitted verbatim apart from re-indentation; strucpp is what
+ * judges its validity.
+ */
+function emitExecuteNode(state: WalkerState, node: RFNode): void {
+  const data = asExecuteData(node.data)
+  if (data === null) {
+    state.warnings.push(`execute node "${node.id}" has unrecognised data shape`)
+    return
+  }
+
+  // Bail before emitting anything — an empty box would otherwise
+  // produce a hollow `IF cond THEN END_IF;`, which is legal ST but
+  // pure noise in the generated output.
+  if (data.code.trim() === '') {
+    state.warnings.push(`Execute block "${node.id}" is empty.`)
+    return
+  }
+
+  const info: Location = [state.tagName, 'execute', locId(node)]
+  const paths = pathsFromIncoming(state, node.id, /*order=*/ false)
+  const gated = paths.length > 0 && !(paths.length === 1 && paths[0].kind === 'true')
+
+  if (gated) {
+    state.program.push([`${state.currentIndent}IF `, info])
+    for (const chunk of pathsToChunks(paths)) state.program.push(chunk)
+    state.program.push([' THEN\n', []])
+    state.currentIndent += '  '
+  }
+
+  for (const line of reindentSnippet(data.code, state.currentIndent)) state.program.push([line, info])
+
+  if (gated) {
+    state.currentIndent = state.currentIndent.slice(0, -2)
+    state.program.push([`${state.currentIndent}END_IF;\n`, []])
+  }
+}
+
 /* ─────────────────────────── standalone block ───────────────────────────── */
 
 function emitStandaloneBlock(state: WalkerState, node: RFNode): void {
@@ -611,6 +694,14 @@ function visitUpstream(state: WalkerState, node: RFNode, edge: RFEdge, order: bo
       // behaviour: emit nothing for the coil, just propagate the
       // upstream signal.
       return visitCoilPassthrough(state, node, order)
+    case 'execute':
+      // ENO passthrough: an Execute box conducts rung power straight through,
+      // so `contact -> EXECUTE -> coil` yields `coil := contact` and the
+      // snippet emits separately as a sink. Confirmed against a CODESYS
+      // PLCopen export, where a downstream coil references the EXECUTE block
+      // with no `formalParameter` qualifier — plain rung continuation. Same
+      // algebra as a coil passthrough.
+      return visitCoilPassthrough(state, node, order)
     case 'continuation':
       return visitContinuation(state, node)
     case 'connector':
diff --git a/src/backend/shared/transpilers/st-transpiler/walker/narrow.ts b/src/backend/shared/transpilers/st-transpiler/walker/narrow.ts
index 127740cc7..8e825e2a1 100644
--- a/src/backend/shared/transpilers/st-transpiler/walker/narrow.ts
+++ b/src/backend/shared/transpilers/st-transpiler/walker/narrow.ts
@@ -78,6 +78,12 @@ export interface ParallelData {
   side: 'open' | 'close'
 }
 
+export interface ExecuteData {
+  /** The user's raw Structured Text snippet. */
+  code: string
+  executionOrder: number
+}
+
 function isObject(v: unknown): v is Record<string, unknown> {
   return typeof v === 'object' && v !== null && !Array.isArray(v)
 }
@@ -176,6 +182,21 @@ export function asParallelData(data: Record<string, unknown>): ParallelData | nu
   return { side: t }
 }
 
+/**
+ * Execute ("ST Block") payload — a graphical element holding a raw ST
+ * snippet.  `code` is the only required field; a node whose `code` is
+ * not a string is malformed and the walker warns rather than guessing.
+ *
+ * The snippet is stored exactly as the user typed it (indentation and
+ * blank lines included); re-indentation happens at emission time, not
+ * here.
+ */
+export function asExecuteData(data: Record<string, unknown>): ExecuteData | null {
+  const code = asString(data['code'])
+  if (code === null) return null
+  return { code, executionOrder: asNumber(data['executionOrder']) ?? 0 }
+}
+
 export function asBlockData(data: Record<string, unknown>): BlockData | null {
   const variant = data['variant']
   if (!isObject(variant)) return null
diff --git a/src/backend/shared/transpilers/st-transpiler/walker/types.ts b/src/backend/shared/transpilers/st-transpiler/walker/types.ts
index a2182413f..35bea7710 100644
--- a/src/backend/shared/transpilers/st-transpiler/walker/types.ts
+++ b/src/backend/shared/transpilers/st-transpiler/walker/types.ts
@@ -34,7 +34,7 @@ export interface RFNode {
    *  boundary in `from-schema.ts` can pass the editor's `node.type:
    *  string` straight through without a typecast.  Known values the
    *  walker dispatches on: `'powerRail' | 'contact' | 'coil' | 'block'
-   *  | 'variable' | 'input-variable' | 'output-variable' |
+   *  | 'execute' | 'variable' | 'input-variable' | 'output-variable' |
    *  'inout-variable' | 'parallel' | 'connector' | 'continuation'`.
    *  Anything else is treated as a no-op sink. */
   type: string
diff --git a/src/frontend/assets/icons/project/ladder/Execute.tsx b/src/frontend/assets/icons/project/ladder/Execute.tsx
new file mode 100644
index 000000000..110564e04
--- /dev/null
+++ b/src/frontend/assets/icons/project/ladder/Execute.tsx
@@ -0,0 +1,50 @@
+import { ComponentPropsWithoutRef } from 'react'
+
+import { cn } from '../../../../utils/cn'
+
+type IExecuteIconProps = ComponentPropsWithoutRef<'svg'> & {
+  size?: 'sm' | 'md' | 'lg'
+}
+
+const sizeClasses = {
+  sm: 'w-5 h-5',
+  md: 'w-6 h-6',
+  lg: 'w-12 h-12',
+}
+
+/**
+ * Execute ("ST Block") toolbox icon — a rung-wired box holding lines of
+ * text, echoing how the element renders on the canvas. Matches the
+ * other ladder icons' rounded-square backdrop and `#B4D0FE` palette.
+ */
+export default function ExecuteIcon(props: IExecuteIconProps) {
+  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'
+      />
+      {/* rung wires into EN / out of ENO */}
+      <path d='M2 11.6667H5.5' stroke='#B4D0FE' strokeWidth='1.35' />
+      <path d='M18 11.6667H21.5' stroke='#B4D0FE' strokeWidth='1.35' />
+      {/* the box */}
+      <rect x='5.5' y='5.5' width='12.5' height='12.3333' rx='1.5' stroke='#B4D0FE' strokeWidth='1.35' />
+      {/* lines of code */}
+      <path
+        d='M7.83333 9.33333H15.6667M7.83333 11.6667H13.3333M7.83333 14H14.5'
+        stroke='#B4D0FE'
+        strokeWidth='1.1'
+        strokeLinecap='round'
+      />
+    </svg>
+  )
+}
diff --git a/src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
index 5f69f9791..938a49a83 100644
--- a/src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/buildNodes.tsx
@@ -11,6 +11,10 @@ import {
   DEFAULT_BLOCK_TYPE,
   DEFAULT_CONNECTION_CONNECTOR_X,
   DEFAULT_CONNECTION_CONNECTOR_Y,
+  DEFAULT_EXECUTE_CONNECTOR_X,
+  DEFAULT_EXECUTE_CONNECTOR_Y,
+  DEFAULT_EXECUTE_HEIGHT,
+  DEFAULT_EXECUTE_WIDTH,
   DEFAULT_VARIABLE_CONNECTOR_X,
   DEFAULT_VARIABLE_CONNECTOR_Y,
   MINIMUM_ELEMENT_HEIGHT,
@@ -24,6 +28,8 @@ import type {
   CommentNode,
   ConnectionBuilderProps,
   ConnectionNode,
+  ExecuteBuilderProps,
+  ExecuteNode,
   VariableBuilderProps,
   VariableNode,
 } from './utils/types'
@@ -115,6 +121,72 @@ export const buildCommentNode = ({ id, position }: CommentBuilderProps): Comment
   }
 }
 
+/**
+ * Build an FBD Execute ("ST Block") node.
+ *
+ * Same electrical shape as the ladder variant — `EN` target left, `ENO`
+ * source right — but free-positioned and resizable like the comment
+ * element, since FBD has no rung to lay it out.  Leaving `EN` unwired
+ * means the snippet runs unconditionally; the walker's "no incoming
+ * paths" case handles that.
+ */
+export const buildExecuteNode = ({ id, position, code = '' }: ExecuteBuilderProps): ExecuteNode => {
+  // `style.top` places the handle's DOM element — React Flow draws edges to
+  // the DOM position, so without it the wire meets the box off the pin row.
+  const inputHandle = buildHandle({
+    id: 'EN',
+    position: Position.Left,
+    type: 'target',
+    glbX: position.x,
+    glbY: position.y + DEFAULT_EXECUTE_CONNECTOR_Y,
+    relX: 0,
+    relY: DEFAULT_EXECUTE_CONNECTOR_Y,
+    style: { top: DEFAULT_EXECUTE_CONNECTOR_Y, left: 0 },
+  })
+  const outputHandle = buildHandle({
+    id: 'ENO',
+    position: Position.Right,
+    type: 'source',
+    glbX: position.x + DEFAULT_EXECUTE_CONNECTOR_X,
+    glbY: position.y + DEFAULT_EXECUTE_CONNECTOR_Y,
+    relX: DEFAULT_EXECUTE_CONNECTOR_X,
+    relY: DEFAULT_EXECUTE_CONNECTOR_Y,
+    style: { top: DEFAULT_EXECUTE_CONNECTOR_Y, right: 0 },
+  })
+
+  return {
+    id,
+    type: 'execute',
+    position,
+    width: DEFAULT_EXECUTE_WIDTH,
+    height: DEFAULT_EXECUTE_HEIGHT,
+    measured: {
+      width: DEFAULT_EXECUTE_WIDTH,
+      height: DEFAULT_EXECUTE_HEIGHT,
+    },
+    data: {
+      handles: [inputHandle, outputHandle],
+      inputHandles: [inputHandle],
+      outputHandles: [outputHandle],
+      inputConnector: inputHandle,
+      outputConnector: outputHandle,
+      numericId: generateNumericUUID(),
+      executionOrder: 0,
+      code,
+      // Shape-compatibility with `BasicNodeData`; an Execute box binds no
+      // single variable — it references whatever its code does.
+      variable: { id: '', name: '' },
+      draggable: true,
+      selectable: true,
+      deletable: true,
+    },
+    deletable: true,
+    selectable: true,
+    draggable: true,
+    selected: true,
+  }
+}
+
 export const buildConnectionNode = ({ id, position, variant, label }: ConnectionBuilderProps): ConnectionNode => {
   const inputHandle =
     variant === 'connector'
diff --git a/src/frontend/components/_atoms/graphical-editor/fbd/execute.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/execute.tsx
new file mode 100644
index 000000000..7554dfedf
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/execute.tsx
@@ -0,0 +1,142 @@
+import { NodeResizer } from '@xyflow/react'
+import { memo, useCallback, useEffect, useState } from 'react'
+
+import { useIsDebuggerVisible } from '../../../../hooks/use-debug-value'
+import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
+import { executeStDocumentUri } from '../../../../utils/PLC/execute-st-uri'
+import { useBoundPou } from '../../../_features/[workspace]/editor/graphical/active-context'
+import { StCodeField } from '../st-code-field'
+import { CustomHandle } from './handle'
+import {
+  DEFAULT_EXECUTE_BODY_TOP,
+  DEFAULT_EXECUTE_CONNECTOR_Y,
+  DEFAULT_EXECUTE_HEIGHT,
+  DEFAULT_EXECUTE_WIDTH,
+} from './utils/constants'
+import type { ExecuteProps } from './utils/types'
+
+export type { ExecuteNode } from './utils/types'
+
+/**
+ * Execute ("ST Block") for FBD — a resizable box holding a raw ST snippet,
+ * gated by whatever reaches `EN` and passing that signal through on `ENO`.
+ *
+ * Free-positioned and user-resizable like the comment element, since FBD has
+ * no rung to lay it out. An unwired `EN` means the snippet runs every scan.
+ */
+const ExecuteElement = (block: ExecuteProps) => {
+  const { id, data, selected, width, height } = block
+  const pouName = useBoundPou()
+  const updateNode = useOpenPLCStore((state) => state.fbdFlowActions.updateNode)
+  const updateModelFBD = useOpenPLCStore((state) => state.editorActions.updateModelFBD)
+  const openModal = useOpenPLCStore((state) => state.modalActions.openModal)
+  const isDebuggerVisible = useIsDebuggerVisible()
+
+  // Only one Monaco surface may own the shared model URI at a time — see the
+  // ladder Execute node.
+  const expandedModal = useOpenPLCStore((state) => state.modals['execute-fbd-element'])
+  const isExpanded = expandedModal.open && (expandedModal.data as { id?: string } | null)?.id === id
+
+  const [focused, setFocused] = useState(false)
+
+  // Monaco's scroll/zoom gestures fight the canvas', so freeze pan and zoom
+  // while the field has focus — as the comment element does for its textarea.
+  useEffect(() => {
+    updateModelFBD({ canEditorZoom: !focused, canEditorPan: !focused })
+    return () => updateModelFBD({ canEditorZoom: true, canEditorPan: true })
+  }, [focused, updateModelFBD])
+
+  const handleCommit = useCallback(
+    (nextCode: string) => {
+      const { fbdFlows } = useOpenPLCStore.getState()
+      const node = fbdFlows.find((flow) => flow.name === pouName)?.rung.nodes.find((n) => n.id === id)
+      if (!node) return
+      if ((node.data as { code?: string }).code === nextCode) return
+
+      updateNode({
+        editorName: pouName,
+        nodeId: id,
+        node: { ...node, data: { ...node.data, code: nextCode } },
+      })
+    },
+    [id, pouName, updateNode],
+  )
+
+  return (
+    <>
+      {/* Bare, unstyled root — border and size live on the inner box, mirroring
+          `Block`. Bordering this element would shift every handle down by the
+          border width and step the wire into it. */}
+      <div className='relative'>
+        <div
+          data-testid={`execute-${id}`}
+          style={{ width: width ?? DEFAULT_EXECUTE_WIDTH, height: height ?? DEFAULT_EXECUTE_HEIGHT }}
+          className={cn(
+            'relative flex flex-col rounded-md border border-neutral-850 bg-white text-neutral-1000',
+            'dark:bg-neutral-900 dark:text-neutral-50',
+            'hover:border-transparent hover:ring-2 hover:ring-brand',
+            selected && 'border-transparent ring-2 ring-brand',
+          )}
+        >
+          <div className='absolute top-2 w-full truncate bg-transparent px-1 text-center text-xs'>Execute</div>
+
+          <button
+            type='button'
+            aria-label='Expand ST editor'
+            title='Expand ST editor'
+            className='absolute right-1 top-1.5 flex h-4 w-4 items-center justify-center rounded-sm hover:bg-neutral-200 dark:hover:bg-neutral-800'
+            onClick={(event) => {
+              event.stopPropagation()
+              openModal('execute-fbd-element', block)
+            }}
+          >
+            <svg
+              viewBox='0 0 12 12'
+              aria-hidden
+              className='h-3 w-3 fill-none stroke-neutral-850 dark:stroke-neutral-300'
+            >
+              <path d='M7 1h4v4M11 1 6.5 5.5M5 11H1V7M1 11l4.5-4.5' strokeWidth='1.2' strokeLinecap='round' />
+            </svg>
+          </button>
+
+          <div className='absolute text-xs' style={{ top: DEFAULT_EXECUTE_CONNECTOR_Y - 10, left: 6 }}>
+            EN
+          </div>
+          <div className='absolute text-xs' style={{ top: DEFAULT_EXECUTE_CONNECTOR_Y - 10, right: 6 }}>
+            ENO
+          </div>
+
+          <div
+            className='absolute inset-x-1 bottom-1 overflow-hidden rounded-sm border border-neutral-300 dark:border-neutral-800'
+            style={{ top: DEFAULT_EXECUTE_BODY_TOP }}
+            onFocusCapture={() => setFocused(true)}
+            onBlurCapture={() => setFocused(false)}
+          >
+            <StCodeField
+              value={data.code}
+              onCommit={handleCommit}
+              uri={executeStDocumentUri(pouName, id)}
+              debugPrefix={isDebuggerVisible ? `${pouName}:` : undefined}
+              active={selected === true && !isExpanded}
+            />
+          </div>
+        </div>
+
+        {data.handles.map((handle, index) => (
+          <CustomHandle key={index} {...handle} />
+        ))}
+      </div>
+      <NodeResizer
+        isVisible={selected ?? false}
+        minWidth={DEFAULT_EXECUTE_WIDTH}
+        minHeight={DEFAULT_EXECUTE_HEIGHT}
+        handleStyle={{ borderRadius: '0', width: '8px', height: '8px' }}
+      />
+    </>
+  )
+}
+
+const exportExecuteElement = memo(ExecuteElement)
+
+export { exportExecuteElement as ExecuteElement }
diff --git a/src/frontend/components/_atoms/graphical-editor/fbd/index.ts b/src/frontend/components/_atoms/graphical-editor/fbd/index.ts
index 80007b3ba..ba9448bcd 100644
--- a/src/frontend/components/_atoms/graphical-editor/fbd/index.ts
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/index.ts
@@ -2,6 +2,7 @@ import * as blockNode from './block'
 import * as buildNodes from './buildNodes'
 import * as commentNode from './comment'
 import * as connectionNode from './connection'
+import * as executeNode from './execute'
 import * as variableNode from './variable'
 
 export const customNodeTypes = {
@@ -12,6 +13,7 @@ export const customNodeTypes = {
   connector: connectionNode.ConnectionElement,
   continuation: connectionNode.ConnectionElement,
   comment: commentNode.CommentElement,
+  execute: executeNode.ExecuteElement,
 }
 export type CustomFbdNodeTypes = keyof typeof customNodeTypes
 
@@ -20,4 +22,5 @@ export const nodesBuilder = {
   variable: buildNodes.buildVariableNode,
   connection: buildNodes.buildConnectionNode,
   comment: buildNodes.buildCommentNode,
+  execute: buildNodes.buildExecuteNode,
 }
diff --git a/src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx b/src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
index 242c69e17..7e9d33dda 100644
--- a/src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/utils/constants.tsx
@@ -44,3 +44,14 @@ export const DEFAULT_VARIABLE_CONNECTOR_X = DEFAULT_VARIABLE_WIDTH
 export const DEFAULT_VARIABLE_CONNECTOR_Y = DEFAULT_VARIABLE_HEIGHT / 2
 
 export { FBD_VARIABLE_NODE_TYPES } from '../../../../../utils/graphical/types'
+
+// execute ("ST Block")
+
+// Same connector geometry as an FBD block, so wires meet the box on the
+// block pin row rather than at an arbitrary height of its own.
+export const DEFAULT_EXECUTE_WIDTH = 260
+export const DEFAULT_EXECUTE_HEIGHT = 120
+export const DEFAULT_EXECUTE_CONNECTOR_Y = DEFAULT_BLOCK_CONNECTOR_Y
+export const DEFAULT_EXECUTE_CONNECTOR_X = DEFAULT_EXECUTE_WIDTH
+/** Top of the code area — clears the title row and the EN/ENO pin row. */
+export const DEFAULT_EXECUTE_BODY_TOP = DEFAULT_EXECUTE_CONNECTOR_Y + 16
diff --git a/src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts b/src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
index d7a899711..69237b427 100644
--- a/src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
+++ b/src/frontend/components/_atoms/graphical-editor/fbd/utils/types.ts
@@ -68,3 +68,15 @@ export type VariableProps = NodeProps<VariableNode>
 export type VariableBuilderProps = BuilderBasicProps & {
   variant: 'input-variable' | 'output-variable' | 'inout-variable'
 }
+
+// execute ("ST Block")
+
+/**
+ * A box holding a raw Structured Text snippet.  `EN` gates execution;
+ * `ENO` passes the same signal through.  Unlike the ladder variant this
+ * one is free-positioned and user-resizable, matching the FBD comment
+ * element.
+ */
+export type ExecuteNode = Node<BasicNodeData & { code: string }>
+export type ExecuteProps = NodeProps<ExecuteNode>
+export type ExecuteBuilderProps = BuilderBasicProps & { code?: string }
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
index ac79fc34d..fbaf113cf 100644
--- a/src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/buildNodes.tsx
@@ -11,6 +11,8 @@ import {
   DEFAULT_CONTACT_BLOCK_HEIGHT,
   DEFAULT_CONTACT_BLOCK_WIDTH,
   DEFAULT_CONTACT_CONNECTOR_Y,
+  DEFAULT_EXECUTE_CONNECTOR_Y,
+  DEFAULT_EXECUTE_WIDTH,
   DEFAULT_PARALLEL_CONNECTOR_Y,
   DEFAULT_PARALLEL_HEIGHT,
   DEFAULT_PARALLEL_WIDTH,
@@ -24,12 +26,14 @@ import {
   DEFAULT_VARIABLE_CONNECTOR_Y,
   DEFAULT_VARIABLE_HEIGHT,
   DEFAULT_VARIABLE_WIDTH,
+  executeHeight,
 } from './utils/constants'
 import type {
   BlockBuilderProps,
   BlockVariant,
   CoilBuilderProps,
   ContactBuilderProps,
+  ExecuteBuilderProps,
   LadderBlockConnectedVariables,
   ParallelBuilderProps,
   ParallelNode,
@@ -165,6 +169,78 @@ export const buildCoilNode = ({ id, posX, posY, handleX, handleY, variant }: Coi
   }
 }
 
+/**
+ * Build an Execute ("ST Block") node — a box carrying a raw ST snippet.
+ *
+ * Electrically a coil: one `EN` target on the left, one `ENO` source on
+ * the right, both anchored to the header strip's vertical centre so the
+ * rung wire enters at a fixed height regardless of how many lines of
+ * code the box holds.  Height is derived from the line count (clamped);
+ * past the clamp the box scrolls internally rather than growing the rung.
+ */
+export const buildExecuteNode = ({ id, posX, posY, handleX, handleY, code = '' }: ExecuteBuilderProps) => {
+  // `style.top` is what actually places the handle's DOM element, and React
+  // Flow draws every edge to the DOM position — `relY` alone is not enough.
+  // Omitting it left the handle at the element's default offset while the
+  // label sat on the pin row, which is what made the rung wire jog into the
+  // box. Mirrors `getBlockSize`'s handles exactly.
+  const inputHandle = buildHandle({
+    id: 'EN',
+    position: Position.Left,
+    isConnectable: false,
+    type: 'target',
+    glbX: handleX,
+    glbY: handleY,
+    relX: 0,
+    relY: DEFAULT_EXECUTE_CONNECTOR_Y,
+    style: { top: DEFAULT_EXECUTE_CONNECTOR_Y, left: 0 },
+  })
+  const outputHandle = buildHandle({
+    id: 'ENO',
+    position: Position.Right,
+    isConnectable: false,
+    type: 'source',
+    glbX: handleX + DEFAULT_EXECUTE_WIDTH,
+    glbY: handleY,
+    relX: DEFAULT_EXECUTE_WIDTH,
+    relY: DEFAULT_EXECUTE_CONNECTOR_Y,
+    style: { top: DEFAULT_EXECUTE_CONNECTOR_Y, right: 0 },
+  })
+  const handles = [inputHandle, outputHandle]
+  const height = executeHeight(code === '' ? 0 : code.split('\n').length)
+
+  return {
+    id,
+    type: 'execute',
+    position: { x: posX, y: posY },
+    data: {
+      handles,
+      code,
+      inputHandles: [inputHandle],
+      outputHandles: [outputHandle],
+      inputConnector: inputHandle,
+      outputConnector: outputHandle,
+      numericId: generateNumericUUID(),
+      // Carried for shape-compatibility with `BasicNodeData`; an Execute
+      // box binds no single variable — it references whatever its code does.
+      variable: { name: '' },
+      executionOrder: 0,
+      draggable: true,
+      selectable: true,
+      deletable: true,
+    },
+    width: DEFAULT_EXECUTE_WIDTH,
+    height,
+    measured: {
+      width: DEFAULT_EXECUTE_WIDTH,
+      height,
+    },
+    draggable: true,
+    selectable: true,
+    selected: true,
+  }
+}
+
 export const buildContactNode = ({ id, posX, posY, handleX, handleY, variant }: ContactBuilderProps) => {
   const inputHandle = buildHandle({
     id: 'input',
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/execute.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/execute.tsx
new file mode 100644
index 000000000..a33853d36
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/execute.tsx
@@ -0,0 +1,165 @@
+import { memo, useCallback } from 'react'
+
+import { useIsDebuggerVisible } from '../../../../hooks/use-debug-value'
+import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
+import { executeStDocumentUri } from '../../../../utils/PLC/execute-st-uri'
+import { useBoundPou } from '../../../_features/[workspace]/editor/graphical/active-context'
+import { StCodeField } from '../st-code-field'
+import { CustomHandle } from './handle'
+import { getLadderPouVariablesRungNodeAndEdges } from './utils'
+import {
+  DEFAULT_EXECUTE_BODY_TOP,
+  DEFAULT_EXECUTE_CONNECTOR_Y,
+  DEFAULT_EXECUTE_HEIGHT,
+  DEFAULT_EXECUTE_WIDTH,
+  executeHeight,
+} from './utils/constants'
+import type { ExecuteProps } from './utils/types'
+
+export type { ExecuteNode } from './utils/types'
+
+/**
+ * Execute ("ST Block") — a ladder element holding a raw ST snippet.
+ *
+ * Rendered as a standard ladder block: the same chrome as `BlockNodeVisual` on
+ * the same `DEFAULT_BLOCK_CONNECTOR_Y` geometry, so the layout aligns it like
+ * any block and the rung wire runs straight through.
+ *
+ * `EN` / `ENO` are always shown — execution control is what gates the snippet.
+ * Electrically the box is a coil: ENO is EN, so power conducts through to
+ * whatever follows.
+ */
+const Execute = (block: ExecuteProps) => {
+  const { id, data, selected, width, height } = block
+  const pouName = useBoundPou()
+  const updateNode = useOpenPLCStore((state) => state.ladderFlowActions.updateNode)
+  const openModal = useOpenPLCStore((state) => state.modalActions.openModal)
+  const isDebuggerVisible = useIsDebuggerVisible()
+
+  // The modal edits the same document URI, so diagnostics attach to whichever
+  // surface is up. Two Monaco editors on one model path fight over it, so only
+  // one may be live at a time; the modal wins.
+  const expandedModal = useOpenPLCStore((state) => state.modals['execute-ladder-element'])
+  const isExpanded = expandedModal.open && (expandedModal.data as { id?: string } | null)?.id === id
+
+  // Grow / shrink as the user types. The code is only written back on blur, so
+  // without this the box keeps its committed height while the text runs past
+  // the bottom. Transient — resizing must not mark the POU dirty on its own.
+  const handleLineCountChange = useCallback(
+    (lineCount: number) => {
+      const nextHeight = executeHeight(lineCount)
+      const { project, ladderFlows } = useOpenPLCStore.getState()
+      const { rung, node } = getLadderPouVariablesRungNodeAndEdges(pouName, project.data.pous, ladderFlows, {
+        nodeId: id,
+      })
+      if (!rung || !node || node.height === nextHeight) return
+
+      updateNode({
+        editorName: pouName,
+        rungId: rung.id,
+        nodeId: id,
+        node: {
+          ...node,
+          height: nextHeight,
+          measured: { width: node.width ?? DEFAULT_EXECUTE_WIDTH, height: nextHeight },
+        },
+        transient: true,
+      })
+    },
+    [id, pouName, updateNode],
+  )
+
+  const handleCommit = useCallback(
+    (nextCode: string) => {
+      // Re-read from the store: the rung id isn't on the node, and it may have
+      // been re-laid-out since this callback was made.
+      const { project, ladderFlows } = useOpenPLCStore.getState()
+      const { rung, node } = getLadderPouVariablesRungNodeAndEdges(pouName, project.data.pous, ladderFlows, {
+        nodeId: id,
+      })
+      if (!rung || !node) return
+      if ((node.data as { code?: string }).code === nextCode) return
+
+      const nextHeight = executeHeight(nextCode === '' ? 0 : nextCode.split('\n').length)
+      updateNode({
+        editorName: pouName,
+        rungId: rung.id,
+        nodeId: node.id,
+        node: {
+          ...node,
+          height: nextHeight,
+          measured: { width: node.width ?? DEFAULT_EXECUTE_WIDTH, height: nextHeight },
+          data: { ...node.data, code: nextCode },
+        },
+      })
+    },
+    [id, pouName, updateNode],
+  )
+
+  return (
+    // Bare, unstyled root — border and size live on the inner box, mirroring
+    // `Block`. Load-bearing: handles position with `top: <connectorY>` against
+    // the nearest positioned ancestor, so bordering this element would shift
+    // every handle down by the border width and step the wire into the box.
+    <div className='relative'>
+      <div
+        data-testid={`execute-${id}`}
+        style={{ width: width ?? DEFAULT_EXECUTE_WIDTH, height: height ?? DEFAULT_EXECUTE_HEIGHT }}
+        className={cn(
+          'relative flex flex-col rounded-md border border-neutral-850 bg-white text-neutral-1000',
+          'dark:bg-neutral-900 dark:text-neutral-50',
+          'hover:border-transparent hover:ring-2 hover:ring-brand',
+          selected && 'border-transparent ring-2 ring-brand',
+        )}
+      >
+        {/* Title, centred like a block's type name. */}
+        <div className='absolute top-2 w-full truncate bg-transparent px-1 text-center text-xs'>Execute</div>
+
+        <button
+          type='button'
+          aria-label='Expand ST editor'
+          title='Expand ST editor'
+          className='absolute right-1 top-1.5 flex h-4 w-4 items-center justify-center rounded-sm hover:bg-neutral-200 dark:hover:bg-neutral-800'
+          onClick={(event) => {
+            event.stopPropagation()
+            openModal('execute-ladder-element', block)
+          }}
+        >
+          <svg viewBox='0 0 12 12' aria-hidden className='h-3 w-3 fill-none stroke-neutral-850 dark:stroke-neutral-300'>
+            <path d='M7 1h4v4M11 1 6.5 5.5M5 11H1V7M1 11l4.5-4.5' strokeWidth='1.2' strokeLinecap='round' />
+          </svg>
+        </button>
+
+        {/* EN / ENO inset at the connector row, as BlockNodeVisual does it. */}
+        <div className='absolute text-xs' style={{ top: DEFAULT_EXECUTE_CONNECTOR_Y - 10, left: 6 }}>
+          EN
+        </div>
+        <div className='absolute text-xs' style={{ top: DEFAULT_EXECUTE_CONNECTOR_Y - 10, right: 6 }}>
+          ENO
+        </div>
+
+        <div
+          className='absolute inset-x-1 bottom-1 overflow-hidden rounded-sm border border-neutral-300 dark:border-neutral-800'
+          style={{ top: DEFAULT_EXECUTE_BODY_TOP }}
+        >
+          <StCodeField
+            value={data.code}
+            onCommit={handleCommit}
+            uri={executeStDocumentUri(pouName, id)}
+            debugPrefix={isDebuggerVisible ? `${pouName}:` : undefined}
+            active={selected === true && !isExpanded}
+            onLineCountChange={handleLineCountChange}
+          />
+        </div>
+      </div>
+
+      {data.handles.map((handle, index) => (
+        <CustomHandle key={index} {...handle} />
+      ))}
+    </div>
+  )
+}
+
+export default memo(Execute)
+export { Execute }
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/index.ts b/src/frontend/components/_atoms/graphical-editor/ladder/index.ts
index 729c7d2b0..006a99f09 100644
--- a/src/frontend/components/_atoms/graphical-editor/ladder/index.ts
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/index.ts
@@ -1,6 +1,7 @@
 import * as blockNode from './block'
 import * as coilNode from './coil'
 import * as contactNode from './contact'
+import * as executeNode from './execute'
 import * as mockNode from './mock-node'
 import * as parallelNode from './parallel'
 import * as placeholderNode from './placeholder'
@@ -16,6 +17,7 @@ export const customNodeTypes = {
   block: blockNode.Block,
   coil: coilNode.Coil,
   contact: contactNode.Contact,
+  execute: executeNode.Execute,
   parallel: parallelNode.Parallel,
   parallelPlaceholder: placeholderNode.Placeholder,
   placeholder: placeholderNode.Placeholder,
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts b/src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts
index 06f5e0287..c94290b50 100644
--- a/src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/node-builders.ts
@@ -62,6 +62,19 @@ export const defaultCustomNodesStyles: CustomLadderNodeTypes = {
       offsetY: 0,
     },
   },
+  execute: {
+    width: constants.DEFAULT_EXECUTE_WIDTH,
+    // Nominal only — an Execute node carries its own `height`, derived
+    // from its line count, and the layout reads `node.height` first.
+    height: constants.DEFAULT_EXECUTE_HEIGHT,
+    gap: 60,
+    verticalGap: 80,
+    handle: {
+      x: constants.DEFAULT_EXECUTE_CONNECTOR_X,
+      y: constants.DEFAULT_EXECUTE_CONNECTOR_Y,
+      offsetY: 0,
+    },
+  },
   parallel: {
     width: constants.DEFAULT_PARALLEL_WIDTH,
     height: constants.DEFAULT_PARALLEL_HEIGHT,
@@ -134,6 +147,7 @@ export const nodesBuilder = {
   block: buildNodes.buildBlockNode,
   coil: buildNodes.buildCoilNode,
   contact: buildNodes.buildContactNode,
+  execute: buildNodes.buildExecuteNode,
   parallel: buildNodes.buildParallel,
   parallelPlaceholder: buildNodes.builderPlaceholderNode,
   placeholder: buildNodes.builderPlaceholderNode,
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx b/src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
index 7499db6ab..d17772b1d 100644
--- a/src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/utils/constants.tsx
@@ -186,6 +186,31 @@ export const GAP = 0
 
 export const DEFAULT_PARALLEL_CONNECTOR_Y = DEFAULT_PARALLEL_HEIGHT / 2
 
+// execute ("ST Block")
+
+// Geometry is deliberately the SAME as a block's: `EN` / `ENO` sit on the
+// first pin row, so the layout aligns this element exactly as it aligns a
+// block and the rung wire runs straight into it instead of jogging.
+export const DEFAULT_EXECUTE_WIDTH = 240
+export const DEFAULT_EXECUTE_CONNECTOR_Y = DEFAULT_BLOCK_CONNECTOR_Y
+export const DEFAULT_EXECUTE_CONNECTOR_X = DEFAULT_EXECUTE_WIDTH
+
+/** Top of the code area — clears the title row and the EN/ENO pin row. */
+export const DEFAULT_EXECUTE_BODY_TOP = DEFAULT_EXECUTE_CONNECTOR_Y + 16
+export const DEFAULT_EXECUTE_LINE_HEIGHT = 18
+export const DEFAULT_EXECUTE_BODY_PADDING = 10
+/** An empty box still shows the "Enter ST code here" placeholder line. */
+export const DEFAULT_EXECUTE_MIN_LINES = 1
+/** Past this the code area scrolls instead of growing the rung. */
+export const DEFAULT_EXECUTE_MAX_LINES = 12
+
+export const executeHeight = (lineCount: number): number =>
+  DEFAULT_EXECUTE_BODY_TOP +
+  Math.min(Math.max(lineCount, DEFAULT_EXECUTE_MIN_LINES), DEFAULT_EXECUTE_MAX_LINES) * DEFAULT_EXECUTE_LINE_HEIGHT +
+  DEFAULT_EXECUTE_BODY_PADDING
+
+export const DEFAULT_EXECUTE_HEIGHT = executeHeight(DEFAULT_EXECUTE_MIN_LINES)
+
 // placeholder
 
 export const DEFAULT_PLACEHOLDER_WIDTH = 10
diff --git a/src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts b/src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
index 6a4567114..6cc13a10f 100644
--- a/src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
+++ b/src/frontend/components/_atoms/graphical-editor/ladder/utils/types.ts
@@ -105,6 +105,18 @@ export type ContactType = {
   }
 }
 
+// execute ("ST Block")
+
+/**
+ * A box holding a raw Structured Text snippet, gated by the rung
+ * condition reaching its `EN` handle and passing power through on
+ * `ENO`.  `code` is stored exactly as the user typed it — indentation
+ * and blank lines included; the transpiler re-indents at emission.
+ */
+export type ExecuteNode = Node<BasicNodeData & { code: string }>
+export type ExecuteProps = NodeProps<ExecuteNode>
+export type ExecuteBuilderProps = BuilderBasicProps & { code?: string }
+
 // mock
 
 export type MockNode = Node<{ label: string; handles: CustomHandleProps[] }, 'text'>
diff --git a/src/frontend/components/_atoms/graphical-editor/st-code-field/index.tsx b/src/frontend/components/_atoms/graphical-editor/st-code-field/index.tsx
new file mode 100644
index 000000000..c5065a895
--- /dev/null
+++ b/src/frontend/components/_atoms/graphical-editor/st-code-field/index.tsx
@@ -0,0 +1,298 @@
+import { Editor as PrimitiveEditor } from '@monaco-editor/react'
+import * as monaco from 'monaco-editor'
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import { useIsDebuggerVisible } from '../../../../hooks/use-debug-value'
+import { useStDebugDecorations } from '../../../../hooks/use-st-debug-decorations'
+import { getExecuteDraftApi } from '../../../../services/st-lsp/execute-sync'
+import { useOpenPLCStore } from '../../../../store'
+import { cn } from '../../../../utils/cn'
+import { applyThemeNow, ensureOpenplcThemes } from '../../../_features/[workspace]/editor/monaco/theme-utils'
+
+/**
+ * Structured Text editing surface for the Execute ("ST Block") element in LD
+ * and FBD, and for its expand modal.
+ *
+ * Separate from the POU-level `MonacoEditor`, which is bound to a POU (store
+ * lookups, project sync, file watchers, AI hooks). A rung can hold several
+ * Execute boxes, so Monaco mounts lazily — the field renders plain text until
+ * activated. The model is created under `uri`, the same URI the ST LSP holds
+ * the snippet's document on, which is what makes diagnostics attach.
+ */
+
+const PLACEHOLDER = 'Enter ST code here'
+
+export type StCodeFieldProps = {
+  /** Current snippet. Treated as the source of truth while unfocused. */
+  value: string
+  /** Called on blur (and on unmount while dirty) with the edited text. */
+  onCommit: (next: string) => void
+  /**
+   * LSP document URI for this snippet — also the Monaco model URI, which
+   * is what makes diagnostics attach. Must be unique per node.
+   */
+  uri: string
+  /**
+   * Composite-key prefix for debug value badges, e.g. `MyProgram:`.
+   * Omit to disable badges (the modal in a non-debug session).
+   */
+  debugPrefix?: string
+  /**
+   * When false the field stays in its cheap read-only presentation and
+   * never mounts Monaco. The node passes `selected`; the modal passes
+   * `true`.
+   */
+  active?: boolean
+  /**
+   * `compact` — the in-rung box: no line numbers or gutter, small type, every
+   * pixel spent on code because the element is only ~200px wide.
+   * `full` — the expand modal: a proper editor, matching the POU-level ST
+   * editor's font size, gutter and padding. That is the whole point of
+   * expanding.
+   */
+  variant?: 'compact' | 'full'
+  className?: string
+  /**
+   * Fires as the user types, with the snippet's current line count. The
+   * owning node uses it to grow/shrink itself live — without it the box
+   * keeps its committed height while the text runs past the bottom edge.
+   */
+  onLineCountChange?: (lineCount: number) => void
+}
+
+export const StCodeField = ({
+  value,
+  onCommit,
+  uri,
+  debugPrefix,
+  active = false,
+  variant = 'compact',
+  className,
+  onLineCountChange,
+}: StCodeFieldProps) => {
+  const containerRef = useRef<HTMLDivElement | null>(null)
+  const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null)
+  const monacoRef = useRef<typeof monaco | null>(null)
+  const shouldUseDarkMode = useOpenPLCStore((state) => state.workspace.systemConfigs.shouldUseDarkMode)
+  const isDebuggerVisible = useIsDebuggerVisible()
+
+  // The debugger makes every code surface read-only — the running program is
+  // what it is; editing it here would be a lie.
+  const effectiveReadOnly = isDebuggerVisible
+
+  // Monaco mounting is invisible to React — `onMount` only fills refs, so
+  // nothing re-renders. Without this flag the decoration scan below runs once
+  // against a null editor and never again. `MonacoEditor` guards the same trap.
+  const [editorMounted, setEditorMounted] = useState(false)
+
+  // Local buffer so typing doesn't round-trip through the store on
+  // every keystroke. Re-synced from `value` whenever the field is not
+  // the thing driving the change.
+  const [draft, setDraft] = useState(value)
+  const draftRef = useRef(value)
+  const dirtyRef = useRef(false)
+  const lspTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  // Push the draft to the LSP as the user types. The store only sees the
+  // snippet on blur, so a store-driven sync would deliver diagnostics a commit
+  // late — by which point the field may be deselected and its model disposed,
+  // leaving markers nowhere to land. Debounced into one `didChange`.
+  const scheduleLspSync = useCallback(
+    (text: string) => {
+      if (lspTimerRef.current !== null) clearTimeout(lspTimerRef.current)
+      lspTimerRef.current = setTimeout(() => {
+        lspTimerRef.current = null
+        getExecuteDraftApi()?.syncDraft(uri, text)
+      }, 200)
+    },
+    [uri],
+  )
+
+  useEffect(
+    () => () => {
+      if (lspTimerRef.current !== null) clearTimeout(lspTimerRef.current)
+    },
+    [],
+  )
+
+  // Publish on mount so an already-broken snippet is underlined before a key
+  // is pressed. `force` is required: diagnostics are a one-shot notification,
+  // and mounting creates a NEW model (the expand modal builds a second one at
+  // the same URI) with usually-unchanged text, so without a forced re-analyse
+  // the worker stays silent. Keyed on `editorMounted` — the model does not
+  // exist until Monaco has mounted.
+  useEffect(() => {
+    if (!active || !editorMounted) return
+    getExecuteDraftApi()?.syncDraft(uri, draftRef.current, true)
+  }, [active, editorMounted, uri])
+
+  useEffect(() => {
+    if (dirtyRef.current) return
+    setDraft(value)
+    draftRef.current = value
+  }, [value])
+
+  const commit = useCallback(() => {
+    if (!dirtyRef.current) return
+    dirtyRef.current = false
+    if (draftRef.current === value) return
+    onCommit(draftRef.current)
+  }, [onCommit, value])
+
+  // Latest `commit` for callbacks registered once at mount, so the blur
+  // handler below never runs against a stale `value`.
+  const commitRef = useRef(commit)
+  commitRef.current = commit
+
+  // Commit anything still buffered when the field goes away — a node
+  // deleted or a modal closed mid-edit must not silently lose the text.
+  // `commit` changes identity with `value`, so this cleanup also runs on an
+  // ordinary re-render; that is harmless because `commit` no-ops unless the
+  // buffer is dirty.
+  useEffect(() => commit, [commit])
+
+  useStDebugDecorations({
+    editorRef,
+    monacoRef,
+    prefix: debugPrefix,
+    enabled: active && editorMounted && isDebuggerVisible && debugPrefix !== undefined,
+    modelVersion: draft,
+  })
+
+  const handleMount = useCallback(
+    (editor: monaco.editor.IStandaloneCodeEditor, monacoInstance: typeof monaco) => {
+      editorRef.current = editor
+      monacoRef.current = monacoInstance
+      setEditorMounted(true)
+      ensureOpenplcThemes(monacoInstance)
+      applyThemeNow(monacoInstance, shouldUseDarkMode)
+      editor.onDidBlurEditorText(() => commitRef.current())
+    },
+    [shouldUseDarkMode],
+  )
+
+  useEffect(() => {
+    if (monacoRef.current) applyThemeNow(monacoRef.current, shouldUseDarkMode)
+  }, [shouldUseDarkMode])
+
+  // Blur (and commit) on a click anywhere outside the field. The rung's React
+  // Flow pane covers only the rung, so a click elsewhere on the page never
+  // reaches it and the editor would otherwise keep focus indefinitely.
+  useEffect(() => {
+    if (!active) return
+    const onPointerDown = (event: PointerEvent) => {
+      const container = containerRef.current
+      if (!container) return
+      const target = event.target
+      if (target instanceof Node && container.contains(target)) return
+      // Monaco's overlays (suggest widget, hovers) portal outside the
+      // container; blurring while one is open would fight the user.
+      if (target instanceof Element && target.closest('.monaco-editor')) return
+      editorRef.current?.getDomNode()?.blur()
+      commit()
+    }
+    document.addEventListener('pointerdown', onPointerDown, true)
+    return () => document.removeEventListener('pointerdown', onPointerDown, true)
+  }, [active, commit])
+
+  // Going inactive unmounts Monaco, leaving the refs on a disposed editor.
+  // Cleared in an effect rather than during render.
+  useEffect(() => {
+    if (active) return
+    editorRef.current = null
+    monacoRef.current = null
+    setEditorMounted(false)
+  }, [active])
+
+  if (!active) {
+    // Cheap presentation: no Monaco, no LSP document, no decorations.
+    return (
+      <pre
+        aria-label='Structured Text'
+        className={cn(
+          'm-0 h-full w-full overflow-hidden whitespace-pre px-2 py-1 font-mono text-[11px] leading-[18px]',
+          'text-neutral-1000 dark:text-neutral-100',
+          draft === '' && 'italic text-neutral-500 dark:text-neutral-500',
+          className,
+        )}
+      >
+        {draft === '' ? PLACEHOLDER : draft}
+      </pre>
+    )
+  }
+
+  return (
+    // `nokey` opts these keystrokes out of @xyflow/react's window-level keydown
+    // listener, which treats Space as a canvas pan-modifier and preventDefaults
+    // it. xyflow exempts input/textarea/contenteditable, but Monaco's
+    // EditContext surface is a plain div — so without this, Space never reaches
+    // the editor. The POU-level editor carries the same marker.
+    <div ref={containerRef} className={cn('nokey h-full w-full', className)}>
+      <PrimitiveEditor
+        language='st'
+        path={uri}
+        value={draft}
+        onChange={(next) => {
+          const text = next ?? ''
+          dirtyRef.current = true
+          draftRef.current = text
+          setDraft(text)
+          scheduleLspSync(text)
+          onLineCountChange?.(text === '' ? 0 : text.split('\n').length)
+        }}
+        onMount={handleMount}
+        options={{
+          readOnly: effectiveReadOnly,
+          domReadOnly: effectiveReadOnly,
+          minimap: { enabled: false },
+          scrollBeyondLastLine: false,
+          // Classic hidden-<textarea> input rather than the newer EditContext
+          // surface — a real textarea is what xyflow's `isInputDOMNode`
+          // recognises, so this reinforces `.nokey` above.
+          editContext: false,
+          automaticLayout: true,
+          wordWrap: 'off',
+          // Same indentation contract as every other Monaco surface in the
+          // app — 4 spaces, no tabs, no detect-indentation heuristic.
+          tabSize: 4,
+          insertSpaces: true,
+          detectIndentation: false,
+          // Without this the LSP's semantic-tokens response is silently
+          // dropped and ST loses variable/type colouring.
+          'semanticHighlighting.enabled': true,
+          ...(variant === 'full'
+            ? {
+                // Match the POU-level ST editor: gutter, same font size, and
+                // room to breathe.
+                fontSize: 12,
+                lineNumbers: 'on',
+                folding: true,
+                padding: { top: 10, bottom: 10 },
+                // Hovers / suggestions would otherwise clip inside the modal.
+                fixedOverflowWidgets: true,
+              }
+            : {
+                // In-rung: no gutter, minimal chrome, small type.
+                fontSize: 11,
+                lineHeight: 18,
+                lineNumbers: 'off',
+                glyphMargin: false,
+                folding: false,
+                lineDecorationsWidth: 0,
+                lineNumbersMinChars: 0,
+                overviewRulerLanes: 0,
+                renderLineHighlight: 'none',
+                padding: { top: 4, bottom: 4 },
+                scrollbar: {
+                  vertical: 'auto',
+                  horizontal: 'auto',
+                  verticalScrollbarSize: 8,
+                  horizontalScrollbarSize: 8,
+                },
+                contextmenu: false,
+              }),
+        }}
+      />
+    </div>
+  )
+}
diff --git a/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/execute/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/execute/index.tsx
new file mode 100644
index 000000000..4e5728570
--- /dev/null
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/fbd/execute/index.tsx
@@ -0,0 +1,86 @@
+import type { Node as FlowNode } from '@xyflow/react'
+import { useCallback, useEffect, useState } from 'react'
+
+import { useIsDebuggerVisible } from '../../../../../../../../hooks/use-debug-value'
+import { useOpenPLCStore } from '../../../../../../../../store'
+import { executeStDocumentUri } from '../../../../../../../../utils/PLC/execute-st-uri'
+import { StCodeField } from '../../../../../../../_atoms/graphical-editor/st-code-field'
+import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
+
+type ExecuteElementModalProps = {
+  isOpen: boolean
+  onClose: () => void
+  node: FlowNode | null
+  pouName: string
+}
+
+/**
+ * Expanded ST editor for an FBD Execute ("ST Block") element.
+ *
+ * Twin of the ladder modal — the only differences are which store slice
+ * the write-back goes through (`fbdFlowActions`, single rung, no rung
+ * id) and which modal id it answers to.
+ */
+export const ExecuteElementModal = ({ isOpen, onClose, node, pouName }: ExecuteElementModalProps) => {
+  const updateNode = useOpenPLCStore((state) => state.fbdFlowActions.updateNode)
+  const fbdFlows = useOpenPLCStore((state) => state.fbdFlows)
+  const isDebuggerVisible = useIsDebuggerVisible()
+
+  const nodeId = node?.id ?? ''
+  const storedCode = ((node?.data ?? {}) as { code?: string }).code ?? ''
+  const [code, setCode] = useState(storedCode)
+
+  useEffect(() => {
+    if (isOpen) setCode(storedCode)
+  }, [isOpen, nodeId, storedCode])
+
+  const commit = useCallback(
+    (next: string) => {
+      setCode(next)
+      if (nodeId === '') return
+      const target = fbdFlows.find((flow) => flow.name === pouName)?.rung.nodes.find((n) => n.id === nodeId)
+      if (!target) return
+      if ((target.data as { code?: string }).code === next) return
+
+      updateNode({
+        editorName: pouName,
+        nodeId,
+        node: { ...target, data: { ...target.data, code: next } },
+      })
+    },
+    [fbdFlows, nodeId, pouName, updateNode],
+  )
+
+  return (
+    <Modal open={isOpen} onOpenChange={(open) => !open && onClose()}>
+      <ModalContent
+        onClose={onClose}
+        onEscapeKeyDown={(event) => {
+          event.preventDefault()
+          onClose()
+        }}
+        onPointerDownOutside={(event) => {
+          event.preventDefault()
+          onClose()
+        }}
+        className='h-[560px] w-[760px] select-none flex-col gap-4 px-8 py-5'
+      >
+        <ModalTitle className='text-xl font-medium text-neutral-950 dark:text-white'>
+          Execute{isDebuggerVisible ? ' (read-only — debugging)' : ''}
+        </ModalTitle>
+        <div className='h-full min-h-0 w-full overflow-hidden rounded-lg border border-neutral-300 dark:border-neutral-850'>
+          <StCodeField
+            value={code}
+            onCommit={commit}
+            uri={executeStDocumentUri(pouName, nodeId)}
+            debugPrefix={isDebuggerVisible ? `${pouName}:` : undefined}
+            active={isOpen}
+            variant='full'
+          />
+        </div>
+      </ModalContent>
+    </Modal>
+  )
+}
+
+export default ExecuteElementModal
diff --git a/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/execute/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/execute/index.tsx
new file mode 100644
index 000000000..19883e37c
--- /dev/null
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/elements/ladder/execute/index.tsx
@@ -0,0 +1,101 @@
+import type { Node } from '@xyflow/react'
+import { useCallback, useEffect, useState } from 'react'
+
+import { useIsDebuggerVisible } from '../../../../../../../../hooks/use-debug-value'
+import { useOpenPLCStore } from '../../../../../../../../store'
+import { executeStDocumentUri } from '../../../../../../../../utils/PLC/execute-st-uri'
+import { executeHeight } from '../../../../../../../_atoms/graphical-editor/ladder/utils/constants'
+import { StCodeField } from '../../../../../../../_atoms/graphical-editor/st-code-field'
+import { Modal, ModalContent, ModalTitle } from '../../../../../../../_molecules/modal'
+
+type ExecuteElementModalProps = {
+  isOpen: boolean
+  onClose: () => void
+  node: Node | null
+  pouName: string
+}
+
+/**
+ * Expanded ST editor for an Execute ("ST Block") element.
+ *
+ * Opens on double-click or the node's expand button. Unlike the other
+ * graphical element modals it also opens during a debug session — in
+ * that case read-only, with live value badges, so the snippet running
+ * on the PLC can actually be read (a two-line box on the canvas is not
+ * a realistic reading surface for a `CASE` statement).
+ */
+export const ExecuteElementModal = ({ isOpen, onClose, node, pouName }: ExecuteElementModalProps) => {
+  const updateNode = useOpenPLCStore((state) => state.ladderFlowActions.updateNode)
+  const ladderFlows = useOpenPLCStore((state) => state.ladderFlows)
+  const isDebuggerVisible = useIsDebuggerVisible()
+
+  const nodeId = node?.id ?? ''
+  const storedCode = ((node?.data ?? {}) as { code?: string }).code ?? ''
+  const [code, setCode] = useState(storedCode)
+
+  // Re-seed whenever a different node is opened (or the same node is
+  // reopened after an edit made on the canvas).
+  useEffect(() => {
+    if (isOpen) setCode(storedCode)
+  }, [isOpen, nodeId, storedCode])
+
+  const commit = useCallback(
+    (next: string) => {
+      setCode(next)
+      if (nodeId === '') return
+      const rung = ladderFlows
+        .find((flow) => flow.name === pouName)
+        ?.rungs.find((candidate) => candidate.nodes.some((n) => n.id === nodeId))
+      const target = rung?.nodes.find((n) => n.id === nodeId)
+      if (!rung || !target) return
+      if ((target.data as { code?: string }).code === next) return
+
+      const height = executeHeight(next === '' ? 0 : next.split('\n').length)
+      updateNode({
+        editorName: pouName,
+        rungId: rung.id,
+        nodeId,
+        node: {
+          ...target,
+          height,
+          measured: { width: target.width ?? 0, height },
+          data: { ...target.data, code: next },
+        },
+      })
+    },
+    [ladderFlows, nodeId, pouName, updateNode],
+  )
+
+  return (
+    <Modal open={isOpen} onOpenChange={(open) => !open && onClose()}>
+      <ModalContent
+        onClose={onClose}
+        onEscapeKeyDown={(event) => {
+          event.preventDefault()
+          onClose()
+        }}
+        onPointerDownOutside={(event) => {
+          event.preventDefault()
+          onClose()
+        }}
+        className='h-[560px] w-[760px] select-none flex-col gap-4 px-8 py-5'
+      >
+        <ModalTitle className='text-xl font-medium text-neutral-950 dark:text-white'>
+          Execute{isDebuggerVisible ? ' (read-only — debugging)' : ''}
+        </ModalTitle>
+        <div className='h-full min-h-0 w-full overflow-hidden rounded-lg border border-neutral-300 dark:border-neutral-850'>
+          <StCodeField
+            value={code}
+            onCommit={commit}
+            uri={executeStDocumentUri(pouName, nodeId)}
+            debugPrefix={isDebuggerVisible ? `${pouName}:` : undefined}
+            active={isOpen}
+            variant='full'
+          />
+        </div>
+      </ModalContent>
+    </Modal>
+  )
+}
+
+export default ExecuteElementModal
diff --git a/src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx b/src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
index 956df2eef..2cb3db402 100644
--- a/src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/graphical/ladder/index.tsx
@@ -15,6 +15,8 @@ import {
 import { restrictToParentElement } from '@dnd-kit/modifiers'
 import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
 import * as Portal from '@radix-ui/react-portal'
+// Aliased: the bare name `Node` resolves to lib.dom's Node in this file.
+import type { Node as FlowNode } from '@xyflow/react'
 import { useEffect, useMemo, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
 import { v4 as uuidv4 } from 'uuid'
@@ -36,6 +38,7 @@ import { useBoundPou } from '../active-context'
 import BlockElement from '../elements/ladder/block'
 import CoilElement from '../elements/ladder/coil'
 import ContactElement from '../elements/ladder/contact'
+import ExecuteElement from '../elements/ladder/execute'
 
 const EMPTY_DIVERGENCES: string[] = []
 
@@ -52,6 +55,7 @@ export default function LadderEditor() {
   const blockElementModal = useOpenPLCStore((state) => state.modals['block-ladder-element'])
   const contactElementModal = useOpenPLCStore((state) => state.modals['contact-ladder-element'])
   const coilElementModal = useOpenPLCStore((state) => state.modals['coil-ladder-element'])
+  const executeElementModal = useOpenPLCStore((state) => state.modals['execute-ladder-element'])
   const pous = useOpenPLCStore((state) => state.project.data.pous)
   const closeModal = useOpenPLCStore((state) => state.modalActions.closeModal)
   const userLibraries = useOpenPLCStore((state) => state.libraries.user)
@@ -298,6 +302,14 @@ export default function LadderEditor() {
               isOpen={coilElementModal.open}
             />
           )}
+          {executeElementModal?.open && (
+            <ExecuteElement
+              onClose={handleModalClose}
+              node={executeElementModal.data as FlowNode | null}
+              isOpen={executeElementModal.open}
+              pouName={pouName}
+            />
+          )}
         </Portal.Root>
       </div>
     </div>
diff --git a/src/frontend/components/_features/[workspace]/editor/monaco/index.tsx b/src/frontend/components/_features/[workspace]/editor/monaco/index.tsx
index b5fb74966..595bee92e 100644
--- a/src/frontend/components/_features/[workspace]/editor/monaco/index.tsx
+++ b/src/frontend/components/_features/[workspace]/editor/monaco/index.tsx
@@ -7,7 +7,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
 import type { PLCPou } from '../../../../../../middleware/shared/ports/types'
 import { useAI, useCapabilities, useProject } from '../../../../../../middleware/shared/providers'
-import { useDebugBoolValuesMap, useDebugNonBoolValuesMap } from '../../../../../hooks/use-debug-value'
+import { useStDebugDecorations } from '../../../../../hooks/use-st-debug-decorations'
 import { getCppMemberCompletions, projectTypeNamePredicate } from '../../../../../services/cpp-scope'
 import { executeSaveActiveFile, executeSaveProject } from '../../../../../services/save-actions'
 import { pouUri, splitExpression } from '../../../../../services/st-lsp'
@@ -68,53 +68,6 @@ type SnippetController = {
   insert: (snippet: string, options?: unknown) => void
 }
 
-// ---------------------------------------------------------------------------
-// Comment stripping (for debug variable position scanning)
-// ---------------------------------------------------------------------------
-
-type BlockCommentState = false | 'paren' | 'slash'
-
-function stripLineComments(line: string, state: BlockCommentState): { stripped: string; state: BlockCommentState } {
-  const chars = [...line]
-  let i = 0
-  let s = state
-
-  while (i < chars.length) {
-    if (s) {
-      const endMarker = s === 'paren' ? ')' : '/'
-      if (chars[i] === '*' && chars[i + 1] === endMarker) {
-        chars[i] = ' '
-        chars[i + 1] = ' '
-        i += 2
-        s = false
-      } else {
-        chars[i] = ' '
-        i++
-      }
-    } else {
-      if (chars[i] === '/' && chars[i + 1] === '/') {
-        for (let j = i; j < chars.length; j++) chars[j] = ' '
-        break
-      }
-      if (chars[i] === '(' && chars[i + 1] === '*') {
-        chars[i] = ' '
-        chars[i + 1] = ' '
-        i += 2
-        s = 'paren'
-      } else if (chars[i] === '/' && chars[i + 1] === '*') {
-        chars[i] = ' '
-        chars[i + 1] = ' '
-        i += 2
-        s = 'slash'
-      } else {
-        i++
-      }
-    }
-  }
-
-  return { stripped: chars.join(''), state: s }
-}
-
 // ---------------------------------------------------------------------------
 // Module-level flag for initial theme application
 // ---------------------------------------------------------------------------
@@ -170,9 +123,6 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     ai: { pendingDiffs },
     aiActions: { updatePendingDiff, updatePendingDiffAcceptedHunks, clearPendingDiff },
   } = useOpenPLCStore()
-  const debugBoolValues = useDebugBoolValuesMap()
-  const debugNonBoolValues = useDebugNonBoolValuesMap()
-
   // Create a unique Monaco path for editor (prevents model caching across projects)
   const uniqueMonacoPath = capabilities.hasLocalFilesystem && projectPath ? `${projectPath}${path}` : path
 
@@ -512,95 +462,24 @@ const MonacoEditor = (props: monacoEditorProps): ReturnType<typeof PrimitiveEdit
     return instances.find((inst) => inst.key === selectedKey) || null
   }, [pou, fbSelectedInstance, fbDebugInstances])
 
-  const debugVarKeySet = useMemo(() => {
-    const keys: string[] = []
-    for (const key of debugBoolValues.keys()) keys.push(key)
-    for (const key of debugNonBoolValues.keys()) keys.push(key)
-    return keys.sort().join('\0')
-  }, [debugBoolValues, debugNonBoolValues])
-
-  const debugVarPositions = useMemo(() => {
-    // Inline debug badges are an active-tab-only affordance.  Without
-    // this guard, every multi-mounted MonacoEditor would re-scan its
-    // model for debug-variable occurrences on every poll cycle, then
-    // try to apply decorations to a hidden editor that the user can't
-    // see.  Wasted CPU during debug, especially with many open tabs.
-    if (!isActive) 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.
-    // ST models live under `inmemory://pou/<name>.st` (the LSP scheme); other languages
-    // keep their project-scoped filesystem URI.
-    const expectedUri = language === 'st' ? editorModelPath : monacoRef.current.Uri.file(uniqueMonacoPath).toString()
-    if (model.uri.toString() !== expectedUri) return null
-
-    const prefix = fbInstanceContext
-      ? `${fbInstanceContext.programName}:${fbInstanceContext.fbVariableName}.`
-      : `${name}:`
-
-    const varNames: string[] = []
-    for (const key of debugBoolValues.keys()) {
-      if (key.startsWith(prefix)) varNames.push(key.slice(prefix.length))
-    }
-    for (const key of debugNonBoolValues.keys()) {
-      if (key.startsWith(prefix)) varNames.push(key.slice(prefix.length))
-    }
-    if (varNames.length === 0) return null
-
-    varNames.sort((a, b) => b.length - a.length)
-
-    const exprPatterns = varNames.map((expr) => {
-      const escaped = expr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-      return { expr, pattern: new RegExp(`\\b${escaped}(?![\\w.\\[])`, 'gi') }
-    })
-
-    const positions: Array<{ expr: string; line: number; startCol: number; endCol: number }> = []
-    let blockCommentState: BlockCommentState = false
-
-    for (let lineNumber = 1; lineNumber <= model.getLineCount(); lineNumber++) {
-      const result = stripLineComments(model.getLineContent(lineNumber), blockCommentState)
-      blockCommentState = result.state
-      const claimed: Array<[number, number]> = []
-
-      for (const { expr, pattern } of exprPatterns) {
-        pattern.lastIndex = 0
-        let match: RegExpExecArray | null
-        while ((match = pattern.exec(result.stripped)) !== null) {
-          const startCol = match.index + 1
-          const endCol = startCol + match[0].length
-          if (claimed.some(([s, e]) => startCol < e && endCol > s)) continue
-          claimed.push([startCol, endCol])
-          positions.push({ expr, line: lineNumber, startCol, endCol })
-          break
-        }
-      }
-    }
-
-    return { prefix, positions }
-  }, [isActive, isDebuggerVisible, debugVarKeySet, language, name, fbInstanceContext, editorMounted, modelVersion])
-
-  useEffect(() => {
-    if (!debugVarPositions || !editorRef.current) return
-
-    const { prefix, positions } = debugVarPositions
-    const decorations: monaco.editor.IModelDeltaDecoration[] = positions.map(({ expr, line, startCol, endCol }) => ({
-      range: new monaco.Range(line, startCol, line, endCol),
-      options: {
-        after: {
-          content: ` = ${debugBoolValues.get(prefix + expr) ?? debugNonBoolValues.get(prefix + expr) ?? '?'} `,
-          inlineClassName: 'debug-inline-value',
-        },
-      },
-    }))
-
-    const collection = editorRef.current.createDecorationsCollection(decorations)
-    return () => collection.clear()
-  }, [debugVarPositions, debugBoolValues, debugNonBoolValues])
+  // Scanning + decoration live in a shared hook so the Execute ("ST Block")
+  // element renders identical badges without a second copy of the scanner.
+  // `enabled` keeps badges to the active tab and the textual ST/IL surfaces;
+  // `expectedUri` covers the window during a tab switch where
+  // @monaco-editor/react has not swapped the model yet.
+  const debugDecorationUri = useMemo(() => {
+    if (!editorMounted || !monacoRef.current) return undefined
+    return language === 'st' ? editorModelPath : monacoRef.current.Uri.file(uniqueMonacoPath).toString()
+  }, [editorMounted, language, editorModelPath, uniqueMonacoPath])
+
+  useStDebugDecorations({
+    editorRef,
+    monacoRef,
+    prefix: fbInstanceContext ? `${fbInstanceContext.programName}:${fbInstanceContext.fbVariableName}.` : `${name}:`,
+    enabled: isActive && isDebuggerVisible && (language === 'st' || language === 'il'),
+    modelVersion,
+    expectedUri: debugDecorationUri,
+  })
 
   // -----------------------------------------------------------------------
   // Completion callbacks
diff --git a/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts b/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
index b176a42c0..1ad9b1cb7 100644
--- a/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
+++ b/src/frontend/components/_molecules/graphical-editor/fbd/fbd-utils/nodes.ts
@@ -38,6 +38,11 @@ export const buildGenericNode = <T>({
         variant: nodeType,
         label: connectionLabel,
       })
+    case 'execute':
+      return nodesBuilder.execute({
+        id,
+        position,
+      })
     case 'comment':
       return nodesBuilder.comment({
         id,
diff --git a/src/frontend/components/_molecules/graphical-editor/fbd/index.tsx b/src/frontend/components/_molecules/graphical-editor/fbd/index.tsx
index ff172981b..0c8ed7398 100644
--- a/src/frontend/components/_molecules/graphical-editor/fbd/index.tsx
+++ b/src/frontend/components/_molecules/graphical-editor/fbd/index.tsx
@@ -39,6 +39,7 @@ import { ReactFlowPanel } from '../../../_atoms/react-flow'
 import { toast } from '../../../_features/[app]/toast/use-toast'
 import { useBoundEditorModel, useBoundPou } from '../../../_features/[workspace]/editor/graphical/active-context'
 import BlockElement from '../../../_features/[workspace]/editor/graphical/elements/fbd/block'
+import ExecuteElement from '../../../_features/[workspace]/editor/graphical/elements/fbd/execute'
 import { buildGenericNode } from './fbd-utils/nodes'
 import { useFBDClipboard } from './fbd-utils/useCopyPaste'
 
@@ -55,6 +56,7 @@ const DEFAULT_EDGE_OPTIONS: DefaultEdgeOptions = {
 }
 const SNAP_GRID: SnapGrid = [16, 16]
 const PRO_OPTIONS = { hideAttribution: true }
+const NOOP = () => {}
 const CONTROLS_CONFIG = { showInteractive: false }
 
 // --- Debug edge coloring ---
@@ -213,6 +215,7 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
   const deleteVariable = useOpenPLCStore((state) => state.projectActions.deleteVariable)
   const { closeModal, openModal } = useOpenPLCStore((state) => state.modalActions)
   const blockElementModal = useOpenPLCStore((state) => state.modals['block-fbd-element'])
+  const executeElementModal = useOpenPLCStore((state) => state.modals['execute-fbd-element'])
   const pous = useOpenPLCStore((state) => state.project.data.pous)
   const hasProgramInstance = useOpenPLCStore((state) =>
     state.project.data.configurations.resource.instances.some((instance) => instance.program === pouName),
@@ -755,6 +758,15 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
    * Handle the double click of a node
    */
   const handleNodeDoubleClick = (node: FlowNode) => {
+    // Execute opens even while debugging — read-only, so the running
+    // snippet can be read with live value badges. See the ladder rung
+    // body for the same carve-out.
+    if (node.type === 'execute') {
+      openModal('execute-fbd-element', node)
+      return
+    }
+    if (isDebuggerActive) return
+
     const modalToOpen = node.type === 'block' && 'block-fbd-element'
     if (!modalToOpen) return
 
@@ -819,9 +831,19 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
           nodesConnectable: !isDebuggerActive,
           elementsSelectable: true,
 
+          // React Flow gives a node `pointer-events: none` when it is neither
+          // selectable nor draggable and carries no click handler — which is
+          // exactly the state debug puts every node in, so double-click never
+          // reached the Execute box and its read-only modal was unreachable.
+          // A no-op click handler keeps the node interactive; the ladder rung
+          // does the same thing for the same reason.
+          onNodeClick: isDebuggerActive ? NOOP : undefined,
+
           onDelete: isDebuggerActive ? undefined : onDelete,
           onConnect: isDebuggerActive ? undefined : onConnect,
-          onNodeDoubleClick: isDebuggerActive ? undefined : onNodeDoubleClick,
+          // Always wired — `handleNodeDoubleClick` decides per node type
+          // whether a debug session suppresses the modal.
+          onNodeDoubleClick,
 
           onDragEnter: isDebuggerActive ? undefined : onDragEnterViewport,
           onDragLeave: isDebuggerActive ? undefined : onDragLeaveViewport,
@@ -851,6 +873,14 @@ export const FBDBody = ({ rung, nodeDivergences = [], isDebuggerActive = false }
           isOpen={blockElementModal.open}
         />
       )}
+      {executeElementModal.open && (
+        <ExecuteElement
+          onClose={handleModalClose}
+          node={executeElementModal.data as FlowNode | null}
+          isOpen={executeElementModal.open}
+          pouName={pouName}
+        />
+      )}
     </div>
   )
 }
diff --git a/src/frontend/components/_molecules/graphical-editor/ladder/rung/__tests__/execute-power-flow.test.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/__tests__/execute-power-flow.test.ts
new file mode 100644
index 000000000..4922560c1
--- /dev/null
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/__tests__/execute-power-flow.test.ts
@@ -0,0 +1,76 @@
+import type { RungLadderState } from '@root/frontend/store/slices'
+
+import { computeRungDebugStates, type LadderDebugContext } from '../ladder-utils/debug-power-flow'
+
+// Regression: `getNodeOutputState` dispatches on node type, and `execute` was
+// missing from it — so during debug the power-flow highlight died at an
+// Execute ("ST Block") box even though the rung really does energize whatever
+// follows. Electrically the element is a coil: its ENO is its EN.
+
+const ctx: LadderDebugContext = {
+  isFunctionBlockPou: false,
+  hasProgramInstance: true,
+  getCompositeKey: (variableName: string) => `main:${variableName}`,
+  boolValues: new Map([['main:gate', '1']]),
+}
+
+type Nodes = RungLadderState['nodes']
+type Edges = RungLadderState['edges']
+
+const rail = (id: string, variant: 'left' | 'right') =>
+  ({ id, type: 'powerRail', position: { x: 0, y: 0 }, data: { variant } }) as unknown as Nodes[number]
+const contact = (id: string, name: string) =>
+  ({
+    id,
+    type: 'contact',
+    position: { x: 0, y: 0 },
+    data: { variant: 'open', variable: { name } },
+  }) as unknown as Nodes[number]
+const execute = (id: string) =>
+  ({ id, type: 'execute', position: { x: 0, y: 0 }, data: { code: 'x := 1;' } }) as unknown as Nodes[number]
+const coil = (id: string, name: string) =>
+  ({
+    id,
+    type: 'coil',
+    position: { x: 0, y: 0 },
+    data: { variant: 'default', variable: { name } },
+  }) as unknown as Nodes[number]
+const edge = (id: string, source: string, target: string) =>
+  ({ id, source, target, sourceHandle: 'output', targetHandle: 'input' }) as unknown as Edges[number]
+
+describe('Execute element — debug power flow', () => {
+  it('conducts power through to the next element', () => {
+    // leftRail -> execute -> coil
+    const nodes: Nodes = [rail('L', 'left'), execute('X'), coil('K', 'done')]
+    const edges: Edges = [edge('e1', 'L', 'X'), edge('e2', 'X', 'K')]
+
+    const { edgeStates, nodeInputStates } = computeRungDebugStates(nodes, edges, ctx)
+
+    expect(edgeStates.get('e1')).toBe(true)
+    // The one that used to be false: ENO must carry the rail's power onward.
+    expect(edgeStates.get('e2')).toBe(true)
+    expect(nodeInputStates.get('K')).toBe(true)
+  })
+
+  it('stays de-energized when its upstream contact is false', () => {
+    const offCtx: LadderDebugContext = { ...ctx, boolValues: new Map([['main:gate', '0']]) }
+    const nodes: Nodes = [rail('L', 'left'), contact('C', 'gate'), execute('X'), coil('K', 'done')]
+    const edges: Edges = [edge('e1', 'L', 'C'), edge('e2', 'C', 'X'), edge('e3', 'X', 'K')]
+
+    const { edgeStates } = computeRungDebugStates(nodes, edges, offCtx)
+
+    expect(edgeStates.get('e1')).toBe(true)
+    expect(edgeStates.get('e2')).toBe(false)
+    expect(edgeStates.get('e3')).toBe(false)
+  })
+
+  it('passes a true contact through to the coil beyond it', () => {
+    const nodes: Nodes = [rail('L', 'left'), contact('C', 'gate'), execute('X'), coil('K', 'done')]
+    const edges: Edges = [edge('e1', 'L', 'C'), edge('e2', 'C', 'X'), edge('e3', 'X', 'K')]
+
+    const { edgeStates } = computeRungDebugStates(nodes, edges, ctx)
+
+    expect(edgeStates.get('e2')).toBe(true)
+    expect(edgeStates.get('e3')).toBe(true)
+  })
+})
diff --git a/src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx b/src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
index 955a3ceac..90d6b4acc 100644
--- a/src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/body.tsx
@@ -27,6 +27,7 @@ import { getVariableRestrictionType } from '../../../../_atoms/graphical-editor/
 import { ReactFlowPanel } from '../../../../_atoms/react-flow'
 import { toast } from '../../../../_features/[app]/toast/use-toast'
 import { useBoundEditorModel, useBoundPou } from '../../../../_features/[workspace]/editor/graphical/active-context'
+import { computeRungDebugStates, type RungDebugStates } from './ladder-utils/debug-power-flow'
 import { addNewElement, removeElements } from './ladder-utils/elements'
 import { onElementDragOver, onElementDragStart, onElementDrop } from './ladder-utils/elements/drag-n-drop'
 import {
@@ -86,178 +87,6 @@ const DEFAULT_EDGE_OPTIONS: DefaultEdgeOptions = {
 const PRO_OPTIONS = { hideAttribution: true }
 const NOOP = () => {}
 
-// --- Debug edge coloring ---
-
-type LadderDebugContext = {
-  isFunctionBlockPou: boolean
-  hasProgramInstance: boolean
-  getCompositeKey: (variableName: string) => string
-  boolValues: Map<string, string>
-}
-
-type RungDebugStates = {
-  edgeStates: Map<string, boolean>
-  nodeInputStates: Map<string, boolean>
-}
-
-const computeRungDebugStates = (
-  nodes: RungLadderState['nodes'],
-  edges: RungLadderState['edges'],
-  ctx: LadderDebugContext,
-): RungDebugStates => {
-  const nodeById = new Map(nodes.map((node) => [node.id, node]))
-  const edgeById = new Map(edges.map((edge) => [edge.id, edge]))
-  const edgesByTarget = new Map<string, RungLadderState['edges']>()
-  for (const edge of edges) {
-    const list = edgesByTarget.get(edge.target)
-    if (list) list.push(edge)
-    else edgesByTarget.set(edge.target, [edge])
-  }
-
-  const getNodeOutputState = (
-    nodeId: string,
-    sourceHandle: string | null | undefined,
-    isInputGreen: boolean,
-  ): boolean | undefined => {
-    const node = nodeById.get(nodeId)
-    if (!node) return undefined
-
-    if (node.type === 'powerRail') {
-      return (node.data as { variant: 'left' | 'right' }).variant === 'left'
-    }
-
-    if (node.type === 'parallel') {
-      return isInputGreen
-    }
-
-    if (node.type === 'contact') {
-      const contactData = node.data as { variable?: { name: string }; variant: 'open' | 'negated' }
-      const variableName = contactData.variable?.name
-      if (!variableName) return undefined
-
-      const compositeKey = ctx.getCompositeKey(variableName)
-      const value = ctx.boolValues.get(compositeKey)
-      if (value === undefined) return undefined
-
-      const isTrue = value === '1' || value.toUpperCase() === 'TRUE'
-      const contactState = contactData.variant === 'negated' ? !isTrue : isTrue
-
-      return isInputGreen && contactState
-    }
-
-    if (node.type === 'coil') {
-      return isInputGreen
-    }
-
-    if (node.type === 'block') {
-      const blockData = node.data as {
-        variable?: { name: string }
-        variant?: { name: string; type: string }
-        numericId?: string
-      }
-      if (!sourceHandle) return undefined
-
-      if (!ctx.isFunctionBlockPou && !ctx.hasProgramInstance) return undefined
-
-      if (blockData.variant?.type === 'function-block') {
-        const blockVariableName = blockData.variable?.name
-        if (!blockVariableName) return undefined
-
-        const compositeKey = ctx.getCompositeKey(`${blockVariableName}.${sourceHandle}`)
-        const value = ctx.boolValues.get(compositeKey)
-
-        if (value === undefined) return undefined
-
-        return value === '1' || value.toUpperCase() === 'TRUE'
-      } else if (blockData.variant?.type === 'function') {
-        const blockName = blockData.variant.name.toUpperCase()
-        const numericId = blockData.numericId
-        if (!numericId) return undefined
-
-        const compositeKey = ctx.getCompositeKey(`_TMP_${blockName}${numericId}_${sourceHandle.toUpperCase()}`)
-        const value = ctx.boolValues.get(compositeKey)
-
-        if (value === undefined) return undefined
-
-        return value === '1' || value.toUpperCase() === 'TRUE'
-      }
-
-      return undefined
-    }
-
-    return undefined
-  }
-
-  const edgeStates = new Map<string, boolean>()
-
-  const determineEdgeState = (edgeId: string): boolean => {
-    if (edgeStates.has(edgeId)) {
-      return edgeStates.get(edgeId)!
-    }
-
-    const edge = edgeById.get(edgeId)
-    if (!edge) return false
-
-    const incomingEdges = edgesByTarget.get(edge.source) ?? []
-
-    let isInputGreen = false
-    if (incomingEdges.length === 0) {
-      const sourceNode = nodeById.get(edge.source)
-      isInputGreen = sourceNode?.type === 'powerRail' && (sourceNode.data as { variant: string }).variant === 'left'
-    } else {
-      isInputGreen = incomingEdges.some((incomingEdge) => determineEdgeState(incomingEdge.id))
-    }
-
-    const sourceOutputState = getNodeOutputState(edge.source, edge.sourceHandle, isInputGreen)
-
-    const isGreen = sourceOutputState === true
-    edgeStates.set(edgeId, isGreen)
-    return isGreen
-  }
-
-  edges.forEach((edge) => {
-    determineEdgeState(edge.id)
-  })
-
-  const nodeInputStates = new Map<string, boolean>()
-
-  const determineNodeInputState = (nodeId: string): boolean => {
-    if (nodeInputStates.has(nodeId)) {
-      return nodeInputStates.get(nodeId)!
-    }
-
-    const node = nodeById.get(nodeId)
-    if (!node) return false
-
-    if (node.type === 'powerRail' && (node.data as { variant: string }).variant === 'left') {
-      nodeInputStates.set(nodeId, true)
-      return true
-    }
-
-    const incomingEdges = edgesByTarget.get(nodeId) ?? []
-
-    if (incomingEdges.length === 0) {
-      nodeInputStates.set(nodeId, false)
-      return false
-    }
-
-    const hasGreenInput = incomingEdges.some((incomingEdge) => {
-      const sourceInputGreen = determineNodeInputState(incomingEdge.source)
-      const sourceOutputGreen = getNodeOutputState(incomingEdge.source, incomingEdge.sourceHandle, sourceInputGreen)
-      return sourceOutputGreen === true
-    })
-
-    nodeInputStates.set(nodeId, hasGreenInput)
-    return hasGreenInput
-  }
-
-  nodes.forEach((node) => {
-    determineNodeInputState(node.id)
-  })
-
-  return { edgeStates, nodeInputStates }
-}
-
 const rungDebugStatesEqual = (previous: RungDebugStates | null, next: RungDebugStates | null): boolean =>
   previous !== null &&
   next !== null &&
@@ -748,6 +577,16 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
    * Handle the double click of a node
    */ //
   const handleNodeDoubleClick = (node: FlowNode) => {
+    // Execute is the one element whose modal opens during debug too —
+    // read-only, so the user can read the running snippet with live
+    // value badges. Everything else stays gated off while debugging
+    // because its modal edits the program.
+    if (node.type === 'execute') {
+      openModal('execute-ladder-element', node)
+      return
+    }
+    if (isDebuggerActive) return
+
     const modalToOpen =
       node.type === 'block'
         ? 'block-ladder-element'
@@ -982,7 +821,9 @@ export const RungBody = ({ rung, className, nodeDivergences = [], isDebuggerActi
               onNodeDragStart: isDebuggerActive ? undefined : onNodeDragStart,
               onNodeDrag: isDebuggerActive ? undefined : onNodeDrag,
               onNodeDragStop: isDebuggerActive ? undefined : onNodeDragStop,
-              onNodeDoubleClick: isDebuggerActive ? undefined : onNodeDoubleClick,
+              // Always wired — `handleNodeDoubleClick` decides per node
+              // type whether a debug session suppresses the modal.
+              onNodeDoubleClick,
 
               onDragEnter: onDragEnterViewport,
               onDragLeave: onDragLeaveViewport,
diff --git a/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/debug-power-flow.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/debug-power-flow.ts
new file mode 100644
index 000000000..34fd88a8b
--- /dev/null
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/debug-power-flow.ts
@@ -0,0 +1,190 @@
+/**
+ * Debug power-flow evaluation for one ladder rung.
+ *
+ * During a debug session the editor colours energized wires green. That means
+ * answering, per edge, "is power reaching here?" — which is a pure walk over
+ * the rung's nodes and edges plus the live boolean values.
+ *
+ * Extracted from `body.tsx` so it can be tested without dragging the whole
+ * component tree (and its ESM-only LSP dependency) into the test runner.
+ */
+
+import type { RungLadderState } from '../../../../../../store/slices/ladder'
+
+export type LadderDebugContext = {
+  isFunctionBlockPou: boolean
+  hasProgramInstance: boolean
+  getCompositeKey: (variableName: string) => string
+  boolValues: Map<string, string>
+}
+
+export type RungDebugStates = {
+  edgeStates: Map<string, boolean>
+  nodeInputStates: Map<string, boolean>
+}
+
+export const computeRungDebugStates = (
+  nodes: RungLadderState['nodes'],
+  edges: RungLadderState['edges'],
+  ctx: LadderDebugContext,
+): RungDebugStates => {
+  const nodeById = new Map(nodes.map((node) => [node.id, node]))
+  const edgeById = new Map(edges.map((edge) => [edge.id, edge]))
+  const edgesByTarget = new Map<string, RungLadderState['edges']>()
+  for (const edge of edges) {
+    const list = edgesByTarget.get(edge.target)
+    if (list) list.push(edge)
+    else edgesByTarget.set(edge.target, [edge])
+  }
+
+  const getNodeOutputState = (
+    nodeId: string,
+    sourceHandle: string | null | undefined,
+    isInputGreen: boolean,
+  ): boolean | undefined => {
+    const node = nodeById.get(nodeId)
+    if (!node) return undefined
+
+    if (node.type === 'powerRail') {
+      return (node.data as { variant: 'left' | 'right' }).variant === 'left'
+    }
+
+    if (node.type === 'parallel') {
+      return isInputGreen
+    }
+
+    if (node.type === 'contact') {
+      const contactData = node.data as { variable?: { name: string }; variant: 'open' | 'negated' }
+      const variableName = contactData.variable?.name
+      if (!variableName) return undefined
+
+      const compositeKey = ctx.getCompositeKey(variableName)
+      const value = ctx.boolValues.get(compositeKey)
+      if (value === undefined) return undefined
+
+      const isTrue = value === '1' || value.toUpperCase() === 'TRUE'
+      const contactState = contactData.variant === 'negated' ? !isTrue : isTrue
+
+      return isInputGreen && contactState
+    }
+
+    if (node.type === 'coil') {
+      return isInputGreen
+    }
+
+    // Execute ("ST Block") conducts rung power straight through: its ENO is
+    // its EN, same as a coil. Without this the power-flow highlight stops
+    // dead at the box during debug even though the rung really does energize
+    // whatever follows it.
+    if (node.type === 'execute') {
+      return isInputGreen
+    }
+
+    if (node.type === 'block') {
+      const blockData = node.data as {
+        variable?: { name: string }
+        variant?: { name: string; type: string }
+        numericId?: string
+      }
+      if (!sourceHandle) return undefined
+
+      if (!ctx.isFunctionBlockPou && !ctx.hasProgramInstance) return undefined
+
+      if (blockData.variant?.type === 'function-block') {
+        const blockVariableName = blockData.variable?.name
+        if (!blockVariableName) return undefined
+
+        const compositeKey = ctx.getCompositeKey(`${blockVariableName}.${sourceHandle}`)
+        const value = ctx.boolValues.get(compositeKey)
+
+        if (value === undefined) return undefined
+
+        return value === '1' || value.toUpperCase() === 'TRUE'
+      } else if (blockData.variant?.type === 'function') {
+        const blockName = blockData.variant.name.toUpperCase()
+        const numericId = blockData.numericId
+        if (!numericId) return undefined
+
+        const compositeKey = ctx.getCompositeKey(`_TMP_${blockName}${numericId}_${sourceHandle.toUpperCase()}`)
+        const value = ctx.boolValues.get(compositeKey)
+
+        if (value === undefined) return undefined
+
+        return value === '1' || value.toUpperCase() === 'TRUE'
+      }
+
+      return undefined
+    }
+
+    return undefined
+  }
+
+  const edgeStates = new Map<string, boolean>()
+
+  const determineEdgeState = (edgeId: string): boolean => {
+    if (edgeStates.has(edgeId)) {
+      return edgeStates.get(edgeId)!
+    }
+
+    const edge = edgeById.get(edgeId)
+    if (!edge) return false
+
+    const incomingEdges = edgesByTarget.get(edge.source) ?? []
+
+    let isInputGreen = false
+    if (incomingEdges.length === 0) {
+      const sourceNode = nodeById.get(edge.source)
+      isInputGreen = sourceNode?.type === 'powerRail' && (sourceNode.data as { variant: string }).variant === 'left'
+    } else {
+      isInputGreen = incomingEdges.some((incomingEdge) => determineEdgeState(incomingEdge.id))
+    }
+
+    const sourceOutputState = getNodeOutputState(edge.source, edge.sourceHandle, isInputGreen)
+
+    const isGreen = sourceOutputState === true
+    edgeStates.set(edgeId, isGreen)
+    return isGreen
+  }
+
+  edges.forEach((edge) => {
+    determineEdgeState(edge.id)
+  })
+
+  const nodeInputStates = new Map<string, boolean>()
+
+  const determineNodeInputState = (nodeId: string): boolean => {
+    if (nodeInputStates.has(nodeId)) {
+      return nodeInputStates.get(nodeId)!
+    }
+
+    const node = nodeById.get(nodeId)
+    if (!node) return false
+
+    if (node.type === 'powerRail' && (node.data as { variant: string }).variant === 'left') {
+      nodeInputStates.set(nodeId, true)
+      return true
+    }
+
+    const incomingEdges = edgesByTarget.get(nodeId) ?? []
+
+    if (incomingEdges.length === 0) {
+      nodeInputStates.set(nodeId, false)
+      return false
+    }
+
+    const hasGreenInput = incomingEdges.some((incomingEdge) => {
+      const sourceInputGreen = determineNodeInputState(incomingEdge.source)
+      const sourceOutputGreen = getNodeOutputState(incomingEdge.source, incomingEdge.sourceHandle, sourceInputGreen)
+      return sourceOutputGreen === true
+    })
+
+    nodeInputStates.set(nodeId, hasGreenInput)
+    return hasGreenInput
+  }
+
+  nodes.forEach((node) => {
+    determineNodeInputState(node.id)
+  })
+
+  return { edgeStates, nodeInputStates }
+}
diff --git a/src/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
index 23ad364c1..2f05d756e 100644
--- a/src/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
@@ -113,9 +113,11 @@ export const addNewElement = <T>(
     if ('elementType' in newNode) {
       const elementType = (newNode as { elementType: string }).elementType
 
-      // Blocks cannot be placed on branch handles — the branch layout system
-      // is designed for single-handle elements (contacts/coils) only.
-      if (elementType === 'block') {
+      // Blocks and Execute boxes cannot be placed on branch handles — the
+      // branch layout system is designed for single-handle elements
+      // (contacts/coils) only, and an Execute box is both multi-line tall
+      // and variable-height, which the branch position maths doesn't model.
+      if (elementType === 'block' || elementType === 'execute') {
         return { nodes: removePlaceholderElements(rung.nodes), edges: rung.edges }
       }
       if (isBlockInsideMainParallel(rung, target.blockId)) {
diff --git a/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
index 84789aecb..bd3fe5807 100644
--- a/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
+++ b/src/frontend/components/_molecules/graphical-editor/ladder/rung/ladder-utils/nodes.ts
@@ -102,6 +102,14 @@ export const buildGenericNode = <T>({
         handleY,
         variant: 'default',
       })
+    case 'execute':
+      return nodesBuilder.execute({
+        id,
+        posX,
+        posY,
+        handleX,
+        handleY,
+      })
     case 'parallel':
       return nodesBuilder.parallel({
         id,
diff --git a/src/frontend/components/_molecules/workspace-activity-bar/fbd/execute.tsx b/src/frontend/components/_molecules/workspace-activity-bar/fbd/execute.tsx
new file mode 100644
index 000000000..f58a669a9
--- /dev/null
+++ b/src/frontend/components/_molecules/workspace-activity-bar/fbd/execute.tsx
@@ -0,0 +1,14 @@
+import { ComponentPropsWithoutRef } from 'react'
+
+import ExecuteIcon from '../../../../assets/icons/project/ladder/Execute'
+import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
+
+export const Execute = ({ onDragStart }: ComponentPropsWithoutRef<'div'>) => {
+  return (
+    <ActivityBarButton aria-label='Execute'>
+      <div draggable onDragStart={onDragStart}>
+        <ExecuteIcon />
+      </div>
+    </ActivityBarButton>
+  )
+}
diff --git a/src/frontend/components/_molecules/workspace-activity-bar/ladder/execute.tsx b/src/frontend/components/_molecules/workspace-activity-bar/ladder/execute.tsx
new file mode 100644
index 000000000..12d4aa062
--- /dev/null
+++ b/src/frontend/components/_molecules/workspace-activity-bar/ladder/execute.tsx
@@ -0,0 +1,14 @@
+import { ComponentPropsWithoutRef } from 'react'
+
+import ExecuteIcon from '../../../../assets/icons/project/ladder/Execute'
+import { ActivityBarButton } from '../../../_atoms/buttons/activity-bar'
+
+export const ExecuteButton = ({ onDragStart }: ComponentPropsWithoutRef<'div'>) => {
+  return (
+    <ActivityBarButton aria-label='Execute'>
+      <div draggable onDragStart={onDragStart}>
+        <ExecuteIcon />
+      </div>
+    </ActivityBarButton>
+  )
+}
diff --git a/src/frontend/components/_organisms/debugger/index.tsx b/src/frontend/components/_organisms/debugger/index.tsx
index 52549befd..9d96f7de6 100644
--- a/src/frontend/components/_organisms/debugger/index.tsx
+++ b/src/frontend/components/_organisms/debugger/index.tsx
@@ -141,7 +141,11 @@ const Debugger = ({ graphList }: DebuggerData) => {
             <span className='flex h-7 select-none items-center justify-center rounded-md bg-inherit  p-2 text-cp-sm font-medium text-neutral-1000 outline-none  dark:text-white'>
               Range
             </span>
-            <div className='relative z-[999999] flex gap-2'>
+            {/* Stacks above the chart and nothing else — modal overlays are
+                z-50, so anything higher paints through an open dialog. The
+                Select's dropdown is portalled to body and keeps its own
+                z-index; it cannot open while a modal holds focus. */}
+            <div className='relative z-10 flex gap-2'>
               <Select.Root onValueChange={(value) => setRange(Number(value))}>
                 <Select.Trigger
                   value={String(range)}
diff --git a/src/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx b/src/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
index 4d4059172..6027e484c 100644
--- a/src/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
+++ b/src/frontend/components/_organisms/workspace-activity-bar/fbd-toolbox.tsx
@@ -2,6 +2,7 @@ import { BlockButton } from '../../_molecules/workspace-activity-bar/fbd/block'
 import { Comment } from '../../_molecules/workspace-activity-bar/fbd/comment'
 import { Connector } from '../../_molecules/workspace-activity-bar/fbd/connector'
 import { Continuation } from '../../_molecules/workspace-activity-bar/fbd/continuation'
+import { Execute } from '../../_molecules/workspace-activity-bar/fbd/execute'
 import { InputVariable } from '../../_molecules/workspace-activity-bar/fbd/input-variable'
 import { OutVariable } from '../../_molecules/workspace-activity-bar/fbd/out-variable'
 import { TooltipSidebarWrapperButton } from '../../_molecules/workspace-activity-bar/tooltip-button'
@@ -30,6 +31,9 @@ export const FBDToolbox = () => {
       <TooltipSidebarWrapperButton tooltipContent='Continuation'>
         <Continuation onDragStart={(event) => handleDragStart(event, 'continuation')} />
       </TooltipSidebarWrapperButton>
+      <TooltipSidebarWrapperButton tooltipContent='Execute — inline Structured Text'>
+        <Execute onDragStart={(event) => handleDragStart(event, 'execute')} />
+      </TooltipSidebarWrapperButton>
       <TooltipSidebarWrapperButton tooltipContent='Comment'>
         <Comment onDragStart={(event) => handleDragStart(event, 'comment')} />
       </TooltipSidebarWrapperButton>
diff --git a/src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx b/src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
index a6733487a..4942c9e1b 100644
--- a/src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
+++ b/src/frontend/components/_organisms/workspace-activity-bar/ladder-toolbox.tsx
@@ -7,6 +7,7 @@ import { DeleteElementButton } from '../../_molecules/workspace-activity-bar/def
 import { BlockButton } from '../../_molecules/workspace-activity-bar/ladder/block'
 import { CoilButton } from '../../_molecules/workspace-activity-bar/ladder/coil'
 import { ContactButton } from '../../_molecules/workspace-activity-bar/ladder/contact'
+import { ExecuteButton } from '../../_molecules/workspace-activity-bar/ladder/execute'
 import { TooltipSidebarWrapperButton } from '../../_molecules/workspace-activity-bar/tooltip-button'
 
 export const LadderToolbox = () => {
@@ -118,6 +119,9 @@ export const LadderToolbox = () => {
       <TooltipSidebarWrapperButton tooltipContent='Contact'>
         <ContactButton onDragStart={(event) => handleDragStart(event, 'contact')} />
       </TooltipSidebarWrapperButton>
+      <TooltipSidebarWrapperButton tooltipContent='Execute — inline Structured Text'>
+        <ExecuteButton onDragStart={(event) => handleDragStart(event, 'execute')} />
+      </TooltipSidebarWrapperButton>
       <DividerActivityBar />
       <TooltipSidebarWrapperButton tooltipContent='Delete selected elements'>
         <DeleteElementButton
diff --git a/src/frontend/components/_templates/accelerator-handler.tsx b/src/frontend/components/_templates/accelerator-handler.tsx
index 45d559348..f796a6bbe 100644
--- a/src/frontend/components/_templates/accelerator-handler.tsx
+++ b/src/frontend/components/_templates/accelerator-handler.tsx
@@ -66,9 +66,11 @@ const AcceleratorHandler = () => {
   useEffect(() => {
     if (!capabilities.hasProjectExport) return
 
-    const unsub = accelerator.onExportProject(() => {
+    const unsub = accelerator.onExportProject((format) => {
       setRequestFlag(true)
-      setParseTo('old-editor')
+      // Defaulting to 'old-editor' keeps platforms whose menu sends no dialect
+      // on the PLCOpen export.
+      setParseTo(format ?? 'old-editor')
     })
 
     if (requestFlag && parseTo) {
@@ -91,6 +93,18 @@ const AcceleratorHandler = () => {
     return unsub
   }, [requestFlag, parseTo, accelerator, compilerPort, capabilities.hasProjectExport, project])
 
+  /**
+   * Import PLCopen XML accelerator. Opens the confirm-overwrite modal rather
+   * than importing directly, since an import replaces the open project's
+   * contents in place.
+   */
+  useEffect(() => {
+    if (!capabilities.hasProjectImport) return
+    return accelerator.onImportProject(() => {
+      openModal('confirm-plcopen-import')
+    })
+  }, [accelerator, capabilities.hasProjectImport, openModal])
+
   /**
    * Create project
    */
diff --git a/src/frontend/hooks/use-st-debug-decorations.ts b/src/frontend/hooks/use-st-debug-decorations.ts
new file mode 100644
index 000000000..2a1ce94cc
--- /dev/null
+++ b/src/frontend/hooks/use-st-debug-decorations.ts
@@ -0,0 +1,192 @@
+/**
+ * Inline debug-value badges for a Structured Text Monaco surface.
+ *
+ * During a debug session every occurrence of a live variable in the
+ * source gets an ` = <value>` badge rendered after it. The mechanism is
+ * purely name-based: the debug store keys values by
+ * `<prefix><variableName>`, so decorating is a matter of finding those
+ * names in the text and attaching an `after` decoration.
+ *
+ * Extracted from the POU-level Monaco editor so the graphical Execute
+ * ("ST Block") element gets identical badges without duplicating the
+ * scanner. The POU editor supplies its own prefix (`<pouName>:`, or an
+ * instance-qualified one for function blocks); the Execute field
+ * supplies the prefix of the POU that owns it.
+ *
+ * Comments are stripped before scanning so a variable named in a
+ * comment doesn't collect a badge.
+ */
+
+import type * as monaco from 'monaco-editor'
+import { type RefObject, useEffect, useMemo } from 'react'
+
+import { useDebugBoolValuesMap, useDebugNonBoolValuesMap } from './use-debug-value'
+
+type BlockCommentState = false | 'paren' | 'slash'
+
+/**
+ * Blank out comment spans in a single line, carrying block-comment
+ * state across lines. Characters are replaced with spaces rather than
+ * removed so column positions stay aligned with the real line.
+ *
+ * ST has two block-comment forms — `(* … *)` and `/* … *\/` — plus
+ * `//` to end of line.
+ */
+function stripLineComments(line: string, state: BlockCommentState): { stripped: string; state: BlockCommentState } {
+  const chars = [...line]
+  let i = 0
+  let s = state
+
+  while (i < chars.length) {
+    if (s) {
+      const endMarker = s === 'paren' ? ')' : '/'
+      if (chars[i] === '*' && chars[i + 1] === endMarker) {
+        chars[i] = ' '
+        chars[i + 1] = ' '
+        i += 2
+        s = false
+      } else {
+        chars[i] = ' '
+        i++
+      }
+    } else {
+      if (chars[i] === '/' && chars[i + 1] === '/') {
+        for (let j = i; j < chars.length; j++) chars[j] = ' '
+        break
+      }
+      if (chars[i] === '(' && chars[i + 1] === '*') {
+        chars[i] = ' '
+        chars[i + 1] = ' '
+        i += 2
+        s = 'paren'
+      } else if (chars[i] === '/' && chars[i + 1] === '*') {
+        chars[i] = ' '
+        chars[i + 1] = ' '
+        i += 2
+        s = 'slash'
+      } else {
+        i++
+      }
+    }
+  }
+
+  return { stripped: chars.join(''), state: s }
+}
+
+export type UseStDebugDecorationsOptions = {
+  editorRef: RefObject<monaco.editor.IStandaloneCodeEditor | null>
+  monacoRef: RefObject<typeof monaco | null>
+  /** Composite-key prefix, e.g. `MyProgram:` or `Prog:fbInstance.`. */
+  prefix: string | undefined
+  /** Gate — callers pass false when hidden, not debugging, or non-ST. */
+  enabled: boolean
+  /**
+   * Any value that changes when the model's text changes, so the scan
+   * re-runs. The POU editor passes Monaco's version id; simpler
+   * surfaces can pass the text itself.
+   */
+  modelVersion: unknown
+  /**
+   * Optional guard: when set, decorations are skipped unless the
+   * editor's model URI matches. The POU editor needs this because
+   * `@monaco-editor/react` can swap models a tick after a tab change.
+   */
+  expectedUri?: string
+}
+
+export function useStDebugDecorations({
+  editorRef,
+  monacoRef,
+  prefix,
+  enabled,
+  modelVersion,
+  expectedUri,
+}: UseStDebugDecorationsOptions): void {
+  const debugBoolValues = useDebugBoolValuesMap()
+  const debugNonBoolValues = useDebugNonBoolValuesMap()
+
+  // Cheap identity for "which variables are live", so the scan doesn't
+  // re-run on every poll tick that merely changes values.
+  const debugVarKeySet = useMemo(() => {
+    const keys: string[] = []
+    for (const key of debugBoolValues.keys()) keys.push(key)
+    for (const key of debugNonBoolValues.keys()) keys.push(key)
+    return keys.sort().join('\0')
+  }, [debugBoolValues, debugNonBoolValues])
+
+  const positions = useMemo(() => {
+    if (!enabled || prefix === undefined) return null
+    const editor = editorRef.current
+    if (!editor || !monacoRef.current) return null
+
+    const model = editor.getModel()
+    if (!model) return null
+    if (expectedUri !== undefined && model.uri.toString() !== expectedUri) return null
+
+    const varNames: string[] = []
+    for (const key of debugBoolValues.keys()) {
+      if (key.startsWith(prefix)) varNames.push(key.slice(prefix.length))
+    }
+    for (const key of debugNonBoolValues.keys()) {
+      if (key.startsWith(prefix)) varNames.push(key.slice(prefix.length))
+    }
+    if (varNames.length === 0) return null
+
+    // Longest first so `motor.speed` claims its span before `motor` can.
+    varNames.sort((a, b) => b.length - a.length)
+
+    const exprPatterns = varNames.map((expr) => {
+      const escaped = expr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      return { expr, pattern: new RegExp(`\\b${escaped}(?![\\w.\\[])`, 'gi') }
+    })
+
+    const found: Array<{ expr: string; line: number; startCol: number; endCol: number }> = []
+    let blockCommentState: BlockCommentState = false
+
+    for (let lineNumber = 1; lineNumber <= model.getLineCount(); lineNumber++) {
+      const result = stripLineComments(model.getLineContent(lineNumber), blockCommentState)
+      blockCommentState = result.state
+      const claimed: Array<[number, number]> = []
+
+      for (const { expr, pattern } of exprPatterns) {
+        pattern.lastIndex = 0
+        let match: RegExpExecArray | null
+        while ((match = pattern.exec(result.stripped)) !== null) {
+          const startCol = match.index + 1
+          const endCol = startCol + match[0].length
+          if (claimed.some(([s, e]) => startCol < e && endCol > s)) continue
+          claimed.push([startCol, endCol])
+          found.push({ expr, line: lineNumber, startCol, endCol })
+          break
+        }
+      }
+    }
+
+    return found
+    // `debugVarKeySet` stands in for the two maps' key sets; values are
+    // read in the effect below, which reruns on every poll.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled, prefix, expectedUri, debugVarKeySet, modelVersion])
+
+  useEffect(() => {
+    const editor = editorRef.current
+    const monacoInstance = monacoRef.current
+    if (!positions || !editor || !monacoInstance || prefix === undefined) return
+
+    const decorations: monaco.editor.IModelDeltaDecoration[] = positions.map(({ expr, line, startCol, endCol }) => ({
+      range: new monacoInstance.Range(line, startCol, line, endCol),
+      options: {
+        after: {
+          content: ` = ${debugBoolValues.get(prefix + expr) ?? debugNonBoolValues.get(prefix + expr) ?? '?'} `,
+          inlineClassName: 'debug-inline-value',
+        },
+      },
+    }))
+
+    const collection = editor.createDecorationsCollection(decorations)
+    return () => collection.clear()
+    // `editorRef` / `monacoRef` are refs: stable identities that never
+    // trigger a rerun, and re-reading them here is the point.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [positions, prefix, debugBoolValues, debugNonBoolValues])
+}
diff --git a/src/frontend/services/st-lsp/__tests__/execute-sync.test.ts b/src/frontend/services/st-lsp/__tests__/execute-sync.test.ts
new file mode 100644
index 000000000..1cb296ee1
--- /dev/null
+++ b/src/frontend/services/st-lsp/__tests__/execute-sync.test.ts
@@ -0,0 +1,214 @@
+import type { PLCPou } from '../../../../middleware/shared/ports/types'
+import { getBodyLineOffset } from '../../lsp-shared/body-offsets'
+
+// The store is a module-level singleton in the real app; stub it so the sync
+// layer can be driven directly.
+const state: {
+  project: { data: { pous: PLCPou[] } }
+  ladderFlows: unknown[]
+  fbdFlows: unknown[]
+  projectActions: { getAliasIndex: () => ReadonlyMap<string, string> }
+} = {
+  project: { data: { pous: [] } },
+  ladderFlows: [],
+  fbdFlows: [],
+  projectActions: { getAliasIndex: () => new Map() },
+}
+
+jest.mock('../../../store', () => ({
+  openPLCStoreBase: {
+    getState: () => state,
+    subscribe: () => () => {},
+  },
+}))
+
+// eslint-disable-next-line import/first -- must follow the store mock
+import { attachExecuteSync, collectExecuteDocs, getExecuteDraftApi } from '../execute-sync'
+
+function makePou(name: string): PLCPou {
+  return {
+    name,
+    pouType: 'program',
+    interface: {
+      variables: [
+        {
+          id: '1',
+          name: 'counter',
+          class: 'local',
+          type: { definition: 'base-type', value: 'INT' },
+          location: '',
+          documentation: '',
+          debug: false,
+        },
+      ],
+    },
+    body: { language: 'ld', value: { rungs: [] } },
+  } as unknown as PLCPou
+}
+
+function makeService() {
+  return {
+    ready: Promise.resolve(),
+    refreshStlibs: jest.fn(),
+    openDocument: jest.fn(),
+    changeDocument: jest.fn(),
+    closeDocument: jest.fn(),
+    dispose: jest.fn(),
+  }
+}
+
+const EXECUTE_URI = 'inmemory://execute/main/EXECUTE_1.st'
+
+beforeEach(() => {
+  state.project.data.pous = [makePou('main')]
+  state.ladderFlows = []
+  state.fbdFlows = []
+})
+
+describe('collectExecuteDocs', () => {
+  it('finds Execute nodes across ladder and FBD flows', () => {
+    state.ladderFlows = [
+      { name: 'main', rungs: [{ nodes: [{ id: 'X', type: 'execute', data: { code: 'counter := 1;' } }] }] },
+    ]
+    state.fbdFlows = [
+      { name: 'main', rung: { nodes: [{ id: 'Y', type: 'execute', data: { code: 'counter := 2;' } }] } },
+    ]
+
+    const docs = collectExecuteDocs(state as never)
+
+    expect(docs.map((d) => d.uri)).toEqual(['inmemory://execute/main/X.st', 'inmemory://execute/main/Y.st'])
+  })
+
+  it('skips empty snippets and nodes whose POU is gone', () => {
+    state.ladderFlows = [
+      {
+        name: 'main',
+        rungs: [
+          {
+            nodes: [
+              { id: 'A', type: 'execute', data: { code: '   ' } },
+              { id: 'B', type: 'coil', data: {} },
+            ],
+          },
+        ],
+      },
+      { name: 'deleted-pou', rungs: [{ nodes: [{ id: 'C', type: 'execute', data: { code: 'x := 1;' } }] }] },
+    ]
+
+    expect(collectExecuteDocs(state as never)).toEqual([])
+  })
+})
+
+describe('live draft channel', () => {
+  // Regression: diagnostics used to be driven only off the store, which learns
+  // the snippet on blur. By then the field is often deselected and its Monaco
+  // model disposed, so markers had nowhere to land — a bad identifier surfaced
+  // only at compile time, which is exactly what this element exists to avoid.
+  it('publishes a draft immediately, without waiting for a store commit', () => {
+    const service = makeService()
+    const handle = attachExecuteSync(service as never)
+
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := notAVariable + 1;')
+
+    expect(service.openDocument).toHaveBeenCalledTimes(1)
+    const [uri, text] = service.openDocument.mock.calls[0] as [string, string]
+    expect(uri).toBe(EXECUTE_URI)
+    // The snippet is wrapped in a shell carrying the POU's declarations, so
+    // strucpp resolves `counter` and flags `notAVariable`.
+    expect(text).toContain('counter : INT;')
+    expect(text).toContain('counter := notAVariable + 1;')
+
+    handle.dispose()
+  })
+
+  it('records a body offset that points at the snippet, not the preamble', () => {
+    const service = makeService()
+    const handle = attachExecuteSync(service as never)
+
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;')
+
+    const [, text] = service.openDocument.mock.calls[0] as [string, string]
+    const offset = getBodyLineOffset(EXECUTE_URI)
+    // A diagnostic the worker reports on `offset + 1` must map to snippet
+    // line 1; get this wrong and every squiggle lands on the wrong line.
+    expect(text.split('\n')[offset]).toBe('counter := 1;')
+
+    handle.dispose()
+  })
+
+  it('sends didChange for an edit and nothing at all for an unchanged draft', () => {
+    const service = makeService()
+    const handle = attachExecuteSync(service as never)
+
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;')
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;')
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 2;')
+
+    expect(service.openDocument).toHaveBeenCalledTimes(1)
+    expect(service.changeDocument).toHaveBeenCalledTimes(1)
+
+    handle.dispose()
+  })
+
+  it('ignores URIs that are not Execute documents, and unknown POUs', () => {
+    const service = makeService()
+    const handle = attachExecuteSync(service as never)
+
+    getExecuteDraftApi()?.syncDraft('inmemory://pou/main.st', 'counter := 1;')
+    getExecuteDraftApi()?.syncDraft('inmemory://execute/nope/X.st', 'counter := 1;')
+
+    expect(service.openDocument).not.toHaveBeenCalled()
+
+    handle.dispose()
+  })
+
+  it('is null once disposed, so callers degrade instead of throwing', () => {
+    const handle = attachExecuteSync(makeService() as never)
+    expect(getExecuteDraftApi()).not.toBeNull()
+
+    handle.dispose()
+
+    expect(getExecuteDraftApi()).toBeNull()
+  })
+  // Regression: `openDocument` sets version 1, and this layer used to pass its
+  // own counter — which also started at 1 — so the first edit collided and the
+  // worker silently dropped it. `start-language-service` documents that exact
+  // trap at its `changeDocument`. Omitting the version lets the service
+  // auto-increment, which is correct by construction.
+  it('never supplies its own document version', () => {
+    const service = makeService()
+    const handle = attachExecuteSync(service as never)
+
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;')
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 2;')
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 3;')
+
+    for (const call of service.changeDocument.mock.calls) {
+      expect(call).toHaveLength(2)
+    }
+
+    handle.dispose()
+  })
+
+  // Regression: diagnostics are a one-shot notification, so markers land only
+  // on the model that exists when they arrive. Opening the expand modal builds
+  // a fresh model at the same URI with unchanged text — without a forced
+  // re-analyse the worker stays silent and that model shows no squiggles.
+  it('re-publishes unchanged text when forced, so a newly mounted model gets markers', () => {
+    const service = makeService()
+    const handle = attachExecuteSync(service as never)
+
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;')
+    expect(service.changeDocument).not.toHaveBeenCalled()
+
+    // Same text, no force — nothing to say.
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;')
+    expect(service.changeDocument).not.toHaveBeenCalled()
+
+    // Same text, forced — the worker must re-analyse and re-publish.
+    getExecuteDraftApi()?.syncDraft(EXECUTE_URI, 'counter := 1;', true)
+    expect(service.changeDocument).toHaveBeenCalledTimes(1)
+
+    handle.dispose()
+  })
+})
diff --git a/src/frontend/services/st-lsp/boot.ts b/src/frontend/services/st-lsp/boot.ts
index 3c1181f82..6be69e17a 100644
--- a/src/frontend/services/st-lsp/boot.ts
+++ b/src/frontend/services/st-lsp/boot.ts
@@ -18,6 +18,7 @@
 
 import type { PlatformPorts } from '../../../middleware/shared/providers/types'
 import { toast } from '../../utils/toast'
+import { attachExecuteSync } from './execute-sync'
 import { startStLsp } from './index'
 import { attachMonacoModelSync, type MonacoModelSyncHandle } from './monaco-model-sync'
 import {
@@ -88,6 +89,11 @@ export function bootStLsp(
   // opens a project, the subscribe fires and the worker sees a
   // didOpen wave for every POU.
   const projectSync = attachProjectSync(service)
+  // Execute ("ST Block") snippets live inside graphical bodies, which
+  // project-sync sends to the worker as opaque signature stubs.  This
+  // second sync gives each snippet its own document so it gets real
+  // diagnostics instead of none.
+  const executeSync = attachExecuteSync(service)
   // Both library-sync layers force a document re-publish after the
   // stlib cache settles.  The worker doesn't re-run analysis on
   // cache mutations, so without this nudge documents keep their
@@ -119,6 +125,7 @@ export function bootStLsp(
       unsubscribeBundledLibrariesSync()
       unsubscribeEnabledLibrariesSync()
       unsubscribeLibrarySync()
+      executeSync.dispose()
       projectSync.dispose()
       modelSync?.dispose()
       service.dispose()
diff --git a/src/frontend/services/st-lsp/execute-sync.ts b/src/frontend/services/st-lsp/execute-sync.ts
new file mode 100644
index 000000000..b7dbca49f
--- /dev/null
+++ b/src/frontend/services/st-lsp/execute-sync.ts
@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2025 Autonomy / OpenPLC Project
+/**
+ * Execute ("ST Block") snippets → LSP document sync.
+ *
+ * A graphical POU's body reaches the LSP as a signature-only `stub://`
+ * document, so a snippet inside an LD/FBD diagram would get no diagnostics at
+ * all. Each Execute node instead gets its own synthetic document — the owning
+ * POU's declarations wrapped around the snippet — which strucpp type-checks
+ * like any textual ST body.
+ *
+ * The document URI doubles as the Monaco model URI of the node's editing
+ * surface, which is what makes diagnostics attach (see `execute-st-uri.ts`).
+ * `setBodyLineOffset` records the synthesized preamble's height so reported
+ * lines map back onto the snippet. The shell POU carries a throwaway,
+ * node-stable name so it cannot collide with the POU's real `stub://`
+ * declaration, which is open at the same time.
+ *
+ * Diffed against a snapshot the way `project-sync` diffs POUs.
+ */
+
+import type { PLCPou } from '../../../middleware/shared/ports/types'
+import { openPLCStoreBase } from '../../store'
+import { executeStDocumentUri, executeStScopeId, parseExecuteStDocumentUri } from '../../utils/PLC/execute-st-uri'
+import { serializePouScopeForBody } from '../../utils/PLC/pou-signature-serializer'
+import { deleteBodyLineOffset, setBodyLineOffset } from '../lsp-shared/body-offsets'
+import type { StLspService } from './types'
+
+/** Debounce for keystroke-driven `didChange`, in ms. */
+const SYNC_DEBOUNCE_MS = 250
+
+export interface ExecuteSyncHandle {
+  dispose(): void
+}
+
+/**
+ * Live-draft channel for an open Execute editor.
+ *
+ * The store only learns the snippet on blur, so a store-driven sync delivers
+ * diagnostics a commit late. The open editor pushes its draft straight through
+ * here instead. Registered the way `scoped-query.ts` registers its API:
+ * module-level, null whenever the LSP is unavailable (tests, boot races,
+ * worker crash) so callers degrade rather than throw.
+ */
+export interface ExecuteDraftApi {
+  /**
+   * Publish a snippet now. `force` re-sends unchanged text with a bumped
+   * version so the worker re-analyses — needed because diagnostics are a
+   * one-shot notification, and a model created later (the expand modal builds
+   * a fresh one) would otherwise never receive markers.
+   */
+  syncDraft(uri: string, code: string, force?: boolean): void
+}
+
+let draftApi: ExecuteDraftApi | null = null
+
+export function getExecuteDraftApi(): ExecuteDraftApi | null {
+  return draftApi
+}
+
+type Snapshot = {
+  contentByUri: Map<string, string>
+}
+
+/** One Execute node paired with the POU that owns it. */
+type ExecuteDoc = {
+  uri: string
+  pou: PLCPou
+  nodeId: string
+  code: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/**
+ * Collect every Execute node across the project's graphical flows.
+ *
+ * Reads the live flow slices rather than `pou.body.value`, whose write-back is
+ * debounced and can lag the canvas.
+ */
+export function collectExecuteDocs(state: {
+  project: { data: { pous: PLCPou[] } }
+  ladderFlows: Array<{ name: string; rungs: Array<{ nodes: Array<{ id: string; type?: string; data: unknown }> }> }>
+  fbdFlows: Array<{ name: string; rung: { nodes: Array<{ id: string; type?: string; data: unknown }> } }>
+}): ExecuteDoc[] {
+  const out: ExecuteDoc[] = []
+  const pouByName = new Map(state.project.data.pous.map((pou) => [pou.name, pou]))
+
+  const visit = (pouName: string, nodes: Array<{ id: string; type?: string; data: unknown }>) => {
+    const pou = pouByName.get(pouName)
+    if (!pou) return
+    for (const node of nodes) {
+      if (node.type !== 'execute') continue
+      if (!isRecord(node.data)) continue
+      const code = node.data['code']
+      if (typeof code !== 'string' || code.trim() === '') continue
+      out.push({ uri: executeStDocumentUri(pouName, node.id), pou, nodeId: node.id, code })
+    }
+  }
+
+  for (const flow of state.ladderFlows) {
+    for (const rung of flow.rungs) visit(flow.name, rung.nodes)
+  }
+  for (const flow of state.fbdFlows) visit(flow.name, flow.rung.nodes)
+
+  return out
+}
+
+export function attachExecuteSync(service: StLspService): ExecuteSyncHandle {
+  const snapshot: Snapshot = { contentByUri: new Map() }
+  let disposed = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  // As `project-sync`: `AT <alias>` is not legal IEC, so the LSP must see
+  // resolved literal addresses or the whole VAR block is lost.
+  const aliasIndex = (): ReadonlyMap<string, string> => openPLCStoreBase.getState().projectActions.getAliasIndex()
+
+  function reconcile(): void {
+    if (disposed) return
+    const state = openPLCStoreBase.getState()
+    const docs = collectExecuteDocs(state)
+    const seen = new Set<string>()
+
+    for (const doc of docs) {
+      seen.add(doc.uri)
+      publish(doc.uri, doc.pou, doc.nodeId, doc.code)
+    }
+
+    // Close what disappeared: node deleted or emptied, POU removed or renamed
+    // (a rename changes the URI, so it surfaces as a close plus an open).
+    for (const uri of [...snapshot.contentByUri.keys()]) {
+      if (seen.has(uri)) continue
+      service.closeDocument(uri)
+      snapshot.contentByUri.delete(uri)
+      deleteBodyLineOffset(uri)
+    }
+  }
+
+  /**
+   * Publish one snippet. Shares `snapshot.contentByUri` with `reconcile`, so
+   * whichever ran last owns the document and identical text is a no-op.
+   */
+  function publish(uri: string, pou: PLCPou, nodeId: string, code: string, force = false): void {
+    if (disposed) return
+    const { text, bodyLineOffset } = serializePouScopeForBody(pou, code, executeStScopeId(nodeId), aliasIndex())
+    setBodyLineOffset(uri, bodyLineOffset)
+
+    const previous = snapshot.contentByUri.get(uri)
+    if (previous === undefined) {
+      service.openDocument(uri, text)
+    } else if (previous !== text || force) {
+      // No external version: `openDocument` sets version 1, so a caller-side
+      // counter starting at 1 collides on the first edit and the worker drops
+      // it. Letting the service auto-increment is what that fallback is for.
+      service.changeDocument(uri, text)
+    } else {
+      return
+    }
+    snapshot.contentByUri.set(uri, text)
+  }
+
+  draftApi = {
+    syncDraft(uri, code, force = false) {
+      const parsed = parseExecuteStDocumentUri(uri)
+      if (parsed === null) return
+      const pou = openPLCStoreBase.getState().project.data.pous.find((p) => p.name === parsed.pouName)
+      if (!pou) return
+      publish(uri, pou, parsed.nodeId, code, force)
+    },
+  }
+
+  function schedule(): void {
+    if (disposed) return
+    if (timer !== null) clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = null
+      reconcile()
+    }, SYNC_DEBOUNCE_MS)
+  }
+
+  // Selector-scoped, matching `project-sync` — a blanket subscribe would fire
+  // on every store write, including each debug poll tick. Three triggers: the
+  // flows carry the snippet text, the POU list carries the declarations the
+  // shell embeds, and the alias index changes on a pure re-address.
+  const unsubscribeLadder = openPLCStoreBase.subscribe((state) => state.ladderFlows, schedule)
+  const unsubscribeFbd = openPLCStoreBase.subscribe((state) => state.fbdFlows, schedule)
+  const unsubscribePous = openPLCStoreBase.subscribe((state) => state.project.data.pous, schedule)
+  const unsubscribeAliases = openPLCStoreBase.subscribe((state) => state.projectActions.getAliasIndex(), schedule)
+  const unsubscribe = () => {
+    unsubscribeAliases()
+    unsubscribePous()
+    unsubscribeFbd()
+    unsubscribeLadder()
+  }
+
+  return {
+    dispose() {
+      disposed = true
+      draftApi = null
+      if (timer !== null) {
+        clearTimeout(timer)
+        timer = null
+      }
+      unsubscribe()
+      for (const uri of snapshot.contentByUri.keys()) {
+        service.closeDocument(uri)
+        deleteBodyLineOffset(uri)
+      }
+      snapshot.contentByUri.clear()
+    },
+  }
+}
diff --git a/src/frontend/services/st-lsp/types.ts b/src/frontend/services/st-lsp/types.ts
index 31f6f5f0b..6376bb320 100644
--- a/src/frontend/services/st-lsp/types.ts
+++ b/src/frontend/services/st-lsp/types.ts
@@ -97,8 +97,16 @@ export interface StLspService {
    */
   openDocument(uri: string, content: string): void
 
-  /** Notify the worker of a content change in an already-open doc. */
-  changeDocument(uri: string, content: string, version: number): void
+  /**
+   * Notify the worker of a content change in an already-open doc.
+   *
+   * `version` is optional and usually better omitted: `openDocument` sets
+   * version 1, so a caller-side counter starting at 1 collides on the first
+   * edit and the worker drops it. Omitting it lets the service advance its own
+   * per-URI counter. Pass one only with a genuinely monotonic project-wide
+   * counter, as `project-sync` has.
+   */
+  changeDocument(uri: string, content: string, version?: number): void
 
   /** Notify the worker the document is no longer open. */
   closeDocument(uri: string): void
diff --git a/src/frontend/store/__tests__/fbd-types.test.ts b/src/frontend/store/__tests__/fbd-types.test.ts
index 3071b31a7..cba5b9ecd 100644
--- a/src/frontend/store/__tests__/fbd-types.test.ts
+++ b/src/frontend/store/__tests__/fbd-types.test.ts
@@ -96,6 +96,7 @@ describe('FBD Zod schemas', () => {
       'comment',
       'connector',
       'connection',
+      'execute',
       'input-variable',
       'output-variable',
       'inout-variable',
diff --git a/src/frontend/store/__tests__/ladder-types.test.ts b/src/frontend/store/__tests__/ladder-types.test.ts
index 3c722fa35..3942d15f7 100644
--- a/src/frontend/store/__tests__/ladder-types.test.ts
+++ b/src/frontend/store/__tests__/ladder-types.test.ts
@@ -123,7 +123,7 @@ describe('Ladder Zod schemas', () => {
   })
 
   describe('zodLadderNodeTypesSchema', () => {
-    const validTypes = ['block', 'contact', 'coil', 'parallel', 'powerRail', 'variable']
+    const validTypes = ['block', 'contact', 'coil', 'execute', 'parallel', 'powerRail', 'variable']
 
     it.each(validTypes)('accepts valid node type: %s', (type) => {
       const result = zodLadderNodeTypesSchema.safeParse(type)
diff --git a/src/frontend/store/__tests__/modal-slice.test.ts b/src/frontend/store/__tests__/modal-slice.test.ts
index c3a59811d..cd46c3e0a 100644
--- a/src/frontend/store/__tests__/modal-slice.test.ts
+++ b/src/frontend/store/__tests__/modal-slice.test.ts
@@ -12,6 +12,8 @@ const ALL_MODAL_TYPES: ModalTypes[] = [
   'block-ladder-element',
   'coil-ladder-element',
   'contact-ladder-element',
+  'execute-ladder-element',
+  'execute-fbd-element',
   'block-fbd-element',
   'create-project',
   'save-changes-project',
diff --git a/src/frontend/store/slices/fbd/types.ts b/src/frontend/store/slices/fbd/types.ts
index 9bd515b84..911ed8cc3 100644
--- a/src/frontend/store/slices/fbd/types.ts
+++ b/src/frontend/store/slices/fbd/types.ts
@@ -16,6 +16,7 @@ const zodFBDNodeTypesSchema = z.enum([
   'comment',
   'connector',
   'connection',
+  'execute',
   'input-variable',
   'output-variable',
   'inout-variable',
diff --git a/src/frontend/store/slices/ladder/types.ts b/src/frontend/store/slices/ladder/types.ts
index 4e5dedfd7..a6830e142 100644
--- a/src/frontend/store/slices/ladder/types.ts
+++ b/src/frontend/store/slices/ladder/types.ts
@@ -11,7 +11,7 @@ const zodLadderFlowStateSchema = z.object({
 })
 type ZodLadderFlowState = z.infer<typeof zodLadderFlowStateSchema>
 
-const zodLadderNodeTypesSchema = z.enum(['block', 'contact', 'coil', 'parallel', 'powerRail', 'variable'])
+const zodLadderNodeTypesSchema = z.enum(['block', 'contact', 'coil', 'execute', 'parallel', 'powerRail', 'variable'])
 type ZodLadderNodeType = z.infer<typeof zodLadderNodeTypesSchema>
 
 import type { HandleBranch, RungLadderState } from '../../../../middleware/shared/ports/types'
diff --git a/src/frontend/store/slices/modal/slice.ts b/src/frontend/store/slices/modal/slice.ts
index 7e7843631..9560454b8 100644
--- a/src/frontend/store/slices/modal/slice.ts
+++ b/src/frontend/store/slices/modal/slice.ts
@@ -8,6 +8,8 @@ const ALL_MODAL_TYPES: ModalTypes[] = [
   'block-ladder-element',
   'coil-ladder-element',
   'contact-ladder-element',
+  'execute-ladder-element',
+  'execute-fbd-element',
   'block-fbd-element',
   'create-project',
   'save-changes-project',
diff --git a/src/frontend/store/slices/modal/types.ts b/src/frontend/store/slices/modal/types.ts
index a5efaeb31..7bf46f0ee 100644
--- a/src/frontend/store/slices/modal/types.ts
+++ b/src/frontend/store/slices/modal/types.ts
@@ -9,6 +9,13 @@ export type ModalTypes =
   | 'block-ladder-element'
   | 'coil-ladder-element'
   | 'contact-ladder-element'
+  /** Expanded ST editor for an Execute ("ST Block") element. Data
+   *  shape: the React Flow node. Opens on double-click or the node's
+   *  expand button, and — unlike the other graphical element modals —
+   *  also opens during a debug session, read-only, so the user can
+   *  read the running snippet with live value badges. */
+  | 'execute-ladder-element'
+  | 'execute-fbd-element'
   | 'block-fbd-element'
   | 'create-project'
   | 'save-changes-project'
diff --git a/src/frontend/utils/PLC/__tests__/execute-st-uri.test.ts b/src/frontend/utils/PLC/__tests__/execute-st-uri.test.ts
new file mode 100644
index 000000000..75bb03c7c
--- /dev/null
+++ b/src/frontend/utils/PLC/__tests__/execute-st-uri.test.ts
@@ -0,0 +1,57 @@
+import { executeStDocumentUri, executeStScopeId, parseExecuteStDocumentUri } from '../execute-st-uri'
+
+// The Monaco model URI and the LSP document URI for an Execute ("ST Block")
+// snippet must be the same string — `attachDiagnosticsBridge` matches
+// published diagnostics to models by comparing URIs, so a mismatch silently
+// costs the user their red squiggles with nothing logged to explain it.
+
+describe('executeStDocumentUri', () => {
+  it('builds a stable URI from POU name and node id', () => {
+    expect(executeStDocumentUri('Main', 'EXECUTE_a1b2')).toBe('inmemory://execute/Main/EXECUTE_a1b2.st')
+  })
+
+  it('percent-encodes names that would otherwise break the URI', () => {
+    const uri = executeStDocumentUri('My Program/v2', 'node/1')
+    expect(uri).toBe('inmemory://execute/My%20Program%2Fv2/node%2F1.st')
+    // Still round-trips despite the encoded separators.
+    expect(parseExecuteStDocumentUri(uri)).toEqual({ pouName: 'My Program/v2', nodeId: 'node/1' })
+  })
+
+  it('gives distinct URIs to the same node id under different POUs', () => {
+    expect(executeStDocumentUri('A', 'n1')).not.toBe(executeStDocumentUri('B', 'n1'))
+  })
+})
+
+describe('parseExecuteStDocumentUri', () => {
+  it('round-trips a generated URI', () => {
+    expect(parseExecuteStDocumentUri(executeStDocumentUri('Main', 'n1'))).toEqual({ pouName: 'Main', nodeId: 'n1' })
+  })
+
+  it('returns null for URIs belonging to other schemes', () => {
+    expect(parseExecuteStDocumentUri('inmemory://pou/Main.st')).toBeNull()
+    expect(parseExecuteStDocumentUri('inmemory://stub/Main.st')).toBeNull()
+    expect(parseExecuteStDocumentUri('file:///tmp/Main.st')).toBeNull()
+    expect(parseExecuteStDocumentUri('')).toBeNull()
+  })
+
+  it('returns null rather than throwing on malformed percent-encoding', () => {
+    // A stray `%` is not valid encoding; decodeURIComponent would throw, and
+    // this runs inside notification handlers walking every open document.
+    expect(parseExecuteStDocumentUri('inmemory://execute/%E0%A4%A/n1.st')).toBeNull()
+  })
+})
+
+describe('executeStScopeId', () => {
+  it('is stable for a given node id, so edits are didChange not close/reopen', () => {
+    expect(executeStScopeId('n1')).toBe(executeStScopeId('n1'))
+    expect(executeStScopeId('n1')).toBe('execute_n1')
+  })
+
+  it('sanitises characters that are not legal in an IEC identifier', () => {
+    expect(executeStScopeId('EXECUTE-a1/b2 c')).toBe('execute_EXECUTE_a1_b2_c')
+  })
+
+  it('distinguishes two different nodes', () => {
+    expect(executeStScopeId('n1')).not.toBe(executeStScopeId('n2'))
+  })
+})
diff --git a/src/frontend/utils/PLC/__tests__/pou-signature-serializer.test.ts b/src/frontend/utils/PLC/__tests__/pou-signature-serializer.test.ts
index 0e5787451..35a895c6d 100644
--- a/src/frontend/utils/PLC/__tests__/pou-signature-serializer.test.ts
+++ b/src/frontend/utils/PLC/__tests__/pou-signature-serializer.test.ts
@@ -2,6 +2,7 @@ import type { PLCPou } from '../../../../middleware/shared/ports/types'
 import {
   OPAQUE_BODY_PLACEHOLDER,
   SCOPE_QUERY_POU_NAME,
+  serializePouScopeForBody,
   serializePouScopeForQuery,
   serializePouSignatureToST,
   serializePouSignatureToSTWithBodyOffset,
@@ -382,4 +383,53 @@ describe('serializePouSignatureToST', () => {
       expect(text).not.toContain('VAR_EXTERNAL')
     })
   })
+  describe('serializePouScopeForBody', () => {
+    // Backs diagnostics for Execute ("ST Block") snippets. The line count it
+    // returns is fed to `setBodyLineOffset`, which shifts every diagnostic the
+    // worker reports back onto the lines the user can actually see — so an
+    // off-by-one here puts every red squiggle on the wrong line.
+    it('reports the preamble line count as the body offset', () => {
+      const pou = makePou({
+        name: 'Irrigation',
+        pouType: 'function-block',
+        interface: FB_VARIABLES,
+        body: { language: 'ld', value: {} as never },
+      })
+      const body = 'x := 1;\ny := 2;'
+      const { text, bodyLineOffset } = serializePouScopeForBody(pou, body)
+
+      // The offset must be the index of the snippet's first line.
+      expect(text.split('\n')[bodyLineOffset]).toBe('x := 1;')
+      expect(text.split('\n')[bodyLineOffset + 1]).toBe('y := 2;')
+    })
+
+    it('preserves a multi-line body verbatim, including blank lines and indentation', () => {
+      const pou = makePou({ body: { language: 'ld', value: {} as never } })
+      const body = 'IF a THEN\n    b := 1;\n\n    c := 2;\nEND_IF;'
+      const { text, bodyLineOffset } = serializePouScopeForBody(pou, body)
+
+      expect(
+        text
+          .split('\n')
+          .slice(bodyLineOffset, bodyLineOffset + 5)
+          .join('\n'),
+      ).toBe(body)
+    })
+
+    it('gives two nodes distinct shell names so they cannot collide', () => {
+      const pou = makePou({ body: { language: 'ld', value: {} as never } })
+      const a = serializePouScopeForBody(pou, 'x := 1;', 'execute_n1').text
+      const b = serializePouScopeForBody(pou, 'x := 1;', 'execute_n2').text
+
+      expect(a).toContain(`${SCOPE_QUERY_POU_NAME}execute_n1__`)
+      expect(b).toContain(`${SCOPE_QUERY_POU_NAME}execute_n2__`)
+      expect(a).not.toBe(b)
+    })
+
+    it("does not collide with the POU's own declaration", () => {
+      const pou = makePou({ name: 'Irrigation', body: { language: 'ld', value: {} as never } })
+      const { text } = serializePouScopeForBody(pou, 'x := 1;', 'execute_n1')
+      expect(text).not.toContain('PROGRAM Irrigation')
+    })
+  })
 })
diff --git a/src/frontend/utils/PLC/execute-plcopen.ts b/src/frontend/utils/PLC/execute-plcopen.ts
new file mode 100644
index 000000000..ca06fef82
--- /dev/null
+++ b/src/frontend/utils/PLC/execute-plcopen.ts
@@ -0,0 +1,134 @@
+/**
+ * PLCopen XML representation of the Execute ("ST Block") element.
+ *
+ * TC6 defines no element for inline Structured Text, so the snippet rides in
+ * `<addData>` — the standard's own extension mechanism. The element itself is
+ * an ordinary `<block typeName="EXECUTE">` with real `EN`/`ENO` formal
+ * parameters, so its rung wiring stays fully standard.
+ *
+ * The two exports differ deliberately. "Export to PLCOpen XML" reproduces
+ * Beremiz / the legacy OpenPLC Editor, which carries no vendor references, so
+ * it uses an openplc.org URI. "Export to CODESYS XML" matches what CODESYS
+ * writes, so it uses 3S's URI and their FBD-only descriptors. The importer
+ * accepts either.
+ */
+
+/** `@typeName` on the `<block>` element — the same in both dialects. */
+export const EXECUTE_TYPE_NAME = 'EXECUTE'
+
+/** Our own extension URI, used by the neutral PLCOpen export. */
+export const EXECUTE_STCODE_URI_OPENPLC = 'http://openplc.org/plcopenxml/stcode'
+
+/** 3S's extension URI, used by the CODESYS export and accepted on import. */
+export const EXECUTE_STCODE_URI_CODESYS = 'http://www.3s-software.com/plcopenxml/stcode'
+
+/** Every URI the importer recognises as carrying an Execute snippet. */
+const EXECUTE_STCODE_URIS: readonly string[] = [EXECUTE_STCODE_URI_OPENPLC, EXECUTE_STCODE_URI_CODESYS]
+
+/** CODESYS-only descriptors, emitted in FBD bodies by that dialect alone. */
+const CODESYS_FBD_CALLTYPE_URI = 'http://www.3s-software.com/plcopenxml/fbdcalltype'
+const CODESYS_FBD_INPUT_PARAM_TYPES_URI = 'http://www.3s-software.com/plcopenxml/inputparamtypes'
+const CODESYS_FBD_OUTPUT_PARAM_TYPES_URI = 'http://www.3s-software.com/plcopenxml/outputparamtypes'
+
+export type ExecuteXmlDialect = 'openplc' | 'codesys'
+
+/**
+ * Node types that serialise as a `<block>`.
+ *
+ * A consumer's `<connection>` names the pin it reads via `@formalParameter`,
+ * but only for block-shaped sources — a contact or variable has a single
+ * anonymous output. An Execute element is a block in the XML while carrying
+ * its own node type in the editor, so every such check has to admit it, or the
+ * pin name is dropped and the importer cannot rebuild the edge.
+ */
+export function isBlockLikeNodeType(nodeType: string | undefined): boolean {
+  return nodeType === 'block' || nodeType === 'execute'
+}
+
+/**
+ * Build the `<addData>` payload. `handleUnknown` is required by the spec and
+ * restricted to `preserve` / `discard` / `implementation`.
+ */
+export function buildExecuteAddData(code: string, dialect: ExecuteXmlDialect, language: 'ld' | 'fbd') {
+  if (dialect === 'openplc') {
+    return {
+      data: {
+        '@name': EXECUTE_STCODE_URI_OPENPLC,
+        '@handleUnknown': 'preserve',
+        STCode: { '#': code },
+      },
+    }
+  }
+
+  const stCode = {
+    '@name': EXECUTE_STCODE_URI_CODESYS,
+    '@handleUnknown': 'implementation',
+    STCode: { '@xmlns': '', '#': code },
+  }
+  if (language === 'ld') return { data: stCode }
+
+  return {
+    data: [
+      {
+        '@name': CODESYS_FBD_CALLTYPE_URI,
+        '@handleUnknown': 'implementation',
+        CallType: { '@xmlns': '', '#': 'execute' },
+      },
+      {
+        '@name': CODESYS_FBD_INPUT_PARAM_TYPES_URI,
+        '@handleUnknown': 'implementation',
+        InputParamTypes: { '@xmlns': '', '#': 'BOOL' },
+      },
+      {
+        '@name': CODESYS_FBD_OUTPUT_PARAM_TYPES_URI,
+        '@handleUnknown': 'implementation',
+        OutputParamTypes: { '@xmlns': '', '#': 'BOOL' },
+      },
+      stCode,
+    ],
+  }
+}
+
+type MaybeRecord = Record<string, unknown> | undefined
+
+function asRecord(value: unknown): MaybeRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined
+}
+
+/**
+ * Pull the ST snippet out of a parsed `<block>`, or null if this block isn't
+ * an Execute element.
+ *
+ * `@typeName` alone decides that: `EXECUTE` is the wire name CODESYS and
+ * TwinCAT both reserve for this element, and the `addData` is only where the
+ * payload rides. A block that says EXECUTE but carries no readable snippet is
+ * still an Execute box — it imports empty, which the user can fix, rather than
+ * as a nameless function block with pins nothing resolves to.
+ *
+ * Tolerates both shapes fast-xml-parser produces for `<STCode>`: a bare
+ * string, or `{ '$': text }` when the element carries attributes (CODESYS
+ * writes `xmlns=""` on it). `data` may be a single object or an array —
+ * CODESYS emits four entries for an FBD block and one for an LD block.
+ */
+export function readExecuteStCode(blockXml: unknown): string | null {
+  const block = asRecord(blockXml)
+  if (!block) return null
+  if (block['@typeName'] !== EXECUTE_TYPE_NAME) return null
+
+  const addData = asRecord(block.addData)
+  const entries = addData ? (Array.isArray(addData.data) ? addData.data : [addData.data]) : []
+  for (const entry of entries) {
+    const record = asRecord(entry)
+    if (!record) continue
+    const name = record['@name']
+    if (typeof name !== 'string' || !EXECUTE_STCODE_URIS.includes(name)) continue
+    const stCode = record.STCode
+    if (typeof stCode === 'string') return stCode
+    const wrapped = asRecord(stCode)
+    if (wrapped && typeof wrapped['$'] === 'string') return wrapped['$']
+    break
+  }
+  return ''
+}
diff --git a/src/frontend/utils/PLC/execute-st-uri.ts b/src/frontend/utils/PLC/execute-st-uri.ts
new file mode 100644
index 000000000..147a0ae9b
--- /dev/null
+++ b/src/frontend/utils/PLC/execute-st-uri.ts
@@ -0,0 +1,46 @@
+/**
+ * URI scheme for an Execute ("ST Block") element's snippet.
+ *
+ * The same string is the Monaco model URI of the node's editing surface AND
+ * the LSP document URI the snippet is opened under. `attachDiagnosticsBridge`
+ * matches diagnostics to models by comparing URI strings, so the two must
+ * agree exactly — hence one helper, imported by both sides.
+ *
+ * Lives in `utils/` rather than beside the LSP service so the components layer
+ * can reach it without violating the layer rules.
+ */
+
+const EXECUTE_URI_SCHEME = 'inmemory'
+const EXECUTE_URI_AUTHORITY = 'execute'
+
+/**
+ * Build the document URI for one Execute node. Both segments are
+ * percent-encoded, so a POU name containing a space or slash still yields a
+ * well-formed URI.
+ */
+export function executeStDocumentUri(pouName: string, nodeId: string): string {
+  return `${EXECUTE_URI_SCHEME}://${EXECUTE_URI_AUTHORITY}/${encodeURIComponent(pouName)}/${encodeURIComponent(nodeId)}.st`
+}
+
+/** Reverse of {@link executeStDocumentUri}; null when `uri` is not one of ours. */
+export function parseExecuteStDocumentUri(uri: string): { pouName: string; nodeId: string } | null {
+  const match = new RegExp(`^${EXECUTE_URI_SCHEME}://${EXECUTE_URI_AUTHORITY}/([^/]+)/(.+)\\.st$`).exec(uri)
+  if (!match) return null
+  try {
+    return { pouName: decodeURIComponent(match[1]), nodeId: decodeURIComponent(match[2]) }
+  } catch {
+    // Malformed percent-encoding — treat as "not ours" rather than throwing
+    // into whatever notification handler is walking open documents.
+    return null
+  }
+}
+
+/**
+ * Stable `uniqueId` for the throwaway POU shell wrapping a snippet (see
+ * `serializePouScopeForBody`). Sanitised because node ids may contain
+ * characters that are illegal in an IEC identifier; stable because that is
+ * what keeps an edit a `didChange` rather than a close/reopen pair.
+ */
+export function executeStScopeId(nodeId: string): string {
+  return `execute_${nodeId.replace(/[^A-Za-z0-9_]/g, '_')}`
+}
diff --git a/src/frontend/utils/PLC/pou-signature-serializer.ts b/src/frontend/utils/PLC/pou-signature-serializer.ts
index d3cb6377c..dd2062e79 100644
--- a/src/frontend/utils/PLC/pou-signature-serializer.ts
+++ b/src/frontend/utils/PLC/pou-signature-serializer.ts
@@ -209,4 +209,34 @@ export function serializePouScopeForQuery(
   return { text, position: { line: bodyLine, character: bodyExpr.length } }
 }
 
+/**
+ * Synthesize a self-contained ST document placing a MULTI-LINE body in
+ * `pou`'s scope, for diagnostics on an Execute ("ST Block") snippet.
+ *
+ * Thin wrapper over {@link serializePouScopeForQuery} — the shell it
+ * builds (real POU kind so `VAR_IN_OUT` stays legal, throwaway name so
+ * it can't collide with the POU's own `stub://` document, externals
+ * re-emitted as locals so they resolve without the CONFIGURATION, alias
+ * locations resolved to literal addresses) is exactly what a snippet
+ * needs too. The only difference is what the caller wants back: a
+ * completion query needs a cursor position, this needs the preamble's
+ * line count so `setBodyLineOffset` can shift the worker's diagnostics
+ * back onto the lines the user can actually see.
+ *
+ * `serializePouScopeForQuery` documents `bodyExpr` as single-line, and
+ * that constraint is real — but it applies only to the `character` half
+ * of the position it returns. `text` and the line count are correct for
+ * any body, which is why this wrapper takes the line and drops the rest
+ * rather than reimplementing the shell.
+ */
+export function serializePouScopeForBody(
+  pou: PLCPou,
+  body: string,
+  uniqueId?: number | string,
+  aliasIndex: ReadonlyMap<string, string> = EMPTY_ALIAS_INDEX,
+): { text: string; bodyLineOffset: number } {
+  const { text, position } = serializePouScopeForQuery(pou, body, uniqueId, aliasIndex)
+  return { text, bodyLineOffset: position.line }
+}
+
 export { OPAQUE_BODY_PLACEHOLDER, SCOPE_QUERY_POU_NAME }
diff --git a/src/frontend/utils/PLC/xml-generator/codesys/language/__tests__/fbd-execute.test.ts b/src/frontend/utils/PLC/xml-generator/codesys/language/__tests__/fbd-execute.test.ts
new file mode 100644
index 000000000..f8692e645
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/codesys/language/__tests__/fbd-execute.test.ts
@@ -0,0 +1,68 @@
+import { buildExecuteNode, buildVariableNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/buildNodes'
+import type { FBDRungState } from '@root/frontend/store/slices'
+import type { Edge, Node } from '@xyflow/react'
+
+import { fbdToXml } from '../fbd-xml'
+
+// The CODESYS dialect for an FBD Execute ("ST Block") element.
+//
+// It differs from the neutral export in one visible way: alongside the
+// snippet, CODESYS writes three descriptor entries that only ever appear on
+// FBD blocks. Reproducing them is what lets CODESYS reimport the element as a
+// real ST Block rather than an unknown POU call.
+
+const SNIPPET = 'level := level + 1;'
+
+const CODESYS_URI = 'http://www.3s-software.com/plcopenxml/'
+
+function buildRung(): FBDRungState {
+  const execute = buildExecuteNode({ id: 'X', position: { x: 200, y: 40 }, code: SNIPPET })
+  const source = buildVariableNode({ id: 'IV', position: { x: 20, y: 40 }, variant: 'input-variable' })
+  source.data.variable = { id: '', name: 'gate' }
+
+  const edges: Edge[] = [
+    { id: 'e1', source: 'IV', sourceHandle: source.data.outputConnector?.id, target: 'X', targetHandle: 'EN' },
+  ]
+
+  return {
+    comment: '',
+    selectedNodes: [],
+    nodes: [source, execute] as unknown as Node[],
+    edges,
+  } as unknown as FBDRungState
+}
+
+describe('codesys fbdToXml — Execute element', () => {
+  const block = (fbdToXml(buildRung()) as unknown as { body: { FBD: { block: Record<string, unknown>[] } } }).body.FBD
+    .block[0]
+  const entries = (block.addData as { data: { '@name': string; STCode?: { '#': string } }[] }).data
+
+  it('emits the element as a block with typeName EXECUTE', () => {
+    expect(block['@typeName']).toBe('EXECUTE')
+  })
+
+  it("writes the FBD-only descriptors alongside 3S's stcode", () => {
+    expect(entries.map((entry) => entry['@name'])).toEqual([
+      `${CODESYS_URI}fbdcalltype`,
+      `${CODESYS_URI}inputparamtypes`,
+      `${CODESYS_URI}outputparamtypes`,
+      `${CODESYS_URI}stcode`,
+    ])
+  })
+
+  it('carries the snippet verbatim under the stcode entry', () => {
+    const stCode = entries.find((entry) => entry['@name'] === `${CODESYS_URI}stcode`)
+    expect(stCode?.STCode?.['#']).toBe(SNIPPET)
+  })
+
+  it('declares EN wired to its source and ENO as an output', () => {
+    const inputs = block.inputVariables as {
+      variable: { '@formalParameter': string; connectionPointIn: { connection: unknown[] } }[]
+    }
+    const outputs = block.outputVariables as { variable: { '@formalParameter': string }[] }
+
+    expect(inputs.variable[0]['@formalParameter']).toBe('EN')
+    expect(inputs.variable[0].connectionPointIn.connection).toHaveLength(1)
+    expect(outputs.variable.map((v) => v['@formalParameter'])).toEqual(['ENO'])
+  })
+})
diff --git a/src/frontend/utils/PLC/xml-generator/codesys/language/__tests__/ladder-execute.test.ts b/src/frontend/utils/PLC/xml-generator/codesys/language/__tests__/ladder-execute.test.ts
new file mode 100644
index 000000000..257c6e217
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/codesys/language/__tests__/ladder-execute.test.ts
@@ -0,0 +1,89 @@
+import { buildExecuteNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/buildNodes'
+import { nodesBuilder } from '@root/frontend/components/_atoms/graphical-editor/ladder/node-builders'
+import type { RungLadderState } from '@root/frontend/store/slices'
+import type { Edge, Node } from '@xyflow/react'
+
+import { ladderToXml } from '../ladder-xml'
+
+// The CODESYS dialect for the Execute ("ST Block") element, exercised through
+// the topology it is actually used in: contact → EXECUTE → coil.
+//
+// That shape is what makes this dialect distinct — its contact/coil emitters
+// look up the *variant* of a block-shaped source to decide whether to name it
+// by pin or by function name. An Execute element is block-shaped in the XML
+// but carries no variant, so an unguarded lookup throws while exporting.
+
+const SNIPPET = 'total := total + 1;'
+
+function buildRung(): RungLadderState {
+  // `connector` names the side the rail's handle sits on, so the LEFT rail is
+  // built with `connector: 'right'` and vice versa — same as startLadderRung.
+  const left = nodesBuilder.powerRail({ id: 'L', posX: 0, posY: 0, handleX: 0, handleY: 20, connector: 'right' })
+  const contact = nodesBuilder.contact({ id: 'C', posX: 60, posY: 0, handleX: 60, handleY: 20, variant: 'default' })
+  const execute = buildExecuteNode({ id: 'X', posX: 140, posY: 0, handleX: 140, handleY: 20, code: SNIPPET })
+  const coil = nodesBuilder.coil({ id: 'K', posX: 420, posY: 0, handleX: 420, handleY: 20, variant: 'default' })
+  const right = nodesBuilder.powerRail({ id: 'R', posX: 600, posY: 0, handleX: 600, handleY: 20, connector: 'left' })
+
+  const edges: Edge[] = [
+    {
+      id: 'e1',
+      source: 'L',
+      sourceHandle: left.data.outputConnector?.id,
+      target: 'C',
+      targetHandle: contact.data.inputConnector?.id,
+    },
+    { id: 'e2', source: 'C', sourceHandle: contact.data.outputConnector?.id, target: 'X', targetHandle: 'EN' },
+    { id: 'e3', source: 'X', sourceHandle: 'ENO', target: 'K', targetHandle: coil.data.inputConnector?.id },
+    {
+      id: 'e4',
+      source: 'K',
+      sourceHandle: coil.data.outputConnector?.id,
+      target: 'R',
+      targetHandle: right.data.inputConnector?.id,
+    },
+  ]
+
+  return {
+    id: 'rung-0',
+    comment: '',
+    defaultBounds: [800, 200],
+    reactFlowViewport: [800, 200],
+    nodes: [left, contact, execute, coil, right] as unknown as Node[],
+    edges,
+    selectedNodes: [],
+    handleBranches: [],
+  } as unknown as RungLadderState
+}
+
+describe('codesys ladderToXml — Execute element', () => {
+  const xml = ladderToXml([buildRung()]) as unknown as {
+    body: {
+      LD: {
+        block: Record<string, unknown>[]
+        coil: Record<string, unknown>[]
+      }
+    }
+  }
+
+  it('emits the element as a block with typeName EXECUTE', () => {
+    expect(xml.body.LD.block[0]['@typeName']).toBe('EXECUTE')
+  })
+
+  it("carries the snippet in 3S's stcode addData", () => {
+    const addData = xml.body.LD.block[0].addData as { data: Record<string, unknown> }
+    expect(addData.data['@name']).toBe('http://www.3s-software.com/plcopenxml/stcode')
+    expect((addData.data.STCode as { '#': string })['#']).toBe(SNIPPET)
+  })
+
+  it('names the ENO pin on a downstream coil', () => {
+    // Without the pin name the importer cannot tell which output the coil
+    // reads, and rebuilds the edge against a handle that does not exist.
+    const connectionPointIn = xml.body.LD.coil[0].connectionPointIn as {
+      connection: { '@refLocalId': string; '@formalParameter'?: string }[]
+    }
+    expect(connectionPointIn.connection[0]['@formalParameter']).toBe('ENO')
+    expect(connectionPointIn.connection[0]['@refLocalId']).toBe(
+      (xml.body.LD.block[0]['@localId'] as string | number).toString(),
+    )
+  })
+})
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
index 692351da3..c7b375284 100644
--- a/src/frontend/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
+++ b/src/frontend/utils/PLC/xml-generator/codesys/language/fbd-xml.ts
@@ -17,11 +17,70 @@ import {
   InVariableFbdXML,
   OutVariableFbdXML,
 } from '@root/middleware/shared/ports/xml-types/codesys/pous/languages/fbd-diagram'
+import type { Node as FlowNode } from '@xyflow/react'
+
+import { buildExecuteAddData, EXECUTE_TYPE_NAME, isBlockLikeNodeType } from '../../../execute-plcopen'
 
 /**
  * Translate react flow nodes to XML
  */
 
+/**
+ * Serialize an FBD Execute ("ST Block") in the CODESYS dialect.
+ *
+ * Without this the element was dropped from the CODESYS FBD export entirely,
+ * which also dangled any connection into it — an outVariable fed by its ENO
+ * kept a `refLocalId` pointing at a block that was never written, and the
+ * importer reported "connection references unknown localId".
+ *
+ * Shape matches CODESYS: `<block typeName="EXECUTE">` with EN/ENO formal
+ * parameters, plus the three FBD-only descriptor addData entries alongside
+ * the snippet — see `buildExecuteAddData`.
+ */
+const executeToXml = (node: FlowNode<BasicNodeData & { code: string }>, rung: FBDRungState) => {
+  const inputVariables = 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 || 'EN', connectionPointIn: { connection: [] } }]
+      }
+      return edges.map((edge) => {
+        const sourceNode = rung.nodes.find((candidate) => candidate.id === edge.source)
+        if (!sourceNode) return undefined
+        return {
+          '@formalParameter': handle.id || 'EN',
+          connectionPointIn: {
+            connection: [
+              {
+                '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+                '@formalParameter': isBlockLikeNodeType(sourceNode.type) ? (edge.sourceHandle as string) : undefined,
+              },
+            ],
+          },
+        }
+      })
+    })
+    .filter((variable) => variable !== undefined)
+
+  return {
+    '@localId': node.data.numericId,
+    '@typeName': EXECUTE_TYPE_NAME,
+    ...(node.data.executionOrder ? { '@executionOrderId': node.data.executionOrder } : {}),
+    '@width': node.width as number,
+    '@height': node.height as number,
+    position: { '@x': node.position.x, '@y': node.position.y },
+    inputVariables: { variable: inputVariables },
+    inOutVariables: '',
+    outputVariables: {
+      variable: node.data.outputHandles.map((handle) => ({
+        '@formalParameter': handle.id || 'ENO',
+        connectionPointOut: { expression: undefined },
+      })),
+    },
+    addData: buildExecuteAddData(node.data.code, 'codesys', 'fbd'),
+  }
+}
+
 const blockToXml = (node: BlockNode<BlockVariant>, rung: FBDRungState): BlockFbdXML => {
   const inputVariables: BlockFbdXML['inputVariables']['variable'] = node.data.inputHandles
     .flatMap((handle) => {
@@ -44,12 +103,11 @@ const blockToXml = (node: BlockNode<BlockVariant>, rung: FBDRungState): BlockFbd
             connection: [
               {
                 '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
-                '@formalParameter':
-                  sourceNode.type === 'block'
-                    ? (edge.sourceHandle as string) === 'OUT'
-                      ? '   '
-                      : (edge.sourceHandle as string)
-                    : undefined,
+                '@formalParameter': isBlockLikeNodeType(sourceNode.type)
+                  ? (edge.sourceHandle as string) === 'OUT'
+                    ? '   '
+                    : (edge.sourceHandle as string)
+                  : undefined,
               },
             ],
           },
@@ -143,12 +201,11 @@ const outputVariableToXml = (node: VariableNode, rung: FBDRungState): OutVariabl
               ? (sourceNode?.data as BasicNodeData).numericId
               : 'undefined'
             : 'undefined',
-          '@formalParameter':
-            sourceNode?.type === 'block'
-              ? (edge.sourceHandle as string) === 'OUT'
-                ? '   '
-                : (edge.sourceHandle as string)
-              : undefined,
+          '@formalParameter': isBlockLikeNodeType(sourceNode?.type)
+            ? (edge.sourceHandle as string) === 'OUT'
+              ? '   '
+              : (edge.sourceHandle as string)
+            : undefined,
         }
       })
       .filter((connection) => connection['@refLocalId'] !== 'undefined'),
@@ -190,12 +247,11 @@ const connectorToXml = (node: ConnectionNode, rung: FBDRungState): ConnectorFbdX
 
         return {
           '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
-          '@formalParameter':
-            sourceNode.type === 'block'
-              ? (edge.sourceHandle as string) === 'OUT'
-                ? '   '
-                : (edge.sourceHandle as string)
-              : undefined,
+          '@formalParameter': isBlockLikeNodeType(sourceNode.type)
+            ? (edge.sourceHandle as string) === 'OUT'
+              ? '   '
+              : (edge.sourceHandle as string)
+            : undefined,
         }
       })
       .filter((connection) => connection !== undefined),
@@ -301,6 +357,11 @@ const fbdToXml = (rung: FBDRungState) => {
       case 'comment':
         fbdXML.body.FBD.comment.push(commentToXml(node as CommentNode))
         break
+      case 'execute':
+        fbdXML.body.FBD.block.push(
+          executeToXml(node as FlowNode<BasicNodeData & { code: string }>, rung) as BlockFbdXML,
+        )
+        break
       default:
         break
     }
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
index c5d0cdf1f..eeaad7edd 100644
--- a/src/frontend/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
+++ b/src/frontend/utils/PLC/xml-generator/codesys/language/ladder-xml.ts
@@ -20,6 +20,8 @@ import {
 } from '@root/middleware/shared/ports/xml-types/codesys/pous/languages/ladder-diagram'
 import { Node } from '@xyflow/react'
 
+import { buildExecuteAddData, EXECUTE_TYPE_NAME, isBlockLikeNodeType } from '../../../execute-plcopen'
+
 /**
  * Find the connections of a node in a rung.
  */
@@ -357,6 +359,31 @@ const rightRailToXML = (
   }
 }
 
+/**
+ * The `@formalParameter` a leaf element (contact / coil) writes for the source
+ * it reads from.
+ *
+ * Only a block-shaped source names a pin at all — a rail or another leaf has a
+ * single anonymous output. In this dialect a *function* block is additionally
+ * referenced by its name rather than by the pin id.
+ *
+ * The `variant` lookup is guarded on `type === 'block'` specifically: an
+ * Execute element is block-shaped in the XML but carries no `variant`, so
+ * reading one off it throws. It takes the pin-id branch, which is what its
+ * `ENO` needs.
+ */
+const leafSourceFormalParameter = (
+  connectionNode: Node | undefined,
+  connection: { '@formalParameter'?: string },
+): string | undefined => {
+  if (!isBlockLikeNodeType(connectionNode?.type)) return undefined
+  if (connectionNode?.type === 'block') {
+    const { variant } = (connectionNode as BlockNode<BlockVariant>).data
+    if (variant.type === 'function') return variant.name
+  }
+  return connection['@formalParameter']
+}
+
 const contactToXML = (
   contact: ContactNode,
   rung: RungLadderState,
@@ -388,12 +415,7 @@ const contactToXML = (
       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
+        const formalParameter = leafSourceFormalParameter(connectionNode, connection)
         return {
           '@refLocalId': refLocalId,
           '@formalParameter': formalParameter,
@@ -432,12 +454,7 @@ const coilToXml = (coil: CoilNode, rung: RungLadderState, offsetY: number = 0, l
       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
+        const formalParameter = leafSourceFormalParameter(connectionNode, connection)
         return {
           '@refLocalId': refLocalId,
           '@formalParameter': formalParameter,
@@ -449,6 +466,61 @@ const coilToXml = (coil: CoilNode, rung: RungLadderState, offsetY: number = 0, l
   }
 }
 
+/**
+ * Serialize an Execute ("ST Block") element in the CODESYS dialect.
+ *
+ * Same `<block typeName="EXECUTE">` shape as the old-editor generator, with
+ * this dialect's one extra rule applied: connections into a power rail are
+ * rewritten to the single shared left-rail localId, because CODESYS emits one
+ * rail per body rather than one per rung.
+ */
+const executeToXml = (
+  node: Node<BasicNodeData & { code: string }>,
+  rung: RungLadderState,
+  offsetY: number = 0,
+  leftRailId: string,
+) => {
+  const enHandle = node.data.inputConnector
+  const enoHandle = node.data.outputConnector
+  const connections = enHandle ? findConnections(node, rung, offsetY, enHandle.id) : []
+  const rail = rung.nodes.find((n) => n.type === 'powerRail' && (n as PowerRailNode).data.variant === 'left')
+  const remapped = connections.map((connection) =>
+    rail?.data.numericId === connection['@refLocalId'] ? { ...connection, '@refLocalId': leftRailId } : connection,
+  )
+
+  return {
+    '@localId': node.data.numericId,
+    '@typeName': EXECUTE_TYPE_NAME,
+    '@width': node.width as number,
+    '@height': node.height as number,
+    ...(node.data.executionOrder ? { '@executionOrderId': node.data.executionOrder } : {}),
+    position: { '@x': node.position.x, '@y': (node.position.y ?? 0) + offsetY },
+    inputVariables: {
+      variable: [
+        {
+          '@formalParameter': 'EN',
+          connectionPointIn: {
+            relPosition: { '@x': enHandle?.relPosition.x || 0, '@y': enHandle?.relPosition.y || 0 },
+            connection: remapped,
+          },
+        },
+      ],
+    },
+    inOutVariables: '',
+    outputVariables: {
+      variable: [
+        {
+          '@formalParameter': 'ENO',
+          connectionPointOut: {
+            relPosition: { '@x': enoHandle?.relPosition.x || 0, '@y': enoHandle?.relPosition.y || 0 },
+          },
+        },
+      ],
+    },
+    addData: buildExecuteAddData(node.data.code, 'codesys', 'ld'),
+  }
+}
+
 const blockToXml = (
   block: BlockNode<BlockVariant>,
   rung: RungLadderState,
@@ -477,7 +549,9 @@ const blockToXml = (
           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
+            const formalParameter = isBlockLikeNodeType(connectionNode?.type)
+              ? connection['@formalParameter']
+              : undefined
             return {
               '@refLocalId': refLocalId,
               '@formalParameter': formalParameter,
@@ -662,6 +736,11 @@ const ladderToXml = (rungs: RungLadderState[]) => {
         case 'block':
           ladderXML.body.LD.block.push(blockToXml(node as BlockNode<BlockVariant>, rung, offsetY, leftRailId))
           break
+        case 'execute':
+          ladderXML.body.LD.block.push(
+            executeToXml(node as Node<BasicNodeData & { code: string }>, rung, offsetY, leftRailId) as BlockLadderXML,
+          )
+          break
         case 'variable':
           if ((node as VariableNode).data.variable.name === '') return
           if ((node as VariableNode).data.variant === 'input')
diff --git a/src/frontend/utils/PLC/xml-generator/old-editor/language/__tests__/fbd-execute.test.ts b/src/frontend/utils/PLC/xml-generator/old-editor/language/__tests__/fbd-execute.test.ts
new file mode 100644
index 000000000..9a31bf67e
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/old-editor/language/__tests__/fbd-execute.test.ts
@@ -0,0 +1,106 @@
+import { buildExecuteNode, buildVariableNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/buildNodes'
+import type { FBDRungState } from '@root/frontend/store/slices'
+import { parseFbdXml } from '@root/frontend/utils/PLC/xml-parser/language/fbd-xml'
+import { collectExecuteStCode, parseXmlDocument } from '@root/frontend/utils/PLC/xml-parser/parse-xml-document'
+import type { Edge, Node } from '@xyflow/react'
+import { create } from 'xmlbuilder2'
+
+import { fbdToXml } from '../fbd-xml'
+
+// The FBD half of the Execute ("ST Block") element, in the neutral PLCOpen
+// dialect. Unlike ladder, FBD wiring is free-form: `EN` may be fed from
+// another node's output or left open entirely, and both have to survive the
+// round trip — an open `EN` is what the transpiler reads as "runs every scan".
+
+const SNIPPET = 'counter := counter + 1;'
+
+function buildRung(wireEn: boolean): FBDRungState {
+  const execute = buildExecuteNode({ id: 'X', position: { x: 200, y: 40 }, code: SNIPPET })
+  const source = buildVariableNode({ id: 'IV', position: { x: 20, y: 40 }, variant: 'input-variable' })
+  source.data.variable = { id: '', name: 'gate' }
+
+  const edges: Edge[] = wireEn
+    ? [
+        {
+          id: 'e1',
+          source: 'IV',
+          sourceHandle: source.data.outputConnector?.id,
+          target: 'X',
+          targetHandle: 'EN',
+        },
+      ]
+    : []
+
+  return {
+    comment: '',
+    selectedNodes: [],
+    nodes: [source, execute] as unknown as Node[],
+    edges,
+  } as unknown as FBDRungState
+}
+
+type FbdBlockXml = Record<string, unknown>
+
+const blockOf = (rung: FBDRungState): FbdBlockXml =>
+  (fbdToXml(rung) as unknown as { body: { FBD: { block: FbdBlockXml[] } } }).body.FBD.block[0]
+
+describe('old-editor fbdToXml — Execute element', () => {
+  it('emits the element as a block with typeName EXECUTE and its snippet', () => {
+    const block = blockOf(buildRung(true))
+
+    expect(block['@typeName']).toBe('EXECUTE')
+    const addData = block.addData as { data: Record<string, unknown> }
+    expect(addData.data['@name']).toBe('http://openplc.org/plcopenxml/stcode')
+    expect((addData.data.STCode as { '#': string })['#']).toBe(SNIPPET)
+  })
+
+  it('carries no CODESYS FBD descriptors — those belong to the CODESYS export', () => {
+    const addData = blockOf(buildRung(true)).addData as { data: unknown }
+
+    expect(Array.isArray(addData.data)).toBe(false)
+  })
+
+  it('declares EN and ENO, wiring EN to whatever feeds it', () => {
+    const block = blockOf(buildRung(true))
+    const inputs = block.inputVariables as {
+      variable: { '@formalParameter': string; connectionPointIn: { connection: { '@refLocalId': string }[] } }[]
+    }
+    const outputs = block.outputVariables as { variable: { '@formalParameter': string }[] }
+
+    expect(inputs.variable.map((v) => v['@formalParameter'])).toEqual(['EN'])
+    expect(inputs.variable[0].connectionPointIn.connection).toHaveLength(1)
+    expect(outputs.variable.map((v) => v['@formalParameter'])).toEqual(['ENO'])
+  })
+
+  it('leaves EN declared but unconnected when nothing feeds it', () => {
+    const block = blockOf(buildRung(false))
+    const inputs = block.inputVariables as {
+      variable: { '@formalParameter': string; connectionPointIn: { connection: unknown[] } }[]
+    }
+
+    expect(inputs.variable[0]['@formalParameter']).toBe('EN')
+    expect(inputs.variable[0].connectionPointIn.connection).toEqual([])
+  })
+
+  it('round-trips through serialized XML with the snippet byte-identical', () => {
+    const xml = fbdToXml(buildRung(true)) as unknown as { body: unknown }
+    const serialized = create({
+      project: { types: { pous: { pou: { '@name': 'Main', body: xml.body } } } },
+    }).end({ prettyPrint: true })
+
+    const project = parseXmlDocument(serialized)
+    const fbdXml = (project.types as { pous: { pou: { body: { FBD: unknown } }[] } }).pous.pou[0].body.FBD
+
+    const { body, warnings } = parseFbdXml('Main', fbdXml, collectExecuteStCode(serialized))
+
+    expect(warnings).toEqual([])
+    const executes = body.rung.nodes.filter((node) => node.type === 'execute')
+    expect(executes).toHaveLength(1)
+    expect((executes[0].data as { code: string }).code).toBe(SNIPPET)
+
+    // The EN edge must rebuild against the pin the generator named, not the
+    // anonymous leaf handle a non-block source would use.
+    const enEdge = body.rung.edges.find((edge) => edge.target === executes[0].id)
+    expect(enEdge?.targetHandle).toBe('EN')
+  })
+})
diff --git a/src/frontend/utils/PLC/xml-generator/old-editor/language/__tests__/ladder-execute.test.ts b/src/frontend/utils/PLC/xml-generator/old-editor/language/__tests__/ladder-execute.test.ts
new file mode 100644
index 000000000..0b83c4979
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-generator/old-editor/language/__tests__/ladder-execute.test.ts
@@ -0,0 +1,116 @@
+import { buildExecuteNode } from '@root/frontend/components/_atoms/graphical-editor/ladder/buildNodes'
+import { nodesBuilder } from '@root/frontend/components/_atoms/graphical-editor/ladder/node-builders'
+import type { RungLadderState } from '@root/frontend/store/slices'
+import { parseLadderXml } from '@root/frontend/utils/PLC/xml-parser/language/ladder-xml'
+import { collectExecuteStCode, parseXmlDocument } from '@root/frontend/utils/PLC/xml-parser/parse-xml-document'
+import type { Edge, Node } from '@xyflow/react'
+import { create } from 'xmlbuilder2'
+
+import { ladderToXml } from '../ladder-xml'
+
+// Export → import round trip for the Execute ("ST Block") element.
+//
+// The wire shape is a `<block typeName="EXECUTE">` carrying its source in an
+// `<addData>` — the standard's own extension mechanism, since TC6 defines no
+// inline-ST element. This is the NEUTRAL PLCOpen export, so it uses OpenPLC's
+// URI; the CODESYS export uses 3S's.
+
+const SNIPPET = 'IF a < 10 AND b THEN\n    total := total + 1;\nEND_IF;'
+
+function buildRung(): RungLadderState {
+  // `connector` names the side the rail's handle sits on, so the LEFT rail is
+  // built with `connector: 'right'` and vice versa — same as startLadderRung.
+  const rail = nodesBuilder.powerRail({ id: 'L', posX: 0, posY: 0, handleX: 0, handleY: 20, connector: 'right' })
+  const execute = buildExecuteNode({ id: 'X', posX: 100, posY: 0, handleX: 100, handleY: 20, code: SNIPPET })
+  const rightRail = nodesBuilder.powerRail({
+    id: 'R',
+    posX: 400,
+    posY: 0,
+    handleX: 400,
+    handleY: 20,
+    connector: 'left',
+  })
+
+  const edges: Edge[] = [
+    {
+      id: 'e1',
+      source: 'L',
+      sourceHandle: rail.data.outputConnector?.id,
+      target: 'X',
+      targetHandle: 'EN',
+    },
+    { id: 'e2', source: 'X', sourceHandle: 'ENO', target: 'R', targetHandle: rightRail.data.inputConnector?.id },
+  ]
+
+  return {
+    id: 'rung-0',
+    comment: '',
+    defaultBounds: [800, 200],
+    reactFlowViewport: [800, 200],
+    nodes: [rail, execute, rightRail] as unknown as Node[],
+    edges,
+    selectedNodes: [],
+    handleBranches: [],
+  } as unknown as RungLadderState
+}
+
+describe('old-editor ladderToXml — Execute element', () => {
+  const xml = ladderToXml([buildRung()]) as unknown as {
+    body: { LD: { block: Record<string, unknown>[] } }
+  }
+  const block = xml.body.LD.block[0]
+
+  it('emits the element as a block with typeName EXECUTE', () => {
+    expect(block['@typeName']).toBe('EXECUTE')
+  })
+
+  it('declares EN and ENO as real formal parameters', () => {
+    const inputs = (block.inputVariables as { variable: { '@formalParameter': string }[] }).variable
+    const outputs = (block.outputVariables as { variable: { '@formalParameter': string }[] }).variable
+    expect(inputs.map((v) => v['@formalParameter'])).toEqual(['EN'])
+    expect(outputs.map((v) => v['@formalParameter'])).toEqual(['ENO'])
+  })
+
+  it('carries the snippet in an openplc.org addData, verbatim', () => {
+    // The neutral PLCOpen export reproduces Beremiz / the legacy OpenPLC
+    // Editor, which carries no vendor references anywhere — so this export
+    // uses OpenPLC's own URI, not 3S's. `preserve` is the spec's "try to
+    // preserve the additional data element", the right ask for a
+    // standards-facing file. The CODESYS export uses 3S's instead.
+    const data = (block.addData as { data: Record<string, unknown> }).data
+    expect(data['@name']).toBe('http://openplc.org/plcopenxml/stcode')
+    expect(data['@handleUnknown']).toBe('preserve')
+    expect((data.STCode as { '#': string })['#']).toBe(SNIPPET)
+  })
+
+  it('omits executionOrderId when the user has not set one', () => {
+    // CODESYS omits it entirely; matching that keeps a default export
+    // byte-comparable with theirs.
+    expect(block['@executionOrderId']).toBeUndefined()
+  })
+
+  // A REAL round trip: serialize to XML text with xmlbuilder2, then read it
+  // back through the production parser. Going object → object would skip the
+  // two things most likely to break — entity escaping of `<` / `&`, and the
+  // whitespace trimming that would otherwise reindent the user's code.
+  it('round-trips through serialized XML with the snippet byte-identical', () => {
+    const serialized = create({ project: { types: { pous: { pou: { '@name': 'Main', body: xml.body } } } } }).end({
+      prettyPrint: true,
+    })
+
+    // Escaped on the way out, exactly as CODESYS does it — never CDATA.
+    expect(serialized).toContain('&lt;')
+
+    const project = parseXmlDocument(serialized)
+    const executeStCode = collectExecuteStCode(serialized)
+    // `pou` is in the parser's ARRAY_TAGS, so it always arrives as an array.
+    const ldXml = (project.types as { pous: { pou: { body: { LD: unknown } }[] } }).pous.pou[0].body.LD
+
+    const { body, warnings } = parseLadderXml('Main', ldXml, executeStCode)
+    expect(warnings).toEqual([])
+
+    const executes = body.rungs.flatMap((rung) => rung.nodes.filter((node) => node.type === 'execute'))
+    expect(executes).toHaveLength(1)
+    expect((executes[0].data as { code: string }).code).toBe(SNIPPET)
+  })
+})
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
index 37c76ec0a..1df6eeeda 100644
--- 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
@@ -19,6 +19,8 @@ import {
 } from '@root/middleware/shared/ports/xml-types/old-editor/pous/languages/fbd-diagram'
 import { Edge as FlowEdge, Node as FlowNode } from '@xyflow/react'
 
+import { buildExecuteAddData, EXECUTE_TYPE_NAME, isBlockLikeNodeType } from '../../../execute-plcopen'
+
 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,
@@ -88,7 +90,7 @@ const blockToXml = (node: BlockNode<BlockVariant>, rung: FBDRungState): BlockFbd
             connection: [
               {
                 '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
-                '@formalParameter': sourceNode.type === 'block' ? (edge.sourceHandle as string) : undefined,
+                '@formalParameter': isBlockLikeNodeType(sourceNode.type) ? (edge.sourceHandle as string) : undefined,
                 position: path.reverse().map((point) => ({
                   '@x': point.x,
                   '@y': point.y,
@@ -138,6 +140,78 @@ const blockToXml = (node: BlockNode<BlockVariant>, rung: FBDRungState): BlockFbd
   return blockXML
 }
 
+/**
+ * Serialize an FBD Execute ("ST Block") element.
+ *
+ * Same `<block typeName="EXECUTE">` shape as the ladder variant. This is
+ * the neutral PLCOpen export, so it carries only the snippet — CODESYS's
+ * extra `fbdcalltype` / `inputparamtypes` / `outputparamtypes` descriptors
+ * belong to the CODESYS export alone.
+ *
+ * An unwired `EN` is materialised the way CODESYS does it: no connection at
+ * all here. (CODESYS feeds it from a literal `TRUE` inVariable; ours simply
+ * leaves the pin open, which the transpiler reads as "runs every scan" —
+ * semantically identical, and it avoids inventing a node the user never
+ * placed.)
+ */
+const executeToXml = (node: FlowNode<BasicNodeData & { code: string }>, rung: FBDRungState) => {
+  const inputVariables = 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 || 'EN',
+            connectionPointIn: {
+              relPosition: { '@x': handle.relPosition.x || 0, '@y': handle.relPosition.y || 0 },
+              connection: [],
+            },
+          },
+        ]
+      }
+      return edges.map((edge) => {
+        const sourceNode = rung.nodes.find((candidate) => candidate.id === edge.source)
+        if (!sourceNode) return undefined
+        const path = getEdgePaths(edge, rung.nodes)
+        if (!path) return undefined
+        return {
+          '@formalParameter': handle.id || 'EN',
+          connectionPointIn: {
+            relPosition: { '@x': handle.relPosition.x || 0, '@y': handle.relPosition.y || 0 },
+            connection: [
+              {
+                '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
+                '@formalParameter': isBlockLikeNodeType(sourceNode.type) ? (edge.sourceHandle as string) : undefined,
+                position: path.reverse().map((point) => ({ '@x': point.x, '@y': point.y })),
+              },
+            ],
+          },
+        }
+      })
+    })
+    .filter((variable) => variable !== undefined)
+
+  return {
+    '@localId': node.data.numericId,
+    '@typeName': EXECUTE_TYPE_NAME,
+    ...(node.data.executionOrder ? { '@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: node.data.outputHandles.map((handle) => ({
+        '@formalParameter': handle.id || 'ENO',
+        connectionPointOut: {
+          relPosition: { '@x': handle.relPosition.x || 0, '@y': handle.relPosition.y || 0 },
+        },
+      })),
+    },
+    addData: buildExecuteAddData(node.data.code, 'openplc', 'fbd'),
+  }
+}
+
 const inputVariableToXml = (node: VariableNode): InVariableFbdXML => {
   const inputVariableXML: InVariableFbdXML = {
     '@localId': node.data.numericId,
@@ -179,7 +253,7 @@ const outputVariableToXml = (node: VariableNode, rung: FBDRungState): OutVariabl
 
         return {
           '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
-          '@formalParameter': sourceNode.type === 'block' ? (edge.sourceHandle as string) : undefined,
+          '@formalParameter': isBlockLikeNodeType(sourceNode.type) ? (edge.sourceHandle as string) : undefined,
           position: path.reverse().map((point) => ({
             '@x': point.x,
             '@y': point.y,
@@ -224,7 +298,7 @@ const connectorToXml = (node: ConnectionNode, rung: FBDRungState): ConnectorFbdX
 
         return {
           '@refLocalId': (sourceNode.data as BasicNodeData).numericId,
-          '@formalParameter': sourceNode.type === 'block' ? (edge.sourceHandle as string) : undefined,
+          '@formalParameter': isBlockLikeNodeType(sourceNode.type) ? (edge.sourceHandle as string) : undefined,
           position: path.reverse().map((point) => ({
             '@x': point.x,
             '@y': point.y,
@@ -332,6 +406,13 @@ const fbdToXml = (rung: FBDRungState) => {
       case 'comment':
         fbdXML.body.FBD.comment.push(commentToXml(node as CommentNode))
         break
+      case 'execute':
+        // Serialises as a <block typeName="EXECUTE">, so it joins the block
+        // collection — see executeToXml.
+        fbdXML.body.FBD.block.push(
+          executeToXml(node as FlowNode<BasicNodeData & { code: string }>, rung) as BlockFbdXML,
+        )
+        break
       default:
         break
     }
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
index 096a16eae..ab451a8df 100644
--- 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
@@ -21,6 +21,8 @@ import {
 } from '@root/middleware/shared/ports/xml-types/old-editor/pous/languages/ladder-diagram'
 import { Node } from '@xyflow/react'
 
+import { buildExecuteAddData, EXECUTE_TYPE_NAME } from '../../../execute-plcopen'
+
 /**
  * Find the connections of a node in a rung.
  */
@@ -511,6 +513,73 @@ const blockToXml = (block: BlockNode<BlockVariant>, rung: RungLadderState, offse
   }
 }
 
+/**
+ * Serialize an Execute ("ST Block") element.
+ *
+ * PLCopen TC6 has no element for inline ST, so this follows what
+ * CODESYS itself writes (verified against a V3.5 SP22 export): an
+ * ordinary `<block>` with `typeName="EXECUTE"`, real `EN`/`ENO` formal
+ * parameters, and the snippet hung off an `<addData>` — the standard's
+ * own extension mechanism, since TC6 has no inline-ST element.
+ *
+ * This is the NEUTRAL PLCOpen export, which reproduces Beremiz / the
+ * legacy OpenPLC Editor byte-for-byte and carries no vendor references,
+ * so it uses an openplc.org URI. The CODESYS export uses 3S's — see
+ * `execute-plcopen.ts`.
+ *
+ * `xmlbuilder2` escapes the text node, so `<`, `>` and `&` — which ST
+ * uses constantly — come out as entities exactly as CODESYS writes
+ * them. Never hand-concatenate this payload.
+ */
+const executeToXml = (node: Node<BasicNodeData & { code: string }>, rung: RungLadderState, offsetY: number = 0) => {
+  const enHandle = node.data.inputConnector
+  const enoHandle = node.data.outputConnector
+  const connections = enHandle ? findConnections(node, rung, offsetY, enHandle.id) : []
+
+  return {
+    '@localId': node.data.numericId,
+    '@typeName': EXECUTE_TYPE_NAME,
+    '@width': node.width as number,
+    '@height': node.height as number,
+    // CODESYS omits this entirely; emit it only when the user has set an
+    // explicit order, so a default export stays byte-comparable with theirs.
+    ...(node.data.executionOrder ? { '@executionOrderId': node.data.executionOrder } : {}),
+    position: {
+      '@x': node.position.x,
+      '@y': (node.position.y ?? 0) + offsetY,
+    },
+    inputVariables: {
+      variable: [
+        {
+          '@formalParameter': 'EN',
+          connectionPointIn: {
+            relPosition: {
+              '@x': enHandle?.relPosition.x || 0,
+              '@y': enHandle?.relPosition.y || 0,
+            },
+            connection: connections,
+          },
+        },
+      ],
+    },
+    inOutVariables: '',
+    outputVariables: {
+      variable: [
+        {
+          '@formalParameter': 'ENO',
+          connectionPointOut: {
+            relPosition: {
+              '@x': enoHandle?.relPosition.x || 0,
+              '@y': enoHandle?.relPosition.y || 0,
+            },
+          },
+        },
+      ],
+    },
+    addData: buildExecuteAddData(node.data.code, 'openplc', 'ld'),
+  }
+}
+
 const inVariableToXML = (variable: VariableNode, offsetY: number = 0): InVariableLadderXML => {
   return {
     '@localId': variable.data.numericId,
@@ -612,6 +681,13 @@ const ladderToXml = (rungs: RungLadderState[]) => {
         case 'block':
           ladderXML.body.LD.block.push(blockToXml(node as BlockNode<BlockVariant>, rung, offsetY))
           break
+        case 'execute':
+          // An Execute box serialises as a <block typeName="EXECUTE">, so it
+          // joins the same collection — see executeToXml.
+          ladderXML.body.LD.block.push(
+            executeToXml(node as Node<BasicNodeData & { code: string }>, rung, offsetY) as BlockLadderXML,
+          )
+          break
         case 'variable':
           // Always emit — even with an empty name. A <connection> elsewhere
           // in the XML may already reference this node's numericId; skipping
diff --git a/src/frontend/utils/PLC/xml-parser/__tests__/execute-plcopen.test.ts b/src/frontend/utils/PLC/xml-parser/__tests__/execute-plcopen.test.ts
new file mode 100644
index 000000000..ce527975b
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-parser/__tests__/execute-plcopen.test.ts
@@ -0,0 +1,298 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { EXECUTE_STCODE_URI_OPENPLC, readExecuteStCode } from '../../execute-plcopen'
+import { parsePlcopenXml } from '../index'
+import { collectExecuteStCode } from '../parse-xml-document'
+
+// Fixture is a REAL export from CODESYS V3.5 SP22 Patch 1, not a hand-written
+// approximation — it is the authority for the Execute ("ST Block") wire shape:
+// an ordinary `<block typeName="EXECUTE">` with EN/ENO formal parameters and
+// the snippet in a `.../plcopenxml/stcode` addData.
+const FIXTURE = readFileSync(join(__dirname, 'fixtures', 'codesys-execute.xml'), 'utf8')
+
+// A round trip through our own exporter: LD rungs with several Execute boxes
+// plus an FBD POU containing one.
+const OWN_EXPORT = readFileSync(join(__dirname, 'fixtures', 'openplc-execute.xml'), 'utf8')
+
+describe('readExecuteStCode', () => {
+  it('returns null only for a block that is not an Execute element', () => {
+    expect(readExecuteStCode({ '@typeName': 'TON' })).toBeNull()
+    expect(readExecuteStCode(undefined)).toBeNull()
+    expect(readExecuteStCode('not a record')).toBeNull()
+  })
+
+  it('treats typeName alone as the discriminator, snippet or not', () => {
+    // EXECUTE is the wire name reserved for this element, so a block that says
+    // so is one even when the payload is missing or written under a URI we do
+    // not know. It imports as an empty box the user can fill in — better than a
+    // nameless function block with pins that resolve to nothing.
+    expect(readExecuteStCode({ '@typeName': 'EXECUTE' })).toBe('')
+    expect(readExecuteStCode({ '@typeName': 'EXECUTE', addData: { data: { '@name': 'urn:unknown' } } })).toBe('')
+    expect(readExecuteStCode({ '@typeName': 'EXECUTE', addData: 'nonsense' })).toBe('')
+    // A recognised URI whose <STCode> is neither a string nor a text-bearing
+    // record: the entry matched, so stop looking rather than falling through
+    // to another vendor's entry.
+    expect(
+      readExecuteStCode({
+        '@typeName': 'EXECUTE',
+        addData: { data: [{ '@name': EXECUTE_STCODE_URI_OPENPLC, STCode: 42 }] },
+      }),
+    ).toBe('')
+    expect(readExecuteStCode({ '@typeName': 'EXECUTE', addData: { data: [null, 'x'] } })).toBe('')
+  })
+
+  it('reads the snippet from our own openplc.org stcode addData', () => {
+    const code = readExecuteStCode({
+      '@typeName': 'EXECUTE',
+      addData: {
+        data: { '@name': 'http://openplc.org/plcopenxml/stcode', STCode: { $: 'x := 1;' } },
+      },
+    })
+    expect(code).toBe('x := 1;')
+  })
+
+  it("also reads 3S's URI, so a CODESYS export still imports", () => {
+    const code = readExecuteStCode({
+      '@typeName': 'EXECUTE',
+      addData: {
+        data: {
+          '@name': 'http://www.3s-software.com/plcopenxml/stcode',
+          STCode: { '@xmlns': '', $: 'x := 1;' },
+        },
+      },
+    })
+    expect(code).toBe('x := 1;')
+  })
+
+  it('finds the snippet among the several addData entries an FBD block carries', () => {
+    // CODESYS emits fbdcalltype / inputparamtypes / outputparamtypes alongside
+    // stcode in FBD bodies, and only stcode in LD bodies.
+    const code = readExecuteStCode({
+      '@typeName': 'EXECUTE',
+      addData: {
+        data: [
+          { '@name': 'http://www.3s-software.com/plcopenxml/fbdcalltype', CallType: { $: 'execute' } },
+          { '@name': 'http://www.3s-software.com/plcopenxml/inputparamtypes', InputParamTypes: { $: 'BOOL' } },
+          { '@name': 'http://www.3s-software.com/plcopenxml/stcode', STCode: { $: 'y := 2;' } },
+        ],
+      },
+    })
+    expect(code).toBe('y := 2;')
+  })
+
+  it('distinguishes an emptied snippet from a non-Execute block', () => {
+    const code = readExecuteStCode({
+      '@typeName': 'EXECUTE',
+      addData: { data: { '@name': 'http://openplc.org/plcopenxml/stcode', STCode: '' } },
+    })
+    expect(code).toBe('')
+  })
+})
+
+describe('collectExecuteStCode — whitespace fidelity', () => {
+  // The main parse runs with fast-xml-parser's default `trimValues: true`,
+  // which eats the first line's indentation and the trailing newline. For a
+  // code payload that silently rewrites the user's source, so a second
+  // untrimmed parse recovers it.
+  it('preserves leading indentation and blank lines the trimmed parse would eat', () => {
+    const xml = `<?xml version="1.0"?><project><types><pous><pou><body><LD>
+      <block localId="9" typeName="EXECUTE">
+        <addData><data name="http://openplc.org/plcopenxml/stcode"
+          ><STCode>    x := 1;\n\n    y := 2;\n</STCode></data></addData>
+      </block></LD></body></pou></pous></types></project>`
+
+    expect(collectExecuteStCode(xml).get('9')).toBe('    x := 1;\n\n    y := 2;\n')
+  })
+
+  it('returns an empty map for a document with no Execute elements', () => {
+    expect(collectExecuteStCode('<?xml version="1.0"?><project/>').size).toBe(0)
+  })
+
+  it('returns an empty map rather than throwing on malformed XML', () => {
+    expect(collectExecuteStCode('<project><unclosed>').size).toBe(0)
+  })
+})
+
+describe('importing the real CODESYS export', () => {
+  const result = parsePlcopenXml(FIXTURE)
+
+  it('rebuilds Execute nodes carrying their ST snippets', () => {
+    const plcPrg = result.projectData.pous.find((pou) => pou.name === 'PLC_PRG')
+    expect(plcPrg).toBeDefined()
+
+    const value = plcPrg?.body.value as { rungs: Array<{ nodes: Array<{ type?: string; data: unknown }> }> }
+    const executes = value.rungs.flatMap((rung) => rung.nodes.filter((node) => node.type === 'execute'))
+
+    // Both LD networks in the fixture carry one.
+    expect(executes).toHaveLength(2)
+
+    const codes = executes.map((node) => (node.data as { code: string }).code)
+    // Network 1 holds the escaping-test snippet, network 2 a simple assignment.
+    expect(codes.some((code) => code.includes('CASE myNewValue OF'))).toBe(true)
+    expect(codes.some((code) => code.includes('myNewValue_1 := myValue_1 + 111;'))).toBe(true)
+  })
+
+  it('preserves the snippet’s interior indentation through the import', () => {
+    // The whole point of the untrimmed second parse — a `CASE` body indented
+    // four spaces must still be indented four spaces after a round-trip.
+    const plcPrg = result.projectData.pous.find((pou) => pou.name === 'PLC_PRG')
+    const value = plcPrg?.body.value as { rungs: Array<{ nodes: Array<{ type?: string; data: unknown }> }> }
+    const code = value.rungs
+      .flatMap((rung) => rung.nodes.filter((node) => node.type === 'execute'))
+      .map((node) => (node.data as { code: string }).code)
+      .find((snippet) => snippet.includes('CASE myNewValue OF'))
+
+    expect(code).toContain('\n    0, 1: myCoil := TRUE;')
+    // Blank lines between statements survive too.
+    expect(code).toContain('END_IF;\n\nFOR myValue')
+  })
+
+  it('decodes XML entities back into real ST operators', () => {
+    // CODESYS entity-escapes rather than using CDATA: `<` → `&lt;` etc.
+    // Getting this wrong would hand the compiler `IF a &lt; b`.
+    const plcPrg = result.projectData.pous.find((pou) => pou.name === 'PLC_PRG')
+    const value = plcPrg?.body.value as { rungs: Array<{ nodes: Array<{ type?: string; data: unknown }> }> }
+    const codes = value.rungs
+      .flatMap((rung) => rung.nodes.filter((node) => node.type === 'execute'))
+      .map((node) => (node.data as { code: string }).code)
+      .join('\n')
+
+    expect(codes).not.toContain('&lt;')
+    expect(codes).not.toContain('&amp;')
+  })
+
+  // KNOWN LIMITATION, pinned here so it is visible rather than folklore.
+  //
+  // CODESYS emits every network of a POU flat into one <LD> sharing a SINGLE
+  // leftPowerRail, marking network boundaries only with a `networktitle`
+  // <vendorElement>. This parser recovers rungs by connected-component
+  // partition (see parseLadderXml), which was written against our own
+  // generator's per-rung rails — so a shared rail fuses every CODESYS network
+  // into one rung.
+  //
+  // The Execute payloads themselves survive intact; only the rung SHAPE is
+  // wrong. Predates this feature (it affects any CODESYS LD import) and is
+  // left alone deliberately: splitting on the marker would mean inferring
+  // membership from localId ordering, which CODESYS does not guarantee.
+  it('fuses CODESYS networks into one rung — shared power rail, see comment', () => {
+    const plcPrg = result.projectData.pous.find((pou) => pou.name === 'PLC_PRG')
+    const value = plcPrg?.body.value as { rungs: Array<{ nodes: unknown[] }> }
+
+    // Two networks in the source, fused into one 7-node rung because CODESYS
+    // emits them flat around a single shared power rail. The right rail it
+    // leaves unconnected carries no logic and is dropped rather than becoming
+    // a second, elementless rung.
+    expect(value.rungs.map((rung) => rung.nodes.length)).toEqual([7])
+  })
+
+  it('gives each Execute node EN and ENO handles', () => {
+    const plcPrg = result.projectData.pous.find((pou) => pou.name === 'PLC_PRG')
+    const value = plcPrg?.body.value as { rungs: Array<{ nodes: Array<{ type?: string; data: unknown }> }> }
+    const execute = value.rungs.flatMap((rung) => rung.nodes).find((node) => node.type === 'execute')
+    const data = execute?.data as { inputHandles: { id?: string }[]; outputHandles: { id?: string }[] }
+
+    expect(data.inputHandles.map((h) => h.id)).toEqual(['EN'])
+    expect(data.outputHandles.map((h) => h.id)).toEqual(['ENO'])
+  })
+})
+describe('re-importing our own PLCopen export', () => {
+  const result = parsePlcopenXml(OWN_EXPORT)
+
+  const executesIn = (pouName: string) => {
+    const pou = result.projectData.pous.find((p) => p.name === pouName)
+    const value = pou?.body.value as {
+      rungs?: Array<{ nodes: Array<Record<string, unknown>> }>
+      rung?: { nodes: Array<Record<string, unknown>> }
+    }
+    const nodes = value.rungs ? value.rungs.flatMap((rung) => rung.nodes) : (value.rung?.nodes ?? [])
+    return nodes.filter((node) => node.type === 'execute')
+  }
+
+  it('imports cleanly', () => {
+    expect(result.warnings).toEqual([])
+  })
+
+  it('rebuilds every LD Execute box with its snippet', () => {
+    const executes = executesIn('main')
+    expect(executes).toHaveLength(4)
+
+    const codes = executes.map((node) => (node.data as { code: string }).code)
+    expect(codes.some((code) => code.includes('FOR i := 1 TO 10 BY 1 DO'))).toBe(true)
+    expect(codes.some((code) => code.includes('ELSIF counter < 0 THEN'))).toBe(true)
+    // Interior indentation and blank lines survive the round trip.
+    expect(codes.some((code) => code.includes('END_IF;\n\nIF total <> 0.0 AND gate THEN'))).toBe(true)
+  })
+
+  // Regression: the FBD importer had no EXECUTE branch, so the generic block
+  // path claimed the element — it came back as a nameless function block with
+  // no snippet and pins that did not match the wiring, leaving it visibly
+  // empty and disconnected.
+  it('rebuilds the FBD Execute box rather than a generic block', () => {
+    const executes = executesIn('test_FBD')
+    expect(executes).toHaveLength(1)
+    expect((executes[0].data as { code: string }).code).toBe('myVar := myVar + 0.01;')
+  })
+
+  // Regression: imported handles carried no `style`, so React Flow rendered
+  // them at the element's vertical centre while the model said the pin row —
+  // the wire stepped into the box on every import.
+  it.each(['main', 'test_FBD'])('gives %s Execute handles a DOM offset', (pouName) => {
+    for (const node of executesIn(pouName)) {
+      const data = node.data as {
+        inputHandles: { id?: string; style?: { top: number } }[]
+        outputHandles: { id?: string; style?: { top: number } }[]
+      }
+      expect(data.inputHandles.map((h) => h.id)).toEqual(['EN'])
+      expect(data.outputHandles.map((h) => h.id)).toEqual(['ENO'])
+      expect(data.inputHandles[0].style?.top).toBeGreaterThan(0)
+      expect(data.outputHandles[0].style?.top).toBeGreaterThan(0)
+    }
+  })
+  // Regression: a consumer's `<connection>` names the pin it reads via
+  // `@formalParameter`, but the generators only emitted it for `type ===
+  // 'block'` — an Execute node is a block in the XML yet carries its own node
+  // type, so the name was dropped and the ENO edge could not be rebuilt. The
+  // fixture predates that fix, so this also covers the importer's fallback to
+  // a source's sole output handle.
+  it('rebuilds the FBD ENO edge into the consuming variable', () => {
+    const pou = result.projectData.pous.find((p) => p.name === 'test_FBD')
+    const value = pou?.body.value as {
+      rung: { nodes: Array<{ id: string; type?: string }>; edges: Array<Record<string, string>> }
+    }
+    const execute = value.rung.nodes.find((node) => node.type === 'execute')
+    const output = value.rung.nodes.find((node) => node.type === 'output-variable')
+
+    const enoEdge = value.rung.edges.find((edge) => edge.source === execute?.id)
+    expect(enoEdge).toBeDefined()
+    expect(enoEdge?.sourceHandle).toBe('ENO')
+    expect(enoEdge?.target).toBe(output?.id)
+
+    // …and EN is still fed from the TRUE input variable.
+    expect(value.rung.edges.some((edge) => edge.target === execute?.id && edge.targetHandle === 'EN')).toBe(true)
+  })
+  // Regression: the LD generator writes absolute Y including each preceding
+  // rung's height, and the importer used to keep it. Every rung after the
+  // first then rendered far below its own viewport — a blank gap that grew
+  // with each rung. Pre-existing, not specific to the Execute element.
+  it('re-bases every rung to a common origin, handles included', () => {
+    const pou = result.projectData.pous.find((p) => p.name === 'main')
+    const value = pou?.body.value as {
+      rungs: Array<{
+        nodes: Array<{ position: { y: number }; data: { handles?: { glbPosition: { y: number } }[] } }>
+      }>
+    }
+    expect(value.rungs.length).toBeGreaterThan(1)
+
+    const tops = value.rungs.map((rung) => Math.min(...rung.nodes.map((node) => node.position.y)))
+    expect(new Set(tops).size).toBe(1)
+
+    // Handles must move with their nodes — `handles` aliases the input/output
+    // arrays, so a naive shift moves each one twice.
+    const handleTops = value.rungs.map((rung) =>
+      Math.min(...rung.nodes.flatMap((node) => (node.data.handles ?? []).map((h) => h.glbPosition.y))),
+    )
+    expect(new Set(handleTops).size).toBe(1)
+    expect(handleTops[0]).toBeGreaterThan(0)
+  })
+})
diff --git a/src/frontend/utils/PLC/xml-parser/__tests__/fixtures/codesys-execute.xml b/src/frontend/utils/PLC/xml-parser/__tests__/fixtures/codesys-execute.xml
new file mode 100644
index 000000000..197941d34
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-parser/__tests__/fixtures/codesys-execute.xml
@@ -0,0 +1,306 @@
+<?xml version="1.0" encoding="utf-8"?>
+<project xmlns="http://www.plcopen.org/xml/tc6_0200">
+  <fileHeader companyName="" productName="CODESYS" productVersion="CODESYS V3.5 SP22 Patch 1" creationDateTime="2026-08-28T09:52:30.8266995" />
+  <contentHeader name="execute-test.project" modificationDateTime="2026-08-28T09:52:13.9833565">
+    <coordinateInfo>
+      <fbd>
+        <scaling x="1" y="1" />
+      </fbd>
+      <ld>
+        <scaling x="1" y="1" />
+      </ld>
+      <sfc>
+        <scaling x="1" y="1" />
+      </sfc>
+    </coordinateInfo>
+    <addData>
+      <data name="http://www.3s-software.com/plcopenxml/projectinformation" handleUnknown="implementation">
+        <ProjectInformation />
+      </data>
+    </addData>
+  </contentHeader>
+  <types>
+    <dataTypes />
+    <pous>
+      <pou name="PLC_PRG" pouType="program">
+        <interface>
+          <localVars>
+            <variable name="myValue">
+              <type>
+                <INT />
+              </type>
+            </variable>
+            <variable name="myNewValue">
+              <type>
+                <INT />
+              </type>
+            </variable>
+            <variable name="myContact">
+              <type>
+                <BOOL />
+              </type>
+            </variable>
+            <variable name="myCoil">
+              <type>
+                <BOOL />
+              </type>
+            </variable>
+            <variable name="myValue_1">
+              <type>
+                <INT />
+              </type>
+            </variable>
+            <variable name="myNewValue_1">
+              <type>
+                <INT />
+              </type>
+            </variable>
+            <variable name="myContact_1">
+              <type>
+                <BOOL />
+              </type>
+            </variable>
+            <variable name="myCoil_1">
+              <type>
+                <BOOL />
+              </type>
+            </variable>
+          </localVars>
+        </interface>
+        <body>
+          <LD>
+            <leftPowerRail localId="0">
+              <position x="0" y="0" />
+              <connectionPointOut formalParameter="none" />
+            </leftPowerRail>
+            <comment localId="3" height="0" width="0">
+              <position x="0" y="0" />
+              <content>
+                <xhtml xmlns="http://www.w3.org/1999/xhtml">ST Block Comment</xhtml>
+              </content>
+            </comment>
+            <vendorElement localId="2">
+              <position x="0" y="0" />
+              <alternativeText>
+                <xhtml xmlns="http://www.w3.org/1999/xhtml">ST Block Network </xhtml>
+              </alternativeText>
+              <addData>
+                <data name="http://www.3s-software.com/plcopenxml/fbdelementtype" handleUnknown="implementation">
+                  <ElementType xmlns="">networktitle</ElementType>
+                </data>
+              </addData>
+            </vendorElement>
+            <contact localId="4">
+              <position x="0" y="0" />
+              <connectionPointIn>
+                <connection refLocalId="0" />
+              </connectionPointIn>
+              <connectionPointOut />
+              <variable>myContact</variable>
+            </contact>
+            <block localId="5" typeName="EXECUTE">
+              <position x="0" y="0" />
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <connection refLocalId="4" />
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables />
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut />
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://www.3s-software.com/plcopenxml/stcode" handleUnknown="implementation">
+                  <STCode xmlns="">// escaping test: &lt; &gt; &lt;= &gt;= &lt;&gt;
+(* block comment: ampersand &amp; , less-than &lt; , greater-than &gt; , quotes 'single' "double" *)
+IF myValue &lt; 10 AND myContact THEN
+    myNewValue := myValue + 1;
+ELSIF (myValue &gt;= 10) AND (myValue &lt;= 100) THEN
+    myNewValue := myValue - 1;
+ELSIF myValue &lt;&gt; 0 THEN
+    myNewValue := 0;
+ELSE
+    myNewValue := -1;
+END_IF;
+
+FOR myValue := 0 TO 5 BY 1 DO
+    myNewValue := myNewValue + myValue;
+END_FOR;
+
+CASE myNewValue OF
+    0, 1: myCoil := TRUE;
+    2..5: myCoil := FALSE;
+ELSE
+    myCoil := myContact;
+END_CASE;
+</STCode>
+                </data>
+              </addData>
+            </block>
+            <coil localId="6">
+              <position x="0" y="0" />
+              <connectionPointIn>
+                <connection refLocalId="5" />
+              </connectionPointIn>
+              <connectionPointOut />
+              <variable>myCoil</variable>
+            </coil>
+            <comment localId="9" height="0" width="0">
+              <position x="0" y="0" />
+              <content>
+                <xhtml xmlns="http://www.w3.org/1999/xhtml">ST Block Comment 1</xhtml>
+              </content>
+            </comment>
+            <vendorElement localId="8">
+              <position x="0" y="0" />
+              <alternativeText>
+                <xhtml xmlns="http://www.w3.org/1999/xhtml">ST Block Network 1</xhtml>
+              </alternativeText>
+              <addData>
+                <data name="http://www.3s-software.com/plcopenxml/fbdelementtype" handleUnknown="implementation">
+                  <ElementType xmlns="">networktitle</ElementType>
+                </data>
+              </addData>
+            </vendorElement>
+            <contact localId="10">
+              <position x="0" y="0" />
+              <connectionPointIn>
+                <connection refLocalId="0" />
+              </connectionPointIn>
+              <connectionPointOut />
+              <variable>myContact_1</variable>
+            </contact>
+            <block localId="11" typeName="EXECUTE">
+              <position x="0" y="0" />
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <connection refLocalId="10" />
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables />
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut />
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://www.3s-software.com/plcopenxml/stcode" handleUnknown="implementation">
+                  <STCode xmlns="">// Comment in ST Block 1
+myNewValue_1 := myValue_1 + 111;
+</STCode>
+                </data>
+              </addData>
+            </block>
+            <coil localId="12">
+              <position x="0" y="0" />
+              <connectionPointIn>
+                <connection refLocalId="11" />
+              </connectionPointIn>
+              <connectionPointOut />
+              <variable>myCoil_1</variable>
+            </coil>
+            <rightPowerRail localId="2147483647">
+              <position x="0" y="0" />
+              <connectionPointIn />
+            </rightPowerRail>
+          </LD>
+        </body>
+        <addData>
+          <data name="http://www.3s-software.com/plcopenxml/objectid" handleUnknown="discard">
+            <ObjectId>ac119dd2-2f51-4cdc-a0c4-34317ee586a8</ObjectId>
+          </data>
+        </addData>
+      </pou>
+      <pou name="FBD_Test_Execute" pouType="program">
+        <interface>
+          <localVars>
+            <variable name="myNewVarFBD">
+              <type>
+                <INT />
+              </type>
+            </variable>
+          </localVars>
+        </interface>
+        <body>
+          <FBD>
+            <vendorElement localId="10000000000">
+              <position x="0" y="0" />
+              <alternativeText>
+                <xhtml xmlns="http://www.w3.org/1999/xhtml">FBD Implementation Attributes</xhtml>
+              </alternativeText>
+              <addData>
+                <data name="http://www.3s-software.com/plcopenxml/fbd/implementationattributes" handleUnknown="implementation">
+                  <fbdattributes xmlns="">
+                    <attribute name="BoxInputFlagsSupported" value="true" />
+                  </fbdattributes>
+                </data>
+              </addData>
+            </vendorElement>
+            <inVariable localId="10000000001">
+              <position x="0" y="0" />
+              <connectionPointOut />
+              <expression>TRUE</expression>
+            </inVariable>
+            <block localId="10000000002" typeName="EXECUTE">
+              <position x="0" y="0" />
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <connection refLocalId="10000000001" />
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables />
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut />
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://www.3s-software.com/plcopenxml/fbdcalltype" handleUnknown="implementation">
+                  <CallType xmlns="">execute</CallType>
+                </data>
+                <data name="http://www.3s-software.com/plcopenxml/inputparamtypes" handleUnknown="implementation">
+                  <InputParamTypes xmlns="">BOOL</InputParamTypes>
+                </data>
+                <data name="http://www.3s-software.com/plcopenxml/outputparamtypes" handleUnknown="implementation">
+                  <OutputParamTypes xmlns="">BOOL</OutputParamTypes>
+                </data>
+                <data name="http://www.3s-software.com/plcopenxml/stcode" handleUnknown="implementation">
+                  <STCode xmlns="">// FBD escaping test: a &lt; b , c &gt; d , e &lt;&gt; f
+IF myNewVarFBD &lt; 100 AND myNewVarFBD &lt;&gt; 0 THEN
+    myNewVarFBD := myNewVarFBD + 1;
+ELSE
+    myNewVarFBD := 0;
+END_IF;</STCode>
+                </data>
+              </addData>
+            </block>
+          </FBD>
+        </body>
+        <addData>
+          <data name="http://www.3s-software.com/plcopenxml/objectid" handleUnknown="discard">
+            <ObjectId>0350dfcf-d579-48f1-bb55-c69096e9fb64</ObjectId>
+          </data>
+        </addData>
+      </pou>
+    </pous>
+  </types>
+  <instances>
+    <configurations />
+  </instances>
+  <addData>
+    <data name="http://www.3s-software.com/plcopenxml/projectstructure" handleUnknown="discard">
+      <ProjectStructure>
+        <Object Name="PLC_PRG" ObjectId="ac119dd2-2f51-4cdc-a0c4-34317ee586a8" />
+        <Object Name="FBD_Test_Execute" ObjectId="0350dfcf-d579-48f1-bb55-c69096e9fb64" />
+      </ProjectStructure>
+    </data>
+  </addData>
+</project>
\ No newline at end of file
diff --git a/src/frontend/utils/PLC/xml-parser/__tests__/fixtures/openplc-execute.xml b/src/frontend/utils/PLC/xml-parser/__tests__/fixtures/openplc-execute.xml
new file mode 100644
index 000000000..ac4f7fd12
--- /dev/null
+++ b/src/frontend/utils/PLC/xml-parser/__tests__/fixtures/openplc-execute.xml
@@ -0,0 +1,315 @@
+<?xml version="1.0" encoding="utf-8"?>
+<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="2026-08-28T18:13:26"/>
+  <contentHeader name="Unnamed" modificationDateTime="2026-08-28T18:13:26">
+    <coordinateInfo>
+      <fbd>
+        <scaling x="16" y="16"/>
+      </fbd>
+      <ld>
+        <scaling x="16" y="16"/>
+      </ld>
+      <sfc>
+        <scaling x="16" y="16"/>
+      </sfc>
+    </coordinateInfo>
+  </contentHeader>
+  <types>
+    <dataTypes/>
+    <pous>
+      <pou name="main" pouType="program">
+        <interface>
+          <localVars>
+            <variable name="myVar">
+              <type>
+                <REAL/>
+              </type>
+            </variable>
+            <variable name="counter">
+              <type>
+                <INT/>
+              </type>
+            </variable>
+            <variable name="total">
+              <type>
+                <REAL/>
+              </type>
+            </variable>
+            <variable name="gate">
+              <type>
+                <BOOL/>
+              </type>
+            </variable>
+            <variable name="mode">
+              <type>
+                <INT/>
+              </type>
+            </variable>
+            <variable name="result">
+              <type>
+                <REAL/>
+              </type>
+            </variable>
+            <variable name="i">
+              <type>
+                <INT/>
+              </type>
+            </variable>
+          </localVars>
+        </interface>
+        <body>
+          <LD>
+            <leftPowerRail localId="7758567" width="3" height="40">
+              <position x="0" y="30"/>
+              <connectionPointOut formalParameter="">
+                <relPosition x="3" y="20"/>
+              </connectionPointOut>
+            </leftPowerRail>
+            <leftPowerRail localId="2342384" width="3" height="40">
+              <position x="0" y="312"/>
+              <connectionPointOut formalParameter="">
+                <relPosition x="3" y="20"/>
+              </connectionPointOut>
+            </leftPowerRail>
+            <rightPowerRail localId="9187596" width="3" height="40">
+              <position x="463" y="30"/>
+              <connectionPointIn>
+                <relPosition x="3" y="20"/>
+                <connection refLocalId="5987320" formalParameter="ENO">
+                  <position x="466" y="50"/>
+                  <position x="323" y="50"/>
+                </connection>
+              </connectionPointIn>
+            </rightPowerRail>
+            <rightPowerRail localId="912676" width="3" height="40">
+              <position x="1183" y="312"/>
+              <connectionPointIn>
+                <relPosition x="3" y="20"/>
+                <connection refLocalId="2115285" formalParameter="ENO">
+                  <position x="1186" y="332"/>
+                  <position x="1043" y="332"/>
+                </connection>
+              </connectionPointIn>
+            </rightPowerRail>
+            <block localId="5987320" typeName="EXECUTE" width="240" height="80">
+              <position x="83" y="14"/>
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <relPosition x="0" y="36"/>
+                    <connection refLocalId="7758567" formalParameter="left-rail">
+                      <position x="83" y="50"/>
+                      <position x="3" y="50"/>
+                    </connection>
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables/>
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut>
+                    <relPosition x="240" y="36"/>
+                  </connectionPointOut>
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://openplc.org/plcopenxml/stcode" handleUnknown="preserve">
+                  <STCode>myVar := myVar + 0.01;</STCode>
+                </data>
+              </addData>
+            </block>
+            <block localId="1218673" typeName="EXECUTE" width="240" height="116">
+              <position x="83" y="296"/>
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <relPosition x="0" y="36"/>
+                    <connection refLocalId="2342384" formalParameter="left-rail">
+                      <position x="83" y="332"/>
+                      <position x="3" y="332"/>
+                    </connection>
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables/>
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut>
+                    <relPosition x="240" y="36"/>
+                  </connectionPointOut>
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://openplc.org/plcopenxml/stcode" handleUnknown="preserve">
+                  <STCode>counter := counter + 1;
+total := total + 0.01;
+result := total * 2.0;</STCode>
+                </data>
+              </addData>
+            </block>
+            <block localId="1893208" typeName="EXECUTE" width="240" height="224">
+              <position x="443" y="296"/>
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <relPosition x="0" y="36"/>
+                    <connection refLocalId="1218673" formalParameter="ENO">
+                      <position x="443" y="332"/>
+                      <position x="323" y="332"/>
+                    </connection>
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables/>
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut>
+                    <relPosition x="240" y="36"/>
+                  </connectionPointOut>
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://openplc.org/plcopenxml/stcode" handleUnknown="preserve">
+                  <STCode>IF counter &gt; 100 THEN
+    counter := 0;
+ELSIF counter &lt; 0 THEN
+    counter := 100;
+END_IF;
+
+IF total &lt;&gt; 0.0 AND gate THEN
+    result := total / 2.0;
+END_IF;</STCode>
+                </data>
+              </addData>
+            </block>
+            <block localId="2115285" typeName="EXECUTE" width="240" height="278">
+              <position x="803" y="296"/>
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <relPosition x="0" y="36"/>
+                    <connection refLocalId="1893208" formalParameter="ENO">
+                      <position x="803" y="332"/>
+                      <position x="683" y="332"/>
+                    </connection>
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables/>
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut>
+                    <relPosition x="240" y="36"/>
+                  </connectionPointOut>
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://openplc.org/plcopenxml/stcode" handleUnknown="preserve">
+                  <STCode>total := 0.0;
+FOR i := 1 TO 10 BY 1 DO
+    total := total + REAL#1.5;
+END_FOR;
+
+CASE mode OF
+    0: result := 0.0;
+    1, 2: result := total;
+    3..5: result := total * 2.0;
+ELSE
+    result := -1.0;
+END_CASE;</STCode>
+                </data>
+              </addData>
+            </block>
+          </LD>
+        </body>
+        <documentation>
+          <xhtml:p><![CDATA[ ]]></xhtml:p>
+        </documentation>
+      </pou>
+      <pou name="test_FBD" pouType="program">
+        <interface>
+          <localVars>
+            <variable name="myVar">
+              <type>
+                <REAL/>
+              </type>
+            </variable>
+            <variable name="myOut">
+              <type>
+                <BOOL/>
+              </type>
+            </variable>
+          </localVars>
+        </interface>
+        <body>
+          <FBD>
+            <block localId="8825997" typeName="EXECUTE" height="120" width="260">
+              <position x="304" y="176"/>
+              <inputVariables>
+                <variable formalParameter="EN">
+                  <connectionPointIn>
+                    <relPosition x="0" y="48"/>
+                    <connection refLocalId="8239758">
+                      <position x="400" y="256"/>
+                      <position x="312" y="256"/>
+                      <position x="312" y="208"/>
+                      <position x="224" y="208"/>
+                    </connection>
+                  </connectionPointIn>
+                </variable>
+              </inputVariables>
+              <inOutVariables/>
+              <outputVariables>
+                <variable formalParameter="ENO">
+                  <connectionPointOut>
+                    <relPosition x="260" y="48"/>
+                  </connectionPointOut>
+                </variable>
+              </outputVariables>
+              <addData>
+                <data name="http://openplc.org/plcopenxml/stcode" handleUnknown="preserve">
+                  <STCode>myVar := myVar + 0.01;</STCode>
+                </data>
+              </addData>
+            </block>
+            <inVariable localId="8239758" executionOrderId="0" height="32" width="128" negated="false">
+              <position x="112" y="208"/>
+              <connectionPointOut>
+                <relPosition x="112" y="16"/>
+              </connectionPointOut>
+              <expression>TRUE</expression>
+            </inVariable>
+            <outVariable localId="529102" executionOrderId="0" height="32" width="128" negated="false">
+              <position x="624" y="208"/>
+              <connectionPointIn>
+                <relPosition x="0" y="16"/>
+                <connection refLocalId="8825997">
+                  <position x="624" y="208"/>
+                  <position x="642" y="208"/>
+                  <position x="642" y="256"/>
+                  <position x="660" y="256"/>
+                </connection>
+              </connectionPointIn>
+              <expression>myOut</expression>
+            </outVariable>
+          </FBD>
+        </body>
+        <documentation>
+          <xhtml:p><![CDATA[ ]]></xhtml:p>
+        </documentation>
+      </pou>
+    </pous>
+  </types>
+  <instances>
+    <configurations>
+      <configuration name="Config0">
+        <resource name="Res0">
+          <task name="task0" priority="1" interval="T#20ms">
+            <pouInstance name="instance0" typeName="main"/>
+            <pouInstance name="instance1" typeName="test_FBD"/>
+          </task>
+        </resource>
+      </configuration>
+    </configurations>
+  </instances>
+</project>
\ No newline at end of file
diff --git a/src/frontend/utils/PLC/xml-parser/__tests__/parse-plcopen-xml.test.ts b/src/frontend/utils/PLC/xml-parser/__tests__/parse-plcopen-xml.test.ts
index 1a41f2a29..11c8dd45e 100644
--- a/src/frontend/utils/PLC/xml-parser/__tests__/parse-plcopen-xml.test.ts
+++ b/src/frontend/utils/PLC/xml-parser/__tests__/parse-plcopen-xml.test.ts
@@ -427,7 +427,7 @@ describe('parsePlcopenXml — round trip against XmlGenerator (old-editor)', ()
     // Node order follows the raw XML's element-type grouping (leftPowerRail,
     // rightPowerRail, contact, coil), not rung/visual position.
     expect(rung.nodes.map((n) => (n as { id: string }).id).sort()).toEqual(
-      ['LEFT-POWER-RAIL-1', 'RIGHT-POWER-RAIL-4', 'CONTACT-2', 'COIL-3'].sort(),
+      ['left-rail-1', 'right-rail-4', 'CONTACT-2', 'COIL-3'].sort(),
     )
     expect(rung.edges).toHaveLength(3)
     const nodesById = new Map(
diff --git a/src/frontend/utils/PLC/xml-parser/index.ts b/src/frontend/utils/PLC/xml-parser/index.ts
index 079bc802e..62376a958 100644
--- a/src/frontend/utils/PLC/xml-parser/index.ts
+++ b/src/frontend/utils/PLC/xml-parser/index.ts
@@ -1,7 +1,7 @@
 import type { PLCDataType, PLCInstance, PLCPou, PLCTask, PLCVariable } from '../../../../middleware/shared/ports/types'
 import { parseDataTypesXml } from './data-type-xml'
 import { parseConfigurationXml } from './instances-xml'
-import { parseXmlDocument } from './parse-xml-document'
+import { collectExecuteStCode, parseXmlDocument } from './parse-xml-document'
 import { parsePousXml } from './pou-xml'
 import { asRecord, asString } from './xml-node'
 
@@ -41,10 +41,13 @@ export interface PlcopenParseResult {
 // as non-fatal warnings rather than being parsed.
 export function parsePlcopenXml(xml: string): PlcopenParseResult {
   const project = parseXmlDocument(xml)
+  // Recovered from a second, untrimmed parse: the main parse trims text
+  // nodes, which would silently reindent any Execute ("ST Block") snippet.
+  const executeStCode = collectExecuteStCode(xml)
   const types = asRecord(project.types)
 
   const dataTypes = parseDataTypesXml(asRecord(types.dataTypes).dataType)
-  const { pous, warnings } = parsePousXml(asRecord(types.pous).pou)
+  const { pous, warnings } = parsePousXml(asRecord(types.pous).pou, executeStCode)
   const configurations = parseConfigurationXml(project.instances)
   const projectName = asString(asRecord(project.contentHeader)['@name'])
 
diff --git a/src/frontend/utils/PLC/xml-parser/language/__tests__/fbd-xml.test.ts b/src/frontend/utils/PLC/xml-parser/language/__tests__/fbd-xml.test.ts
index dac33eb43..0ea9e167d 100644
--- a/src/frontend/utils/PLC/xml-parser/language/__tests__/fbd-xml.test.ts
+++ b/src/frontend/utils/PLC/xml-parser/language/__tests__/fbd-xml.test.ts
@@ -217,6 +217,35 @@ describe('parseFbdXml', () => {
     expect(warnings).toEqual(['POU "p": 1 FBD inOutVariable node(s) are not supported, skipped'])
   })
 
+  // Mirrors the ladder importer: a file may declare typeName="EXECUTE" without
+  // the EN/ENO formal parameters we always write, and the node still has to
+  // come out with usable connectors.
+  it('gives an Execute element EN and ENO even when the file declares neither', () => {
+    const { body } = parseFbdXml('p', {
+      block: [
+        {
+          '@localId': '3',
+          '@typeName': 'EXECUTE',
+          position: { '@x': '10', '@y': '20' },
+          addData: { data: { '@name': 'http://openplc.org/plcopenxml/stcode', STCode: { $: 'y := 2;' } } },
+        },
+      ],
+    })
+
+    const execute = body.rung.nodes.find((node) => node.type === 'execute')
+    const data = execute?.data as {
+      inputConnector?: { id?: string }
+      outputConnector?: { id?: string }
+      code: string
+    }
+
+    expect(data.inputConnector?.id).toBe('EN')
+    expect(data.outputConnector?.id).toBe('ENO')
+    expect(data.code).toBe('y := 2;')
+    expect(execute?.width).toBeGreaterThan(0)
+    expect(execute?.height).toBeGreaterThan(0)
+  })
+
   it('warns (non-fatally) about a dangling connection reference', () => {
     const { body, warnings } = parseFbdXml('p', {
       outVariable: [
diff --git a/src/frontend/utils/PLC/xml-parser/language/__tests__/ladder-xml.test.ts b/src/frontend/utils/PLC/xml-parser/language/__tests__/ladder-xml.test.ts
index 4aa7d400c..a6a9d15a0 100644
--- a/src/frontend/utils/PLC/xml-parser/language/__tests__/ladder-xml.test.ts
+++ b/src/frontend/utils/PLC/xml-parser/language/__tests__/ladder-xml.test.ts
@@ -67,20 +67,20 @@ describe('parseLadderXml', () => {
     expect(warnings).toEqual([])
     expect(body.rungs).toHaveLength(1)
     const rung = body.rungs[0]
-    // Node order within a rung follows the raw XML's element-type grouping
-    // (leftPowerRail, rightPowerRail, contact, coil, ...) — see
-    // parseLadderXml's node-collection loop — not rung/visual position.
-    expect(rung.nodes.map((n) => n.id)).toEqual(['LEFT-POWER-RAIL-1', 'RIGHT-POWER-RAIL-4', 'CONTACT-2', 'COIL-3'])
+    // Electrical order, not the element-type grouping the parse produces
+    // (leftPowerRail, rightPowerRail, contact, coil, ...) — the ladder editor
+    // reads this array as the rung's serial spine. See orderRungNodes.
+    expect(rung.nodes.map((n) => n.id)).toEqual(['left-rail-1', 'CONTACT-2', 'COIL-3', 'right-rail-4'])
     // Edge order follows pendingEdges collection order (grouped by the
     // consuming node's XML element type), not visual left-to-right order —
     // compare as a set of {source,target} pairs instead of an exact sequence.
     expect(rung.edges).toHaveLength(3)
     expect(rung.edges.map((e) => `${e.source}->${e.target}`).sort()).toEqual(
-      ['LEFT-POWER-RAIL-1->CONTACT-2', 'CONTACT-2->COIL-3', 'COIL-3->RIGHT-POWER-RAIL-4'].sort(),
+      ['left-rail-1->CONTACT-2', 'CONTACT-2->COIL-3', 'COIL-3->right-rail-4'].sort(),
     )
     expect(rung.edges.every((e) => e.type === 'smoothstep')).toBe(true)
-    expect((rung.nodes[2].data as { variable: { name: string } }).variable).toEqual({ name: 'X1' })
-    expect((rung.nodes[3].data as { variable: { name: string } }).variable).toEqual({ name: 'Y1' })
+    expect((rung.nodes[1].data as { variable: { name: string } }).variable).toEqual({ name: 'X1' })
+    expect((rung.nodes[2].data as { variable: { name: string } }).variable).toEqual({ name: 'Y1' })
     expect(rung.defaultBounds).toEqual([0, 0, 170, 40])
     expect(rung.reactFlowViewport).toEqual([170, 40])
   })
@@ -103,6 +103,36 @@ describe('parseLadderXml', () => {
           connectionPointOut: { relPosition: { '@x': '20', '@y': '20' } },
         },
       ],
+      // One coil per rail: a component of nothing but rails carries no logic
+      // and is dropped, so each rung needs an element to exist at all.
+      coil: [
+        {
+          '@localId': '3',
+          '@negated': 'false',
+          '@width': '40',
+          '@height': '40',
+          position: { '@x': '50', '@y': '0' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '1', '@formalParameter': 'left-rail' }],
+          },
+          connectionPointOut: { relPosition: { '@x': '40', '@y': '20' } },
+          variable: ['Y1'],
+        },
+        {
+          '@localId': '4',
+          '@negated': 'false',
+          '@width': '40',
+          '@height': '40',
+          position: { '@x': '50', '@y': '100' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '2', '@formalParameter': 'left-rail' }],
+          },
+          connectionPointOut: { relPosition: { '@x': '40', '@y': '20' } },
+          variable: ['Y2'],
+        },
+      ],
     })
     expect(body.rungs).toHaveLength(2)
   })
@@ -305,4 +335,181 @@ describe('parseLadderXml', () => {
     expect(body.rungs[0].edges).toEqual([])
     expect(warnings).toEqual(['POU "p": LD connection references unknown localId "doesnotexist", skipped'])
   })
+  // Regression: rails used to import as `LEFT-POWER-RAIL-<id>` /
+  // `RIGHT-POWER-RAIL-<id>`, but the rung layout resolves them by the
+  // `left-rail` / `right-rail` prefix. `changeRailBounds` therefore found no
+  // right rail on an imported rung and returned early, so the rail never
+  // repositioned and elements added afterwards ran straight past it.
+  it('names rails with the prefix the rung layout looks them up by', () => {
+    const { body } = parseLadderXml('p', {
+      leftPowerRail: [
+        {
+          '@localId': '1',
+          '@width': '3',
+          '@height': '40',
+          position: { '@x': '0', '@y': '0' },
+          connectionPointOut: { relPosition: { '@x': '3', '@y': '20' } },
+        },
+      ],
+      contact: [
+        {
+          '@localId': '2',
+          '@negated': 'false',
+          '@width': '40',
+          '@height': '40',
+          position: { '@x': '50', '@y': '0' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '1', '@formalParameter': 'left-rail' }],
+          },
+          connectionPointOut: { relPosition: { '@x': '40', '@y': '20' } },
+          variable: ['X1'],
+        },
+      ],
+      rightPowerRail: [
+        {
+          '@localId': '3',
+          '@width': '3',
+          '@height': '40',
+          position: { '@x': '400', '@y': '0' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '2', '@formalParameter': 'output' }],
+          },
+        },
+      ],
+    })
+
+    const ids = body.rungs.flatMap((rung) => rung.nodes.map((node) => node.id))
+    expect(ids.some((id) => id.startsWith('left-rail'))).toBe(true)
+    expect(ids.some((id) => id.startsWith('right-rail'))).toBe(true)
+  })
+
+  // Regression: nodes used to reach the editor grouped by XML element type
+  // (every <contact>, then every <coil>, then every <block>), because that is
+  // how they are parsed. The ladder editor reads a rung's node array as its
+  // serial spine — `appendSerialConnection` and `getPreviousElement` treat the
+  // entry before a node as its electrical predecessor — so inserting an element
+  // wired it to whatever was parsed before it. With a rung whose only element
+  // was a block, that predecessor was the right power rail, which has no output
+  // connector: adding a contact next to the block threw.
+  it('orders a rung electrically, whatever order the elements were parsed in', () => {
+    const { body } = parseLadderXml('p', {
+      leftPowerRail: [
+        {
+          '@localId': '1',
+          '@width': '3',
+          '@height': '40',
+          position: { '@x': '0', '@y': '0' },
+          connectionPointOut: { relPosition: { '@x': '3', '@y': '20' } },
+        },
+      ],
+      // Parsed after the right rail, but electrically between the two rails.
+      coil: [
+        {
+          '@localId': '4',
+          '@negated': 'false',
+          '@width': '40',
+          '@height': '40',
+          position: { '@x': '120', '@y': '0' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '3', '@formalParameter': 'output' }],
+          },
+          connectionPointOut: { relPosition: { '@x': '40', '@y': '20' } },
+          variable: ['Y1'],
+        },
+      ],
+      contact: [
+        {
+          '@localId': '3',
+          '@negated': 'false',
+          '@width': '40',
+          '@height': '40',
+          position: { '@x': '50', '@y': '0' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '1', '@formalParameter': 'left-rail' }],
+          },
+          connectionPointOut: { relPosition: { '@x': '40', '@y': '20' } },
+          variable: ['X1'],
+        },
+      ],
+      rightPowerRail: [
+        {
+          '@localId': '2',
+          '@width': '3',
+          '@height': '40',
+          position: { '@x': '400', '@y': '0' },
+          connectionPointIn: {
+            relPosition: { '@x': '0', '@y': '20' },
+            connection: [{ '@refLocalId': '4', '@formalParameter': 'output' }],
+          },
+        },
+      ],
+    })
+
+    expect(body.rungs).toHaveLength(1)
+    expect(body.rungs[0].nodes.map((node) => node.id)).toEqual(['left-rail-1', 'CONTACT-3', 'COIL-4', 'right-rail-2'])
+  })
+
+  // A foreign or hand-edited file can declare typeName="EXECUTE" without the
+  // EN/ENO formal parameters we always write. The rung layout reads
+  // `inputConnector` / `outputConnector` to place whatever is inserted beside
+  // an element, and an undefined one throws — so the importer supplies them.
+  it('gives an Execute element EN and ENO even when the file declares neither', () => {
+    const { body } = parseLadderXml('p', {
+      leftPowerRail: [
+        {
+          '@localId': '1',
+          position: { '@x': '0', '@y': '0' },
+          connectionPointOut: { relPosition: { '@x': '3', '@y': '20' } },
+        },
+      ],
+      block: [
+        {
+          '@localId': '2',
+          '@typeName': 'EXECUTE',
+          position: { '@x': '50', '@y': '0' },
+          addData: { data: { '@name': 'http://openplc.org/plcopenxml/stcode', STCode: 'x := 1;' } },
+        },
+      ],
+    })
+
+    const execute = body.rungs[0].nodes.find((node) => node.type === 'execute')
+    const data = execute?.data as {
+      inputConnector?: { id?: string }
+      outputConnector?: { id?: string }
+      code: string
+    }
+
+    expect(data.inputConnector?.id).toBe('EN')
+    expect(data.outputConnector?.id).toBe('ENO')
+    expect(data.code).toBe('x := 1;')
+    // Sized from its snippet rather than left 0x0 — CODESYS omits width and
+    // height entirely.
+    expect(execute?.width).toBeGreaterThan(0)
+    expect(execute?.height).toBeGreaterThan(0)
+  })
+
+  // A component holding nothing but power rails is a rail the file left
+  // unwired — CODESYS writes its <rightPowerRail> with an empty
+  // <connectionPointIn>. It would otherwise import as a rung the editor cannot
+  // lay out or add elements to.
+  it('skips a network that has no elements, and says so', () => {
+    const { body, warnings } = parseLadderXml('p', {
+      rightPowerRail: [
+        {
+          '@localId': '9',
+          '@width': '3',
+          '@height': '40',
+          position: { '@x': '400', '@y': '0' },
+          connectionPointIn: { relPosition: { '@x': '0', '@y': '20' }, connection: [] },
+        },
+      ],
+    })
+
+    expect(body.rungs).toEqual([])
+    expect(warnings).toEqual(['POU "p": 1 LD network(s) with no elements (unwired power rail) skipped'])
+  })
 })
diff --git a/src/frontend/utils/PLC/xml-parser/language/fbd-xml.ts b/src/frontend/utils/PLC/xml-parser/language/fbd-xml.ts
index f0ec2ce2e..4b95fc4e2 100644
--- a/src/frontend/utils/PLC/xml-parser/language/fbd-xml.ts
+++ b/src/frontend/utils/PLC/xml-parser/language/fbd-xml.ts
@@ -1,4 +1,10 @@
 import { BlockNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/block'
+import {
+  DEFAULT_EXECUTE_CONNECTOR_Y,
+  DEFAULT_EXECUTE_HEIGHT,
+  DEFAULT_EXECUTE_WIDTH,
+} from '@root/frontend/components/_atoms/graphical-editor/fbd/utils/constants'
+import type { ExecuteNode } from '@root/frontend/components/_atoms/graphical-editor/fbd/utils/types'
 import {
   CommentNode,
   ConnectionNode,
@@ -8,11 +14,13 @@ import { BlockVariant } from '@root/frontend/components/_atoms/graphical-editor/
 import { FBDFlowType } from '@root/frontend/store/slices'
 import { Edge, Position } from '@xyflow/react'
 
+import { readExecuteStCode } from '../../execute-plcopen'
 import { extractXhtmlText } from '../variable-xml'
 import { asArray, asRecord, asString } from '../xml-node'
+import type { XyPosition } from './geometry'
 import { makeHandle, parsePositionXml, toNumber } from './geometry'
 
-type FbdNode = BlockNode<BlockVariant> | CommentNode | ConnectionNode | VariableNode
+type FbdNode = BlockNode<BlockVariant> | CommentNode | ConnectionNode | ExecuteNode | VariableNode
 
 // Reverse of xml-generator/old-editor/language/fbd-xml.ts. Greenfield (no
 // PLCopen import reference existed anywhere before this) — reconstructed
@@ -146,6 +154,114 @@ function parseBlockXml(entry: Record<string, unknown>): { node: BlockNode<BlockV
   return { node, pendingEdges }
 }
 
+/** An `EN` / `ENO` handle for a file that declared neither. */
+function makeExecuteFallbackHandle(id: 'EN' | 'ENO', position: XyPosition) {
+  const relPosition = { '@x': id === 'EN' ? 0 : DEFAULT_EXECUTE_WIDTH, '@y': DEFAULT_EXECUTE_CONNECTOR_Y }
+  return makeHandle(
+    id,
+    id === 'EN' ? 'target' : 'source',
+    id === 'EN' ? Position.Left : Position.Right,
+    position,
+    relPosition,
+    {
+      top: DEFAULT_EXECUTE_CONNECTOR_Y,
+      ...(id === 'EN' ? { left: 0 } : { right: 0 }),
+    },
+  )
+}
+
+/**
+ * Rebuild an Execute ("ST Block") element from a `<block typeName="EXECUTE">`.
+ *
+ * Without this the generic block path claims it, producing a nameless function
+ * block with no snippet and pins that do not match the wiring — so the element
+ * imports empty and disconnected.
+ */
+function parseExecuteXml(
+  entry: Record<string, unknown>,
+  code: string,
+): { node: ExecuteNode; pendingEdges: PendingEdge[] } {
+  const numericId = asString(entry['@localId'])
+  const position = parsePositionXml(entry.position)
+  const pendingEdges: PendingEdge[] = []
+
+  const inputHandles: ExecuteNode['data']['inputHandles'] = []
+  for (const varRaw of asArray(asRecord(entry.inputVariables).variable)) {
+    const v = asRecord(varRaw)
+    const formalParameter = asString(v['@formalParameter'])
+    const connIn = asRecord(v.connectionPointIn)
+    // `style.top` places the handle's DOM element; React Flow draws edges to
+    // that position, not to `relPosition`.
+    inputHandles.push(
+      makeHandle(formalParameter, 'target', Position.Left, position, connIn.relPosition, {
+        top: DEFAULT_EXECUTE_CONNECTOR_Y,
+        left: 0,
+      }),
+    )
+    for (const connRaw of asArray(connIn.connection)) {
+      pendingEdges.push(parseConnectionXml(connRaw, numericId, formalParameter))
+    }
+  }
+
+  const outputHandles: ExecuteNode['data']['outputHandles'] = asArray(asRecord(entry.outputVariables).variable).map(
+    (varRaw) => {
+      const v = asRecord(varRaw)
+      const connOut = asRecord(v.connectionPointOut)
+      return makeHandle(asString(v['@formalParameter']), 'source', Position.Right, position, connOut.relPosition, {
+        top: DEFAULT_EXECUTE_CONNECTOR_Y,
+        right: 0,
+      })
+    },
+  )
+
+  // A file that declares typeName="EXECUTE" without EN/ENO still has to
+  // produce a usable box — `inputConnector` / `outputConnector` must exist.
+  // Nothing we write omits them; this covers hand-edited and foreign files.
+  if (inputHandles.length === 0) inputHandles.push(makeExecuteFallbackHandle('EN', position))
+  if (outputHandles.length === 0) outputHandles.push(makeExecuteFallbackHandle('ENO', position))
+
+  const node: ExecuteNode = {
+    id: `EXECUTE-${numericId}`,
+    type: 'execute',
+    position,
+    // `||` and not `??`: toNumber yields 0 for an absent attribute, and a
+    // 0-sized box is exactly what needs the fallback. CODESYS omits both.
+    width: toNumber(entry['@width']) || DEFAULT_EXECUTE_WIDTH,
+    height: toNumber(entry['@height']) || DEFAULT_EXECUTE_HEIGHT,
+    draggable: true,
+    selectable: true,
+    data: {
+      handles: [...inputHandles, ...outputHandles],
+      inputHandles,
+      outputHandles,
+      inputConnector: inputHandles[0],
+      outputConnector: outputHandles[0],
+      numericId,
+      code,
+      variable: { name: '' },
+      executionOrder: toNumber(entry['@executionOrderId']),
+      draggable: true,
+      selectable: true,
+      deletable: true,
+    },
+  }
+
+  return { node, pendingEdges }
+}
+
+/**
+ * The id of a node's only output handle, or undefined when it has none or
+ * several. A comment node carries no handles at all, hence the narrowing.
+ */
+function soleOutputHandleId(node: FbdNode | undefined): string | undefined {
+  if (!node) return undefined
+  const data: unknown = node.data
+  if (typeof data !== 'object' || data === null || !('outputHandles' in data)) return undefined
+  const { outputHandles } = data as { outputHandles?: { id?: string }[] }
+  if (outputHandles?.length !== 1) return undefined
+  return outputHandles[0].id
+}
+
 function parseInVariableXml(entry: Record<string, unknown>): VariableNode {
   const numericId = asString(entry['@localId'])
   const position = parsePositionXml(entry.position)
@@ -323,7 +439,17 @@ function parseCommentXml(entry: Record<string, unknown>): CommentNode {
   }
 }
 
-export function parseFbdXml(pouName: string, fbdXml: unknown): { body: FBDFlowType; warnings: string[] } {
+export function parseFbdXml(
+  pouName: string,
+  fbdXml: unknown,
+  /**
+   * Untrimmed `<STCode>` payloads by `@localId`, from a second parse — see
+   * `parse-xml-document.ts`. The main parse trims text nodes, which would eat
+   * an Execute snippet's first-line indentation. Absent (tests, callers that
+   * don't care) falls back to the trimmed text.
+   */
+  executeStCode: ReadonlyMap<string, string> = new Map(),
+): { body: FBDFlowType; warnings: string[] } {
   const fbd = asRecord(fbdXml)
   const warnings: string[] = []
   const nodes: FbdNode[] = []
@@ -331,7 +457,13 @@ export function parseFbdXml(pouName: string, fbdXml: unknown): { body: FBDFlowTy
   const pendingEdges: PendingEdge[] = []
 
   for (const entry of asArray(fbd.block)) {
-    const { node, pendingEdges: edges } = parseBlockXml(asRecord(entry))
+    const record = asRecord(entry)
+    // An Execute element rides in as a <block typeName="EXECUTE">, so it has
+    // to be split out before the generic block path claims it.
+    const trimmedCode = readExecuteStCode(record)
+    const executeCode = trimmedCode === null ? null : (executeStCode.get(asString(record['@localId'])) ?? trimmedCode)
+    const { node, pendingEdges: edges } =
+      executeCode === null ? parseBlockXml(record) : parseExecuteXml(record, executeCode)
     nodes.push(node)
     nodeIdByNumericId.set(node.data.numericId, node.id)
     pendingEdges.push(...edges)
@@ -372,6 +504,7 @@ export function parseFbdXml(pouName: string, fbdXml: unknown): { body: FBDFlowTy
   }
 
   const edges: Edge[] = []
+  const nodeById = new Map(nodes.map((node) => [node.id, node]))
   for (const pending of pendingEdges) {
     const targetNodeId = nodeIdByNumericId.get(pending.targetNumericId)
     const sourceNodeId = nodeIdByNumericId.get(pending.sourceRefLocalId)
@@ -381,7 +514,13 @@ export function parseFbdXml(pouName: string, fbdXml: unknown): { body: FBDFlowTy
       )
       continue
     }
-    const sourceHandle = pending.sourceFormalParameter ?? LEAF_OUTPUT_HANDLE_ID
+    // A block-shaped source names the pin it is read from; a contact or
+    // variable has a single anonymous output. Fall back to the source's only
+    // output handle when the name is missing — files exported before Execute
+    // was recognised as block-shaped omit it, and defaulting to the leaf id
+    // would leave the edge pointing at a handle that does not exist.
+    const sourceHandle =
+      pending.sourceFormalParameter ?? soleOutputHandleId(nodeById.get(sourceNodeId)) ?? LEAF_OUTPUT_HANDLE_ID
     edges.push({
       id: `xy-edge__${sourceNodeId}${sourceHandle}-${targetNodeId}${pending.targetHandle}`,
       source: sourceNodeId,
diff --git a/src/frontend/utils/PLC/xml-parser/language/geometry.ts b/src/frontend/utils/PLC/xml-parser/language/geometry.ts
index bd3477df4..ca83d7021 100644
--- a/src/frontend/utils/PLC/xml-parser/language/geometry.ts
+++ b/src/frontend/utils/PLC/xml-parser/language/geometry.ts
@@ -29,6 +29,13 @@ export interface HandleGeometry {
   position: Position
   glbPosition: XyPosition
   relPosition: XyPosition
+  /**
+   * CSS offset for the handle's DOM element. React Flow draws edges to where
+   * the handle actually renders, so an element whose connectors sit somewhere
+   * other than its vertical centre must supply this — `relPosition` alone only
+   * describes the model, not the layout.
+   */
+  style?: { top: number; left?: number; right?: number }
 }
 
 // glbPosition (absolute canvas coordinates) never appears in PLCopen XML —
@@ -41,6 +48,7 @@ export function makeHandle(
   side: Position,
   nodePosition: XyPosition,
   relPositionXml: unknown,
+  style?: HandleGeometry['style'],
 ): HandleGeometry {
   const relPosition = parsePositionXml(relPositionXml)
   return {
@@ -49,5 +57,6 @@ export function makeHandle(
     position: side,
     relPosition,
     glbPosition: { x: nodePosition.x + relPosition.x, y: nodePosition.y + relPosition.y },
+    ...(style ? { style } : {}),
   }
 }
diff --git a/src/frontend/utils/PLC/xml-parser/language/ladder-xml.ts b/src/frontend/utils/PLC/xml-parser/language/ladder-xml.ts
index b0799239d..460692ee6 100644
--- a/src/frontend/utils/PLC/xml-parser/language/ladder-xml.ts
+++ b/src/frontend/utils/PLC/xml-parser/language/ladder-xml.ts
@@ -1,18 +1,26 @@
+import {
+  DEFAULT_EXECUTE_CONNECTOR_Y,
+  DEFAULT_EXECUTE_WIDTH,
+  executeHeight,
+} from '@root/frontend/components/_atoms/graphical-editor/ladder/utils/constants'
 import {
   BlockNode,
   BlockVariant,
   CoilNode,
   ContactNode,
+  ExecuteNode,
   PowerRailNode,
   VariableNode,
 } from '@root/frontend/components/_atoms/graphical-editor/ladder/utils/types'
 import { LadderFlowType } from '@root/frontend/store/slices'
 import { Edge, Position } from '@xyflow/react'
 
+import { readExecuteStCode } from '../../execute-plcopen'
 import { asArray, asRecord, asString } from '../xml-node'
+import type { XyPosition } from './geometry'
 import { makeHandle, parsePositionXml, toNumber } from './geometry'
 
-type LadderParsedNode = PowerRailNode | ContactNode | CoilNode | BlockNode<BlockVariant> | VariableNode
+type LadderParsedNode = PowerRailNode | ContactNode | CoilNode | BlockNode<BlockVariant> | VariableNode | ExecuteNode
 
 // Reverse of xml-generator/old-editor/language/ladder-xml.ts. Greenfield (no
 // PLCopen import reference existed anywhere before this) — reconstructed by
@@ -73,6 +81,12 @@ function parseConnectionXml(connXml: unknown, targetNumericId: string, targetHan
   }
 }
 
+// Rails are the one exception to this file's `TYPE-<localId>` id convention.
+// The rung layout resolves them by prefix — `id.startsWith('left-rail')` /
+// `'right-rail'` (see changeRailBounds and the handle-branch helpers) — so a
+// differently-prefixed id makes an imported rung's right rail invisible to the
+// layout: it never repositions, and elements added afterwards run straight
+// past it.
 function parseLeftRailXml(entry: Record<string, unknown>): PowerRailNode {
   const numericId = asString(entry['@localId'])
   const position = parsePositionXml(entry.position)
@@ -85,7 +99,7 @@ function parseLeftRailXml(entry: Record<string, unknown>): PowerRailNode {
   )
 
   return {
-    id: `LEFT-POWER-RAIL-${numericId}`,
+    id: `left-rail-${numericId}`,
     type: 'powerRail',
     position,
     width: toNumber(entry['@width']),
@@ -119,7 +133,7 @@ function parseRightRailXml(entry: Record<string, unknown>): { node: PowerRailNod
   )
 
   const node: PowerRailNode = {
-    id: `RIGHT-POWER-RAIL-${numericId}`,
+    id: `right-rail-${numericId}`,
     type: 'powerRail',
     position,
     width: toNumber(entry['@width']),
@@ -334,6 +348,105 @@ function parseBlockXml(entry: Record<string, unknown>): { node: BlockNode<BlockV
   return { node, pendingEdges }
 }
 
+/** An `EN` / `ENO` handle for a file that declared neither. */
+function makeExecuteFallbackHandle(id: 'EN' | 'ENO', position: XyPosition) {
+  const side = id === 'EN' ? Position.Left : Position.Right
+  const relPosition = { '@x': id === 'EN' ? 0 : DEFAULT_EXECUTE_WIDTH, '@y': DEFAULT_EXECUTE_CONNECTOR_Y }
+  return makeHandle(id, id === 'EN' ? 'target' : 'source', side, position, relPosition, {
+    top: DEFAULT_EXECUTE_CONNECTOR_Y,
+    ...(id === 'EN' ? { left: 0 } : { right: 0 }),
+  })
+}
+
+/**
+ * Rebuild an Execute ("ST Block") element from a `<block typeName="EXECUTE">`.
+ *
+ * PLCopen has no inline-ST element, so the snippet rides in an `<addData>`
+ * under 3S's `.../plcopenxml/stcode` URI — the same shape CODESYS writes, so
+ * their exports import here too. See `utils/PLC/execute-plcopen.ts`.
+ *
+ * The `EN`/`ENO` pins are ordinary formal parameters, so connections rebuild
+ * through exactly the same `parseConnectionXml` path as any other block.
+ */
+function parseExecuteXml(
+  entry: Record<string, unknown>,
+  code: string,
+): { node: ExecuteNode; pendingEdges: PendingEdge[] } {
+  const numericId = asString(entry['@localId'])
+  const position = parsePositionXml(entry.position)
+  const pendingEdges: PendingEdge[] = []
+
+  const inputHandles: ExecuteNode['data']['inputHandles'] = []
+  for (const varRaw of asArray(asRecord(entry.inputVariables).variable)) {
+    const v = asRecord(varRaw)
+    const formalParameter = asString(v['@formalParameter'])
+    const connIn = asRecord(v.connectionPointIn)
+    // `style.top` is what places the handle's DOM element, and React Flow
+    // draws edges to the DOM position — without it an imported box has its
+    // wires meeting it at the element's vertical centre instead of the pin row.
+    inputHandles.push(
+      makeHandle(formalParameter, 'target', Position.Left, position, connIn.relPosition, {
+        top: DEFAULT_EXECUTE_CONNECTOR_Y,
+        left: 0,
+      }),
+    )
+    for (const connRaw of asArray(connIn.connection)) {
+      pendingEdges.push(parseConnectionXml(connRaw, numericId, formalParameter))
+    }
+  }
+
+  const outputHandles: ExecuteNode['data']['outputHandles'] = asArray(asRecord(entry.outputVariables).variable).map(
+    (varRaw) => {
+      const v = asRecord(varRaw)
+      const connOut = asRecord(v.connectionPointOut)
+      return makeHandle(asString(v['@formalParameter']), 'source', Position.Right, position, connOut.relPosition, {
+        top: DEFAULT_EXECUTE_CONNECTOR_Y,
+        right: 0,
+      })
+    },
+  )
+
+  // A file that declares typeName="EXECUTE" without EN/ENO still has to
+  // produce a usable box: the rung layout reads `inputConnector` /
+  // `outputConnector` to place whatever is inserted next to it, and an
+  // undefined one crashes it. Nothing we write omits them — this covers
+  // hand-edited and foreign files.
+  if (inputHandles.length === 0) inputHandles.push(makeExecuteFallbackHandle('EN', position))
+  if (outputHandles.length === 0) outputHandles.push(makeExecuteFallbackHandle('ENO', position))
+
+  // `||` and not `??`: toNumber yields 0 for an absent or unparseable
+  // attribute, and a 0-sized box is exactly what needs the fallback. CODESYS
+  // omits width/height entirely, so this is its normal path.
+  const width = toNumber(entry['@width']) || DEFAULT_EXECUTE_WIDTH
+  const height = toNumber(entry['@height']) || executeHeight(code === '' ? 0 : code.split('\n').length)
+
+  const node: ExecuteNode = {
+    id: `EXECUTE-${numericId}`,
+    type: 'execute',
+    position,
+    width,
+    height,
+    draggable: true,
+    selectable: true,
+    data: {
+      handles: [...inputHandles, ...outputHandles],
+      inputHandles,
+      outputHandles,
+      inputConnector: inputHandles[0],
+      outputConnector: outputHandles[0],
+      numericId,
+      code,
+      variable: { name: '' },
+      executionOrder: toNumber(entry['@executionOrderId']),
+      draggable: true,
+      selectable: true,
+      deletable: true,
+    },
+  }
+
+  return { node, pendingEdges }
+}
+
 function parseInVariableXml(entry: Record<string, unknown>): VariableNode {
   const numericId = asString(entry['@localId'])
   const position = parsePositionXml(entry.position)
@@ -456,7 +569,112 @@ class UnionFind {
   }
 }
 
-export function parseLadderXml(pouName: string, ldXml: unknown): { body: LadderFlowType; warnings: string[] } {
+/**
+ * Shift a rung's nodes vertically by `dy`, keeping handle geometry in step.
+ *
+ * Mutates the freshly-parsed nodes rather than rebuilding them: `data` is a
+ * discriminated union whose members differ, and every node's handles are
+ * reached the same way regardless. `inputConnector` / `outputConnector` alias
+ * the same handle objects, so moving those objects updates every view of them.
+ */
+function translateRungY(rungNodes: LadderParsedNode[], dy: number): void {
+  if (dy === 0) return
+  // `handles` holds the same objects as `inputHandles` / `outputHandles`, so
+  // track identity — moving one twice would double the shift.
+  const moved = new Set<object>()
+  for (const node of rungNodes) {
+    node.position = { x: node.position.x, y: node.position.y + dy }
+    const data: unknown = node.data
+    if (typeof data !== 'object' || data === null) continue
+    for (const key of ['handles', 'inputHandles', 'outputHandles'] as const) {
+      if (!(key in data)) continue
+      const handles = (data as Record<string, unknown>)[key]
+      if (!Array.isArray(handles)) continue
+      for (const handle of handles) {
+        if (typeof handle !== 'object' || handle === null || !('glbPosition' in handle)) continue
+        if (moved.has(handle)) continue
+        moved.add(handle)
+        const { glbPosition } = handle as { glbPosition: { x: number; y: number } }
+        glbPosition.y += dy
+      }
+    }
+  }
+}
+
+/**
+ * Put a rung's nodes in electrical order: left rail first, each element in
+ * signal-flow order, right rail last.
+ *
+ * The parse builds nodes grouped by XML element type — every `<contact>`, then
+ * every `<coil>`, then every `<block>` — because that is the shape
+ * fast-xml-parser hands over. The ladder editor reads a rung's node array as
+ * its serial spine, though: `appendSerialConnection` and `getPreviousElement`
+ * both take "the entry before this one in the array" to be the electrical
+ * predecessor. Fed a type-grouped array, inserting an element wires it to
+ * whatever happened to be parsed before it — typically the right power rail,
+ * which has no output connector at all.
+ *
+ * Kahn's algorithm over the rung's own edges, tie-broken by X then parse order.
+ * Newly-ready successors go to the front of the queue so a chain stays
+ * contiguous — a parallel path's elements must not interleave with its
+ * sibling's.
+ */
+function orderRungNodes(rungNodes: LadderParsedNode[], rungEdges: Edge[]): LadderParsedNode[] {
+  const byId = new Map(rungNodes.map((node) => [node.id, node]))
+  const parseIndex = new Map(rungNodes.map((node, index) => [node.id, index]))
+  const inDegree = new Map(rungNodes.map((node) => [node.id, 0]))
+  const successors = new Map<string, string[]>()
+
+  for (const edge of rungEdges) {
+    if (!inDegree.has(edge.source) || !inDegree.has(edge.target)) continue
+    inDegree.set(edge.target, (inDegree.get(edge.target) ?? 0) + 1)
+    const existing = successors.get(edge.source)
+    if (existing) existing.push(edge.target)
+    else successors.set(edge.source, [edge.target])
+  }
+
+  const compare = (a: LadderParsedNode, b: LadderParsedNode): number =>
+    a.position.x - b.position.x || (parseIndex.get(a.id) ?? 0) - (parseIndex.get(b.id) ?? 0)
+
+  const queue = rungNodes.filter((node) => (inDegree.get(node.id) ?? 0) === 0).sort(compare)
+  const ordered: LadderParsedNode[] = []
+  const placed = new Set<string>()
+
+  while (queue.length > 0) {
+    const node = queue.shift()
+    if (!node) break
+    ordered.push(node)
+    placed.add(node.id)
+
+    const unlocked: LadderParsedNode[] = []
+    for (const successorId of successors.get(node.id) ?? []) {
+      const remaining = (inDegree.get(successorId) ?? 0) - 1
+      inDegree.set(successorId, remaining)
+      if (remaining !== 0) continue
+      const successor = byId.get(successorId)
+      if (successor) unlocked.push(successor)
+    }
+    queue.unshift(...unlocked.sort(compare))
+  }
+
+  // Ladder bodies are acyclic, so this only guards against a malformed file —
+  // an unorderable node keeps its parse position rather than being dropped.
+  for (const node of rungNodes) if (!placed.has(node.id)) ordered.push(node)
+
+  return ordered
+}
+
+export function parseLadderXml(
+  pouName: string,
+  ldXml: unknown,
+  /**
+   * Untrimmed `<STCode>` payloads by `@localId`, from a second parse — see
+   * `parse-xml-document.ts`. The main parse trims text nodes, which would
+   * eat an Execute snippet's first-line indentation and trailing newline.
+   * Absent (tests, callers that don't care) falls back to the trimmed text.
+   */
+  executeStCode: ReadonlyMap<string, string> = new Map(),
+): { body: LadderFlowType; warnings: string[] } {
   const ld = asRecord(ldXml)
   const warnings: string[] = []
   const nodes: LadderParsedNode[] = []
@@ -487,7 +705,14 @@ export function parseLadderXml(pouName: string, ldXml: unknown): { body: LadderF
     pendingEdges.push(...edges)
   }
   for (const entry of asArray(ld.block)) {
-    const { node, pendingEdges: edges } = parseBlockXml(asRecord(entry))
+    const record = asRecord(entry)
+    // An Execute ("ST Block") element rides in as a <block> with
+    // typeName="EXECUTE" — the shape CODESYS itself writes — so it has to be
+    // split out here before the generic block path claims it as a function call.
+    const trimmedCode = readExecuteStCode(record)
+    const executeCode = trimmedCode === null ? null : (executeStCode.get(asString(record['@localId'])) ?? trimmedCode)
+    const { node, pendingEdges: edges } =
+      executeCode === null ? parseBlockXml(record) : parseExecuteXml(record, executeCode)
     nodes.push(node)
     nodeIdByNumericId.set(node.data.numericId, node.id)
     pendingEdges.push(...edges)
@@ -538,7 +763,7 @@ export function parseLadderXml(pouName: string, ldXml: unknown): { body: LadderF
   // Rungs never cross-connect, so a connected-component partition of the
   // node/edge graph recovers them, without needing the array-position
   // pairing the generator's own output happens to preserve.
-  const componentOrder: string[] = []
+  const allComponents: string[] = []
   const componentNodes = new Map<string, LadderParsedNode[]>()
   for (const node of nodes) {
     const root = forest.find(node.id)
@@ -547,20 +772,45 @@ export function parseLadderXml(pouName: string, ldXml: unknown): { body: LadderF
       group.push(node)
     } else {
       componentNodes.set(root, [node])
-      componentOrder.push(root)
+      allComponents.push(root)
     }
   }
 
-  // Rung stacking (offsetY in the generator) bakes a cumulative Y shift into
-  // every node's position; re-basing each rung to a local origin would need
-  // to rebuild every node-data variant's handles generically, which TS can't
-  // do without a type assertion across this discriminated union — kept as
-  // absolute coordinates instead (still internally consistent per rung; a
-  // reopened diagram just starts further down the canvas for later rungs).
+  // A component of nothing but power rails carries no logic — it is a rail the
+  // file left unwired (CODESYS emits its <rightPowerRail> with an empty
+  // <connectionPointIn>, so it lands in a component of its own). Turning that
+  // into a rung yields one the editor cannot lay out or add to, so drop it and
+  // say so rather than shipping a broken rung.
+  const componentOrder: string[] = []
+  let skippedEmptyNetworks = 0
+  for (const root of allComponents) {
+    const group = componentNodes.get(root) ?? []
+    if (group.some((node) => node.type !== 'powerRail')) componentOrder.push(root)
+    else skippedEmptyNetworks += 1
+  }
+  if (skippedEmptyNetworks > 0) {
+    warnings.push(
+      `POU "${pouName}": ${skippedEmptyNetworks} LD network(s) with no elements (unwired power rail) skipped`,
+    )
+  }
+
+  // Rung stacking bakes a cumulative Y shift into every node's position (the
+  // generator adds each preceding rung's viewport height, see ladderToXml), so
+  // an imported rung's contents would otherwise sit far below its own
+  // viewport — a large blank gap above the elements, growing with every rung.
+  // Re-base each rung so its topmost element sits where the first rung's does.
+  const rungTops = componentOrder.map((root) => {
+    const rungNodes = componentNodes.get(root) ?? []
+    return rungNodes.length > 0 ? Math.min(...rungNodes.map((n) => n.position.y)) : 0
+  })
+  const topmostRungY = rungTops.length > 0 ? Math.min(...rungTops) : 0
+
   const rungs: LadderFlowType['rungs'] = componentOrder.map((root, index) => {
     const rungNodeIds = new Set(componentNodes.get(root)?.map((n) => n.id))
     const rungEdges = edges.filter((e) => rungNodeIds.has(e.source) && rungNodeIds.has(e.target))
-    const rungNodes = componentNodes.get(root) ?? []
+    const rungNodes = orderRungNodes(componentNodes.get(root) ?? [], rungEdges)
+
+    translateRungY(rungNodes, topmostRungY - rungTops[index])
 
     const minX = Math.min(...rungNodes.map((n) => n.position.x))
     const minY = Math.min(...rungNodes.map((n) => n.position.y))
diff --git a/src/frontend/utils/PLC/xml-parser/parse-xml-document.ts b/src/frontend/utils/PLC/xml-parser/parse-xml-document.ts
index 01d36bbd2..8bb121837 100644
--- a/src/frontend/utils/PLC/xml-parser/parse-xml-document.ts
+++ b/src/frontend/utils/PLC/xml-parser/parse-xml-document.ts
@@ -17,6 +17,86 @@ const parser = new XMLParser({
   isArray: (name) => ARRAY_TAGS.has(name),
 })
 
+// Second parser, used only to recover whitespace-significant payloads.
+//
+// `trimValues` defaults to true and is global — fast-xml-parser has no
+// per-tag opt-out (`tagValueProcessor` receives the already-trimmed value,
+// `stopNodes` skips entity decoding). Harmless for everything else here, but
+// an Execute element's `<STCode>` is source code, and trimming eats its first
+// line's indentation. Flipping the flag globally would change every other
+// value, so the document is parsed again with trimming off and only the
+// STCode payloads are taken from it.
+const untrimmedParser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: '@',
+  textNodeName: '$',
+  parseTagValue: false,
+  parseAttributeValue: false,
+  trimValues: false,
+  isArray: (name) => ARRAY_TAGS.has(name),
+})
+
+const EXECUTE_TYPE_NAME = 'EXECUTE'
+// Duplicated from `execute-plcopen.ts` rather than imported: this module is
+// the parser's entry point and must not pull in the generator-side surface.
+const EXECUTE_STCODE_URIS = ['http://openplc.org/plcopenxml/stcode', 'http://www.3s-software.com/plcopenxml/stcode']
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function readStCodeText(node: Record<string, unknown>): string | null {
+  const addData = node.addData
+  if (!isRecord(addData)) return null
+  const entries = Array.isArray(addData.data) ? addData.data : [addData.data]
+  for (const entry of entries) {
+    if (!isRecord(entry) || typeof entry['@name'] !== 'string') continue
+    if (!EXECUTE_STCODE_URIS.includes(entry['@name'])) continue
+    const stCode = entry.STCode
+    if (typeof stCode === 'string') return stCode
+    if (isRecord(stCode) && typeof stCode['$'] === 'string') return stCode['$']
+    return ''
+  }
+  return null
+}
+
+/**
+ * Map every Execute element's `@localId` to its untrimmed ST snippet.
+ *
+ * Keyed by localId because that is the only identifier shared between this
+ * pass and the main parse. A document with no Execute elements yields an
+ * empty map and costs one extra parse; that is the price of fast-xml-parser
+ * having no per-tag whitespace control.
+ */
+export function collectExecuteStCode(xml: string): Map<string, string> {
+  const found = new Map<string, string>()
+  let tree: unknown
+  try {
+    tree = untrimmedParser.parse(xml)
+  } catch {
+    // The main parse is the one that reports malformed input; this pass
+    // failing alone just means snippets fall back to their trimmed values.
+    return found
+  }
+
+  const walk = (value: unknown): void => {
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item)
+      return
+    }
+    if (!isRecord(value)) return
+    if (value['@typeName'] === EXECUTE_TYPE_NAME) {
+      const localId = value['@localId']
+      const code = readStCodeText(value)
+      if (typeof localId === 'string' && code !== null) found.set(localId, code)
+    }
+    for (const child of Object.values(value)) walk(child)
+  }
+
+  walk(tree)
+  return found
+}
+
 // Parses raw PLCopen XML text into the untyped object tree fast-xml-parser
 // produces. Deliberately returns `Record<string, unknown>`, not a typed
 // shape — the vendored xml-types zod schemas (xml-generator/old-editor/*)
diff --git a/src/frontend/utils/PLC/xml-parser/pou-xml.ts b/src/frontend/utils/PLC/xml-parser/pou-xml.ts
index d8b9b74b2..65ecfab3e 100644
--- a/src/frontend/utils/PLC/xml-parser/pou-xml.ts
+++ b/src/frontend/utils/PLC/xml-parser/pou-xml.ts
@@ -46,7 +46,11 @@ export function parseInterfaceXml(interfaceXml: unknown): { variables: PLCVariab
 // full; SFC and codesys-dialect bodies are surfaced as a non-fatal warning
 // and the POU is skipped — this importer's scope is the old-editor dialect
 // only (see xml-parser/index.ts).
-export function parsePousXml(pouXml: unknown): { pous: PLCPou[]; warnings: string[] } {
+export function parsePousXml(
+  pouXml: unknown,
+  /** Untrimmed Execute snippets by localId — see `parseLadderXml` / `parseFbdXml`. */
+  executeStCode: ReadonlyMap<string, string> = new Map(),
+): { pous: PLCPou[]; warnings: string[] } {
   const pous: PLCPou[] = []
   const warnings: string[] = []
 
@@ -86,7 +90,7 @@ export function parsePousXml(pouXml: unknown): { pous: PLCPou[]; warnings: strin
       continue
     }
     if (body.LD !== undefined) {
-      const { body: ldBody, warnings: ldWarnings } = parseLadderXml(name, body.LD)
+      const { body: ldBody, warnings: ldWarnings } = parseLadderXml(name, body.LD, executeStCode)
       warnings.push(...ldWarnings)
       pous.push({
         name,
@@ -98,7 +102,7 @@ export function parsePousXml(pouXml: unknown): { pous: PLCPou[]; warnings: strin
       continue
     }
     if (body.FBD !== undefined) {
-      const { body: fbdBody, warnings: fbdWarnings } = parseFbdXml(name, body.FBD)
+      const { body: fbdBody, warnings: fbdWarnings } = parseFbdXml(name, body.FBD, executeStCode)
       warnings.push(...fbdWarnings)
       pous.push({
         name,
diff --git a/src/frontend/utils/__tests__/debug-polling-filter.test.ts b/src/frontend/utils/__tests__/debug-polling-filter.test.ts
index 8e7d1eedb..f60e12fb5 100644
--- a/src/frontend/utils/__tests__/debug-polling-filter.test.ts
+++ b/src/frontend/utils/__tests__/debug-polling-filter.test.ts
@@ -1661,4 +1661,112 @@ describe('buildActiveIndexSet', () => {
       expect(activeIndexes).not.toContain(99)
     })
   })
+  // -------------------------------------------------------------------------
+  // Execute ("ST Block") elements
+  // -------------------------------------------------------------------------
+  describe('Execute element snippets', () => {
+    it('polls variables referenced in an LD Execute snippet', () => {
+      const pou = makePou(
+        'Main',
+        'program',
+        [makeVariable('COUNTER'), makeVariable('LIMIT'), makeVariable('UNUSED')],
+        'ld',
+      )
+      const indexMap = new Map([
+        ['Main:COUNTER', 10],
+        ['Main:LIMIT', 11],
+        ['Main:UNUSED', 12],
+      ])
+      const ldFlow = {
+        name: 'Main',
+        rungs: [
+          {
+            nodes: [{ type: 'execute', data: { code: 'IF COUNTER < LIMIT THEN\n  COUNTER := COUNTER + 1;\nEND_IF;' } }],
+          },
+        ],
+      }
+      const state = makeState({
+        pous: [pou],
+        debugVariableIndexes: indexMap,
+        editorName: 'Main',
+        editorLanguage: 'ld',
+        ladderFlows: [ldFlow],
+      })
+
+      const { activeIndexes } = buildActiveIndexSet(state, new Map(), null)
+      expect(activeIndexes).toEqual(expect.arrayContaining([10, 11]))
+      // A declared variable the snippet never mentions stays unpolled.
+      expect(activeIndexes).not.toContain(12)
+    })
+
+    it('polls variables referenced in an FBD Execute snippet', () => {
+      const pou = makePou('Fbd', 'program', [makeVariable('TOTAL')], 'fbd')
+      const indexMap = new Map([['Fbd:TOTAL', 20]])
+      const fbdFlow = {
+        name: 'Fbd',
+        rung: { nodes: [{ type: 'execute', data: { code: 'TOTAL := TOTAL + 222;' } }] },
+      }
+      const state = makeState({
+        pous: [pou],
+        debugVariableIndexes: indexMap,
+        editorName: 'Fbd',
+        editorLanguage: 'fbd',
+        fbdFlows: [fbdFlow],
+      })
+
+      const { activeIndexes } = buildActiveIndexSet(state, new Map(), null)
+      expect(activeIndexes).toContain(20)
+    })
+
+    it('ignores an Execute node with an empty or missing snippet', () => {
+      const pou = makePou('Main', 'program', [makeVariable('COUNTER')], 'ld')
+      const indexMap = new Map([['Main:COUNTER', 10]])
+      const ldFlow = {
+        name: 'Main',
+        rungs: [
+          {
+            nodes: [
+              { type: 'execute', data: { code: '' } },
+              { type: 'execute', data: {} },
+            ],
+          },
+        ],
+      }
+      const state = makeState({
+        pous: [pou],
+        debugVariableIndexes: indexMap,
+        editorName: 'Main',
+        editorLanguage: 'ld',
+        ladderFlows: [ldFlow],
+      })
+
+      const { activeIndexes } = buildActiveIndexSet(state, new Map(), null)
+      expect(activeIndexes).toEqual([])
+    })
+
+    it('expands FB instance members referenced from an Execute snippet', () => {
+      const pou = makePou('Main', 'program', [makeDerivedVariable('TON0', 'TON')], 'ld')
+      const indexMap = new Map([
+        ['Main:TON0', 30],
+        ['Main:TON0.Q', 31],
+      ])
+      const ldFlow = {
+        name: 'Main',
+        rungs: [{ nodes: [{ type: 'execute', data: { code: 'IF TON0.Q THEN ; END_IF;' } }] }],
+      }
+      const state = makeState({
+        pous: [pou],
+        debugVariableIndexes: indexMap,
+        editorName: 'Main',
+        editorLanguage: 'ld',
+        ladderFlows: [ldFlow],
+      })
+      const allLeaves = new Map<number, { compositeKey: string; type: string }[]>([
+        [31, [{ compositeKey: 'Main:TON0.Q', type: 'BOOL' }]],
+      ])
+
+      const { activeIndexes } = buildActiveIndexSet(state, allLeaves, null)
+      expect(activeIndexes).toEqual(expect.arrayContaining([30, 31]))
+    })
+  })
 })
diff --git a/src/frontend/utils/debug-polling-filter.ts b/src/frontend/utils/debug-polling-filter.ts
index 839e50d2b..086493588 100644
--- a/src/frontend/utils/debug-polling-filter.ts
+++ b/src/frontend/utils/debug-polling-filter.ts
@@ -16,7 +16,7 @@
  * unless the user switches tabs or FB instance selection.
  */
 
-import type { FbInstanceInfo, PLCPou } from '../../middleware/shared/ports/types'
+import type { FbInstanceInfo, PLCPou, PLCVariable } from '../../middleware/shared/ports/types'
 import { buildGlobalCompositeKey } from './debug-variable-finder'
 
 /**
@@ -339,9 +339,9 @@ function computeVisibleVariableKeys(
   }
 
   if (language === 'ld') {
-    collectLdVisibleKeys(state, makeKey, addLeavesWithPrefix, keys)
+    collectLdVisibleKeys(state, makeKey, addLeavesWithPrefix, keys, currentPou.interface?.variables ?? [])
   } else if (language === 'fbd') {
-    collectFbdVisibleKeys(state, makeKey, addLeavesWithPrefix, keys)
+    collectFbdVisibleKeys(state, makeKey, addLeavesWithPrefix, keys, currentPou.interface?.variables ?? [])
   } else if (language === 'st' || language === 'il') {
     collectStIlVisibleKeys(currentPou, makeKey, addLeavesWithPrefix, keys)
   }
@@ -357,6 +357,7 @@ function collectLdVisibleKeys(
   makeKey: (name: string) => string | null,
   addLeavesWithPrefix: (prefix: string) => void,
   keys: Set<string>,
+  variables: readonly PLCVariable[],
 ): void {
   const editorName = state.editor.meta.name
   const currentFlow = state.ladderFlows.find((f) => f.name === editorName)
@@ -364,7 +365,16 @@ function collectLdVisibleKeys(
 
   for (const rung of currentFlow.rungs) {
     for (const node of rung.nodes) {
-      if (node.type === 'contact' || node.type === 'coil') {
+      if (node.type === 'execute') {
+        // An Execute box references variables in its ST text rather than
+        // binding one, so scan the snippet the same way a textual POU
+        // body is scanned. Skipping this leaves its inline debug badges
+        // showing `?` forever.
+        const code = (node.data as { code?: string }).code
+        if (typeof code === 'string' && code !== '') {
+          collectKeysFromSourceText(code, variables, makeKey, addLeavesWithPrefix, keys)
+        }
+      } else if (node.type === 'contact' || node.type === 'coil') {
         const nodeData = node.data as { variable?: { name?: string } }
         const varName = nodeData.variable?.name
         if (varName) {
@@ -393,13 +403,20 @@ function collectFbdVisibleKeys(
   makeKey: (name: string) => string | null,
   addLeavesWithPrefix: (prefix: string) => void,
   keys: Set<string>,
+  variables: readonly PLCVariable[],
 ): 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') {
+    if (node.type === 'execute') {
+      // Same as LD — see `collectLdVisibleKeys`.
+      const code = (node.data as { code?: string }).code
+      if (typeof code === 'string' && code !== '') {
+        collectKeysFromSourceText(code, variables, makeKey, addLeavesWithPrefix, keys)
+      }
+    } else 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) {
@@ -463,8 +480,26 @@ function collectStIlVisibleKeys(
   const sourceText = typeof currentPou.body.value === 'string' ? currentPou.body.value : ''
   if (!sourceText) return
 
-  const variables = currentPou.interface?.variables ?? []
+  collectKeysFromSourceText(sourceText, currentPou.interface?.variables ?? [], makeKey, addLeavesWithPrefix, keys)
+}
 
+/**
+ * Collect composite keys for every declared variable that appears in a
+ * chunk of ST/IL source text.
+ *
+ * Shared by two callers with the same need but different sources: a
+ * textual POU's whole body, and the snippet inside an Execute ("ST
+ * Block") element on a graphical diagram. Without this, an Execute
+ * box's inline debug badges would render `?` forever — the poller
+ * simply would not know those variables were on screen.
+ */
+export function collectKeysFromSourceText(
+  sourceText: string,
+  variables: readonly PLCVariable[],
+  makeKey: (name: string) => string | null,
+  addLeavesWithPrefix: (prefix: string) => void,
+  keys: Set<string>,
+): void {
   for (const v of variables) {
     // Escape regex special characters in variable name
     const escaped = v.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
diff --git a/src/main/menu.ts b/src/main/menu.ts
index 6018fc8de..265c13e7e 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -98,6 +98,10 @@ export default class MenuBuilder {
     this.mainWindow.webContents.send('compiler:export-project-request', xmlFormatTarget)
   }
 
+  handleImportProjectRequest() {
+    this.mainWindow.webContents.send('project:import-plcopen-request')
+  }
+
   async handleGetRecent() {
     const response = await this.projectService.readProjectHistory(this.projectService.getHistoryProjectsFilePath())
     return response
@@ -260,6 +264,10 @@ export default class MenuBuilder {
           label: i18n.t('menu:file.submenu.exportToCodesysXml'),
           click: () => this.handleExportProjectRequest('codesys'),
         },
+        {
+          label: i18n.t('menu:file.submenu.importFromPLCOpenXml'),
+          click: () => this.handleImportProjectRequest(),
+        },
         { type: 'separator' },
         {
           label: i18n.t('menu:file.submenu.pageSetup'),
@@ -533,6 +541,10 @@ export default class MenuBuilder {
             label: i18n.t('menu:file.submenu.exportToCodesysXml'),
             click: () => this.handleExportProjectRequest('codesys'),
           },
+          {
+            label: i18n.t('menu:file.submenu.importFromPLCOpenXml'),
+            click: () => this.handleImportProjectRequest(),
+          },
           {
             type: 'separator',
           },
diff --git a/src/main/modules/ipc/renderer.ts b/src/main/modules/ipc/renderer.ts
index 9e709227d..a7cc93bf0 100644
--- a/src/main/modules/ipc/renderer.ts
+++ b/src/main/modules/ipc/renderer.ts
@@ -326,6 +326,7 @@ const rendererProcessBridge = {
       message: string
     }>,
   exportProjectRequest: (callback: IpcRendererCallbacks) => subscribe('compiler:export-project-request', callback),
+  importProjectRequest: (callback: IpcRendererCallbacks) => subscribe('project:import-plcopen-request', callback),
   generateCFilesRequest: (pathToStProgram: string, callback: (args: CompilerPortMessage) => void) => {
     const { port1: rendererProcessPort, port2: mainProcessPort } = new MessageChannel()
     ipcRenderer.postMessage('compiler:generate-c-files', pathToStProgram, [mainProcessPort])
diff --git a/src/middleware/adapters/editor/__tests__/accelerator-adapter.test.ts b/src/middleware/adapters/editor/__tests__/accelerator-adapter.test.ts
index e3b37b345..5cfb2f45e 100644
--- a/src/middleware/adapters/editor/__tests__/accelerator-adapter.test.ts
+++ b/src/middleware/adapters/editor/__tests__/accelerator-adapter.test.ts
@@ -48,6 +48,7 @@ beforeEach(() => {
     saveFileAccelerator: register('saveFile'),
     closeProjectAccelerator: register('closeProject'),
     exportProjectRequest: register('exportProject'),
+    importProjectRequest: register('importProject'),
     closeTabAccelerator: register('closeTab'),
     deleteFileAccelerator: register('deleteFile'),
     findInProjectAccelerator: register('findInProject'),
@@ -102,7 +103,6 @@ testAccelerator('onOpenProject', 'openProject', 'handleOpenProjectRequest')
 testAccelerator('onSaveProject', 'saveProject', 'saveProjectAccelerator')
 testAccelerator('onSaveFile', 'saveFile', 'saveFileAccelerator')
 testAccelerator('onCloseProject', 'closeProject', 'closeProjectAccelerator')
-testAccelerator('onExportProject', 'exportProject', 'exportProjectRequest')
 testAccelerator('onCloseTab', 'closeTab', 'closeTabAccelerator')
 testAccelerator('onDeleteFile', 'deleteFile', 'deleteFileAccelerator')
 testAccelerator('onFindInProject', 'findInProject', 'findInProjectAccelerator')
@@ -111,6 +111,52 @@ testAccelerator('onRedo', 'redo', 'handleRedoRequest')
 testAccelerator('onSwitchPerspective', 'switchPerspective', 'switchPerspective')
 testAccelerator('onAbout', 'about', 'aboutModalAccelerator')
 testAccelerator('onQuitApp', 'quitApp', 'quitAppRequest')
+testAccelerator('onImportProject', 'importProject', 'importProjectRequest')
+
+describe('onExportProject', () => {
+  // Regression: the adapter used to swallow the IPC argument
+  // (`() => callback()`), so "Export to CODESYS XML" silently produced
+  // old-editor XML. The two menu items drive two genuinely different
+  // generators, so the dialect has to survive the trip.
+  it('forwards the codesys dialect the menu asked for', () => {
+    const cb = jest.fn()
+    adapter.onExportProject(cb)
+
+    fire('exportProject', {}, 'codesys')
+
+    expect(cb).toHaveBeenCalledWith('codesys')
+  })
+
+  it('forwards the old-editor dialect', () => {
+    const cb = jest.fn()
+    adapter.onExportProject(cb)
+
+    fire('exportProject', {}, 'old-editor')
+
+    expect(cb).toHaveBeenCalledWith('old-editor')
+  })
+
+  it('falls back to old-editor for an unrecognised or absent dialect', () => {
+    const cb = jest.fn()
+    adapter.onExportProject(cb)
+
+    fire('exportProject', {}, undefined)
+    fire('exportProject', {}, 'something-else')
+
+    expect(cb).toHaveBeenNthCalledWith(1, 'old-editor')
+    expect(cb).toHaveBeenNthCalledWith(2, 'old-editor')
+  })
+
+  it('returns an unsubscribe function that deactivates the callback', () => {
+    const cb = jest.fn()
+    const unsub = adapter.onExportProject(cb)
+
+    unsub()
+    fireIfRegistered('exportProject', {}, 'codesys')
+
+    expect(cb).not.toHaveBeenCalled()
+  })
+})
 
 describe('onOpenRecent', () => {
   it('registers a bridge listener and passes response data to the callback', () => {
diff --git a/src/middleware/adapters/editor/accelerator-adapter.ts b/src/middleware/adapters/editor/accelerator-adapter.ts
index 6b14ca875..f30250b12 100644
--- a/src/middleware/adapters/editor/accelerator-adapter.ts
+++ b/src/middleware/adapters/editor/accelerator-adapter.ts
@@ -62,8 +62,14 @@ export function createEditorAcceleratorAdapter(): AcceleratorPort {
       return window.bridge.closeProjectAccelerator(() => callback())
     },
 
-    onExportProject(callback: () => void): Unsubscribe {
-      return window.bridge.exportProjectRequest(() => callback())
+    onExportProject(callback: (format?: 'old-editor' | 'codesys') => void): Unsubscribe {
+      return window.bridge.exportProjectRequest((_event: unknown, format: unknown) =>
+        callback(format === 'codesys' ? 'codesys' : 'old-editor'),
+      )
+    },
+
+    onImportProject(callback: () => void): Unsubscribe {
+      return window.bridge.importProjectRequest(() => callback())
     },
 
     onCloseTab(callback: () => void): Unsubscribe {
diff --git a/src/middleware/shared/ports/accelerator-port.ts b/src/middleware/shared/ports/accelerator-port.ts
index b35474865..ae2d01007 100644
--- a/src/middleware/shared/ports/accelerator-port.ts
+++ b/src/middleware/shared/ports/accelerator-port.ts
@@ -46,7 +46,20 @@ export interface AcceleratorPort {
   onSaveProjectAs(callback: () => void): Unsubscribe
   onSaveFile(callback: () => void): Unsubscribe
   onCloseProject(callback: () => void): Unsubscribe
-  onExportProject(callback: () => void): Unsubscribe
+  /**
+   * File → "Export to PLCOpen XML" / "Export to CODESYS XML".
+   *
+   * The two menu items drive two different generators, so the chosen dialect
+   * has to reach the renderer. Optional, so a platform with a single export
+   * path can still implement a no-arg callback.
+   */
+  onExportProject(callback: (format?: 'old-editor' | 'codesys') => void): Unsubscribe
+  /**
+   * File → "Import PLCopen XML". The handler opens the confirm-overwrite modal
+   * rather than importing straight away, since an import replaces the open
+   * project's contents.
+   */
+  onImportProject(callback: () => void): Unsubscribe
 
   // --- Editor actions ---
   onCloseTab(callback: () => void): Unsubscribe