### Compile and Package 4DIAC IDE with Maven

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use Maven to compile and package the 4DIAC IDE. The 'install' command performs a full build, generating platform-specific packages. Use the '-P nightly' profile for custom branding and '-Dtycho.surefire.skip=true' to skip UI tests.

```bash
# Full build (generates platform-specific packages for Linux, Windows, macOS)
mvn install

# Output artifacts location:
# plugins/org.eclipse.fordiac.ide.product/target/
#   products/org.eclipse.fordiac.ide.product-linux.gtk.x86_64.tar.gz
#   products/org.eclipse.fordiac.ide.product-win32.win32.x86_64.zip
#   products/org.eclipse.fordiac.ide.product-macosx.cocoa.x86_64.tar.gz

# Build with nightly profile (changes splash screen / branding)
mvn install -P nightly

# Run only unit tests
mvn test

# Skip UI tests (faster builds)
mvn install -Dtycho.surefire.skip=true
```

--------------------------------

### CreateApplicationCommand

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Adds a new application, including an empty FBNetwork, to an existing AutomationSystem. This command is undoable.

```APIDOC
## Command-Based Model Editing

### `CreateApplicationCommand` — Add an application to an automation system

All model mutations in 4diac IDE are performed through undoable GEF commands. `CreateApplicationCommand` creates a new `Application` (with an empty `FBNetwork`) and adds it to the `AutomationSystem`.

```java
import org.eclipse.fordiac.ide.model.commands.create.CreateApplicationCommand;
import org.eclipse.fordiac.ide.model.libraryElement.AutomationSystem;
import org.eclipse.gef.commands.CommandStack;

AutomationSystem system = ...; // loaded from a .sys file via TypeLibrary
CommandStack stack = editor.getCommandStack();

// Create and execute the command (supports undo/redo)
CreateApplicationCommand cmd = new CreateApplicationCommand(system, "ConveyorApp");
stack.execute(cmd);

// Retrieve the created application
var app = cmd.getCreatedElement(); // Application
System.out.println(app.getName()); // "ConveyorApp" (or auto-suffixed for uniqueness)

// Undo support
stack.undo(); // removes the application
stack.redo(); // re-adds it
```
```

--------------------------------

### Add Application to Automation System

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use `CreateApplicationCommand` to add a new `Application` with an empty `FBNetwork` to an `AutomationSystem`. This command supports undo/redo operations via the `CommandStack`.

```java
import org.eclipse.fordiac.ide.model.commands.create.CreateApplicationCommand;
import org.eclipse.fordiac.ide.model.libraryElement.AutomationSystem;
import org.eclipse.gef.commands.CommandStack;

AutomationSystem system = ...; // loaded from a .sys file via TypeLibrary
CommandStack stack = editor.getCommandStack();

// Create and execute the command (supports undo/redo)
CreateApplicationCommand cmd = new CreateApplicationCommand(system, "ConveyorApp");
stack.execute(cmd);

// Retrieve the created application
var app = cmd.getCreatedElement(); // Application
System.out.println(app.getName()); // "ConveyorApp" (or auto-suffixed for uniqueness)

// Undo support
stack.undo(); // removes the application
stack.redo(); // re-adds it
```

--------------------------------

### FBCreateCommand

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Instantiates a function block of a specified type within an FBNetwork at given coordinates. This command is executable only if conditions are met.

```APIDOC
### `FBCreateCommand` — Instantiate a function block in an FB network

Creates a new FB instance of a given type within an `FBNetwork`, positioned at specified (x, y) coordinates.

```java
import org.eclipse.fordiac.ide.model.commands.create.FBCreateCommand;
import org.eclipse.fordiac.ide.model.libraryElement.FBNetwork;
import org.eclipse.fordiac.ide.model.typelibrary.FBTypeEntry;
import org.eclipse.fordiac.ide.model.typelibrary.TypeLibrary;
import org.eclipse.fordiac.ide.model.typelibrary.TypeLibraryManager;

IProject project = ...; // open 4diac project
TypeLibrary typeLib = TypeLibraryManager.INSTANCE.getTypeLibrary(project);

// Look up an FB type entry from the type library (e.g., a BasicFB "E_CYCLE")
FBTypeEntry entry = (FBTypeEntry) typeLib.getTypeEntry("E_CYCLE");

FBNetwork network = application.getFBNetwork();

// Place the FB instance at canvas position (100, 200)
FBCreateCommand cmd = new FBCreateCommand(entry, network, 100, 200);

if (cmd.canExecute()) {
    commandStack.execute(cmd);
    var fb = cmd.getFB();
    System.out.println(fb.getName());         // auto-generated, e.g. "E_CYCLE"
    System.out.println(fb.getTypeName());     // "E_CYCLE"
}
```
```

--------------------------------

### Create Event and Data Connections between FB Instances

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use EventConnectionCreateCommand and DataConnectionCreateCommand to wire interface elements of Function Block instances within an FBNetwork. Ensure full constraint validation is performed before execution.

```java
import org.eclipse.fordiac.ide.model.commands.create.EventConnectionCreateCommand;
import org.eclipse.fordiac.ide.model.commands.create.DataConnectionCreateCommand;
import org.eclipse.fordiac.ide.model.libraryElement.FBNetwork;
import org.eclipse.fordiac.ide.model.libraryElement.IInterfaceElement;

FBNetwork network = application.getFBNetwork();

// Retrieve interface elements (events and data pins) from instantiated FBs
IInterfaceElement eo   = cycleTimer.getInterface().getEventOutputs().get(0); // "EO" output of E_CYCLE
IInterfaceElement eiIn = sensorBlock.getInterface().getEventInputs().get(0); // "REQ" input

// Create an event connection: E_CYCLE.EO -> SensorBlock.REQ
EventConnectionCreateCommand evtCmd = new EventConnectionCreateCommand(network);
evtCmd.setSource(eo);
evtCmd.setDestination(eiIn);

if (evtCmd.canExecute()) {
    commandStack.execute(evtCmd);
}

// Wire data: SensorBlock.OUT -> ProcessingFB.IN
IInterfaceElement dataOut = sensorBlock.getInterface().getOutputVars().get(0);
IInterfaceElement dataIn  = processingFB.getInterface().getInputVars().get(0);

DataConnectionCreateCommand dataCmd = new DataConnectionCreateCommand(network);
dataCmd.setSource(dataOut);
dataCmd.setDestination(dataIn);
commandStack.execute(dataCmd);
```

--------------------------------

### Build 4diac IDE with Maven

Source: https://github.com/eclipse-4diac/4diac-ide/blob/develop/README.md

Run this command in the root directory of the 4diac IDE source code to build the project. The packages will be located in the plugins/org.eclipse.fordiac.ide.product/target directory after a successful build.

```bash
mvn install
```

--------------------------------

### Perform Batch Deployment with DeploymentCoordinator

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use DeploymentCoordinator.performDeployment for high-level batch deployment of Devices or Resources with a progress dialog. Alternatively, use createDeploymentdata to build deployment data programmatically.

```java
import org.eclipse.fordiac.ide.deployment.DeploymentCoordinator;
import org.eclipse.fordiac.ide.model.libraryElement.Device;
import java.util.List;

// Deploy an entire device (all its resources)
Device device = system.getSystemConfiguration().getDevices().get(0);
Object[] selection = new Object[] { device };

// Performs deployment with progress UI; overrideHandler=null uses device profile
DeploymentCoordinator.performDeployment(selection, null, "");

// Or build deployment data manually for programmatic use
var deploymentData = DeploymentCoordinator.createDeploymentdata(selection);
// deploymentData is List<DeviceDeploymentData> with resolved resources and parameters
```

--------------------------------

### Batch Export FBs to FORTE C++ Source with Ant Tasks

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

These Ant tasks facilitate batch exporting of FB types to FORTE C++ source. exportProjectFBs exports all FBs, exportFolderFBs exports from a specific folder, and exportSingleFB exports a single named FB. The exportCMakeList flag can generate CMakeLists.txt files.

```xml
<taskdef name="exportProjectFBs"
         classname="org.eclipse.fordiac.ide.ant.ant.ExportProjectFBs"
         classpathref="ant.classpath"/>

<taskdef name="exportFolderFBs"
         classname="org.eclipse.fordiac.ide.ant.ant.ExportFolderFBs"
         classpathref="ant.classpath"/>

<taskdef name="exportSingleFB"
         classname="org.eclipse.fordiac.ide.ant.ant.ExportSingleFB"
         classpathref="ant.classpath"/>

<target name="export-all">
    <!-- Export all FBs in the project; skip generated folders -->
    <exportProjectFBs
        fordiacProject="BottlingLine"
        exportDirectory="/build/forte_src"
        exportCMakeList="true"
        excludeSubfolder="test,examples"/>
</target>

<target name="export-folder">
    <!-- Export FBs from a specific library folder -->
    <exportFolderFBs
        fordiacProject="BottlingLine"
        folderName="ConveyorTypes"
        exportDirectory="/build/forte_src/conveyor"
        exportCMakeList="true"/>
</target>

<target name="export-single">
    <!-- Export a single named FB type -->
    <exportSingleFB
        fordiacProject="BottlingLine"
        fbName="ConveyorControl"
        exportDirectory="/build/forte_src/single"/>
</target>
```

--------------------------------

### Deploy and Manage Devices using IDeviceManagementInteractor

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Interact with an IEC 61499 device's management functions using IDeviceManagementInteractor. Implementations are available for Ethernet and OPC UA. Ensure proper error handling with DeploymentException.

```java
import org.eclipse.fordiac.ide.deployment.interactors.IDeviceManagementInteractor;
import org.eclipse.fordiac.ide.deployment.interactors.DeviceManagementInteractorFactory;
import org.eclipse.fordiac.ide.deployment.data.FBDeploymentData;
import org.eclipse.fordiac.ide.deployment.data.ConnectionDeploymentData;
import org.eclipse.fordiac.ide.deployment.exceptions.DeploymentException;
import org.eclipse.fordiac.ide.model.libraryElement.Device;
import org.eclipse.fordiac.ide.model.libraryElement.Resource;

Device device   = system.getSystemConfiguration().getDevices().get(0);
Resource res    = device.getResource().get(0);

IDeviceManagementInteractor interactor =
    DeviceManagementInteractorFactory.INSTANCE.getInteractor(device);

try {
    // Connect to device
    interactor.connect();

    // Create a resource on the device
    interactor.createResource(res);

    // Write a device parameter (e.g. MGR_ID / port)
    interactor.writeDeviceParameter(device, "MGR_ID", "192.168.1.10:61499");

    // Deploy an FB instance
    FBDeploymentData fbData = new FBDeploymentData("", fbNetworkElement);
    interactor.createFBInstance(fbData, res);

    // Configure an FB parameter
    interactor.writeFBParameter(res, "E_CYCLE.DT#500ms");

    // Wire connections
    interactor.createConnection(res, connectionDeploymentData);

    // Start the resource (begins execution)
    interactor.startResource(res);

    // Monitor: add a watch on a data pin
    boolean added = interactor.addWatch(res, "E_CYCLE.DT");

    // Read current watch values
    var response = interactor.readWatches();

    // Force a value for testing
    interactor.forceValue(res, "SensorFB.IN", "42");
    interactor.clearForce(res, "SensorFB.IN");

    // Stop/kill/delete lifecycle
    interactor.stopResource(res);
    interactor.killResource(res.getName());
    interactor.deleteResource(res.getName());

} catch (DeploymentException e) {
    System.err.println("Deployment failed: " + e.getMessage());
} finally {
    interactor.disconnect();
}
```

--------------------------------

### Instantiate Function Block in FB Network

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use `FBCreateCommand` to instantiate a function block of a given type within an `FBNetwork` at specified coordinates. Ensure the command can be executed before performing the operation.

```java
import org.eclipse.fordiac.ide.model.commands.create.FBCreateCommand;
import org.eclipse.fordiac.ide.model.libraryElement.FBNetwork;
import org.eclipse.fordiac.ide.model.typelibrary.FBTypeEntry;
import org.eclipse.fordiac.ide.model.typelibrary.TypeLibrary;
import org.eclipse.fordiac.ide.model.typelibrary.TypeLibraryManager;

IProject project = ...; // open 4diac project
TypeLibrary typeLib = TypeLibraryManager.INSTANCE.getTypeLibrary(project);

// Look up an FB type entry from the type library (e.g., a BasicFB "E_CYCLE")
FBTypeEntry entry = (FBTypeEntry) typeLib.getTypeEntry("E_CYCLE");

FBNetwork network = application.getFBNetwork();

// Place the FB instance at canvas position (100, 200)
FBCreateCommand cmd = new FBCreateCommand(entry, network, 100, 200);

if (cmd.canExecute()) {
    commandStack.execute(cmd);
    var fb = cmd.getFB();
    System.out.println(fb.getName());         // auto-generated, e.g. "E_CYCLE"
    System.out.println(fb.getTypeName());     // "E_CYCLE"
}
```

--------------------------------

### SystemManager.createNew4diacProject

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Creates a new 4diac IDE project in the Eclipse workspace, setting up the necessary build configurations and standard virtual folders.

```APIDOC
## System Management

### `SystemManager.createNew4diacProject` — Create a new 4diac IDE project

Creates an Eclipse project with the 4diac project nature, sets up the required build pipeline (library builder, Xtext builder, export builder), and initializes the standard `Type Library`, `Standard Library`, and `External Library` virtual folders.

```java
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.fordiac.ide.systemmanagement.SystemManager;

// Create a new 4diac project in the Eclipse workspace
IPath location = new Path("/opt/my4diacProjects/BottlingLine");
IProject project = SystemManager.INSTANCE.createNew4diacProject(
    "BottlingLine",   // project name
    location,         // filesystem location (null = use workspace root)
    new NullProgressMonitor()
);

// Verify project nature
boolean is4diac = SystemManager.hasFordiacProjectNature(project);
// is4diac == true

// Validate the project's type library consistency
SystemManager.validateProjectNature(project);

// Useful constants
String natureId   = SystemManager.FORDIAC_PROJECT_NATURE_ID; // "org.eclipse.fordiac.ide.systemmanagement.FordiacNature"
String sysEnding  = SystemManager.SYSTEM_FILE_ENDING;         // "sys"

// Check if a workspace resource is a system file
boolean isSys = SystemManager.isSystemFile(project.getFile("BottlingLine.sys"));
```
```

--------------------------------

### Wire FB instances

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Connects two interface elements (event or data pins) in an FBNetwork with full constraint validation using `EventConnectionCreateCommand` and `DataConnectionCreateCommand`.

```APIDOC
## EventConnectionCreateCommand / DataConnectionCreateCommand — Wire FB instances

Connects two interface elements (event or data pins) in an `FBNetwork` with full constraint validation.

```java
import org.eclipse.fordiac.ide.model.commands.create.EventConnectionCreateCommand;
import org.eclipse.fordiac.ide.model.commands.create.DataConnectionCreateCommand;
import org.eclipse.fordiac.ide.model.libraryElement.FBNetwork;
import org.eclipse.fordiac.ide.model.libraryElement.IInterfaceElement;

FBNetwork network = application.getFBNetwork();

// Retrieve interface elements (events and data pins) from instantiated FBs
IInterfaceElement eo   = cycleTimer.getInterface().getEventOutputs().get(0); // "EO" output of E_CYCLE
IInterfaceElement eiIn = sensorBlock.getInterface().getEventInputs().get(0); // "REQ" input

// Create an event connection: E_CYCLE.EO -> SensorBlock.REQ
EventConnectionCreateCommand evtCmd = new EventConnectionCreateCommand(network);
evtCmd.setSource(eo);
evtCmd.setDestination(eiIn);

if (evtCmd.canExecute()) {
    commandStack.execute(evtCmd);
}

// Wire data: SensorBlock.OUT -> ProcessingFB.IN
IInterfaceElement dataOut = sensorBlock.getInterface().getOutputVars().get(0);
IInterfaceElement dataIn  = processingFB.getInterface().getInputVars().get(0);

DataConnectionCreateCommand dataCmd = new DataConnectionCreateCommand(network);
dataCmd.setSource(dataOut);
dataCmd.setDestination(dataIn);
commandStack.execute(dataCmd);
```
```

--------------------------------

### DeploymentCoordinator.performDeployment — High-level batch deployment

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Deploys a selection of `Device` or `Resource` objects using a progress dialog, automatically resolving deployment data from the system model.

```APIDOC
## DeploymentCoordinator.performDeployment — High-level batch deployment

Deploys a selection of `Device` or `Resource` objects using a progress dialog, automatically resolving deployment data from the system model.

```java
import org.eclipse.fordiac.ide.deployment.DeploymentCoordinator;
import org.eclipse.fordiac.ide.model.libraryElement.Device;
import java.util.List;

// Deploy an entire device (all its resources)
Device device = system.getSystemConfiguration().getDevices().get(0);
Object[] selection = new Object[] { device };

// Performs deployment with progress UI; overrideHandler=null uses device profile
DeploymentCoordinator.performDeployment(selection, null, "");

// Or build deployment data manually for programmatic use
var deploymentData = DeploymentCoordinator.createDeploymentdata(selection);
// deploymentData is List<DeviceDeploymentData> with resolved resources and parameters
```
```

--------------------------------

### Export FB Types as FORTE C++ Source with ForteNgExportFilter

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use ForteNgExportFilter to generate .h/.cpp files for FB types. Supports various FB types and structured types. Can infer type from file or use an explicit EMF source object. Overwrites existing files if forceOverwrite is true.

```java
import org.eclipse.fordiac.ide.export.forte_ng.ForteNgExportFilter;
import org.eclipse.fordiac.ide.export.ExportException;
import org.eclipse.core.resources.IFile;

// Obtain the .fbt file from the workspace
IFile fbtFile = project.getFile("Type Library/ConveyorControl.fbt");
String outputDirectory = "/tmp/forte_export/";

ForteNgExportFilter filter = new ForteNgExportFilter();

try {
    // Export using the file path; source=null infers type from file
    filter.export(fbtFile, outputDirectory, /* forceOverwrite */ true);

    // Check for warnings/errors
    filter.getWarnings().forEach(w -> System.out.println("WARN: " + w));
    filter.getErrors().forEach(e -> System.err.println("ERR: " + e));
    // On success: ConveyorControl.h and ConveyorControl.cpp written to outputDirectory

    // Export with explicit EMF source object
    BasicFBType fbType = (BasicFBType) fbTypeEntry.getType();
    filter.export(fbtFile, outputDirectory, true, fbType);

} catch (ExportException e) {
    System.err.println("Export failed: " + e.getMessage());
}
```

--------------------------------

### Create New 4diac Project

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Use `createNew4diacProject` to create a new Eclipse project with the 4diac nature. It initializes build pipelines and standard virtual folders. Verify the project nature and validate its type library consistency.

```java
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.fordiac.ide.systemmanagement.SystemManager;

// Create a new 4diac project in the Eclipse workspace
IPath location = new Path("/opt/my4diacProjects/BottlingLine");
IProject project = SystemManager.INSTANCE.createNew4diacProject(
    "BottlingLine",   // project name
    location,         // filesystem location (null = use workspace root)
    new NullProgressMonitor()
);

// Verify project nature
boolean is4diac = SystemManager.hasFordiacProjectNature(project);
// is4diac == true

// Validate the project's type library consistency
SystemManager.validateProjectNature(project);

// Useful constants
String natureId   = SystemManager.FORDIAC_PROJECT_NATURE_ID; // "org.eclipse.fordiac.ide.systemmanagement.FordiacNature"
String sysEnding  = SystemManager.SYSTEM_FILE_ENDING;         // "sys"

// Check if a workspace resource is a system file
boolean isSys = SystemManager.isSystemFile(project.getFile("BottlingLine.sys"));
```

--------------------------------

### Validate System File Headless with CheckSystem Ant Task

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

The CheckSystem Ant task performs a full build and checks for error markers on a .sys file. It throws a BuildException on validation failure, making it suitable for pre-deployment checks in CI environments.

```xml
<taskdef name="checkSystem"
         classname="org.eclipse.fordiac.ide.ant.ant.CheckSystem"
         classpathref="ant.classpath"/>

<target name="validate">
    <!-- systemPath is workspace-relative: /ProjectName/System.sys -->
    <checkSystem systemPath="/BottlingLine/BottlingLine.sys"/>
    <!-- Succeeds silently; fails with BuildException on any IMarker.SEVERITY_ERROR -->
</target>
```

--------------------------------

### Instantiate and Use Model Evaluator

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Create an evaluator for a BasicFBType to run function block logic within the IDE. Ensure to call prepare() before evaluate() and cleanup() afterwards. Custom evaluator factories can be registered for new source types.

```java
import org.eclipse.fordiac.ide.model.eval.EvaluatorFactory;
import org.eclipse.fordiac.ide.model.eval.Evaluator;
import org.eclipse.fordiac.ide.model.eval.variable.Variable;
import org.eclipse.fordiac.ide.model.eval.value.Value;
import org.eclipse.fordiac.ide.model.libraryElement.BasicFBType;
import java.util.Collections;

BasicFBType fbType = (BasicFBType) typeEntry.getType();

// Create an evaluator for the FB type (uses registered factory for BasicFBType)
Evaluator evaluator = EvaluatorFactory.createEvaluator(
    fbType,
    BasicFBType.class,
    /* context variable */ null,
    /* initial variables */ Collections.emptyList(),
    /* parent evaluator */ null
);

if (evaluator != null) {
    try {
        evaluator.prepare();              // parse ST algorithms, resolve types

        Value result = evaluator.evaluate(); // execute the FB logic

        // Inspect variable state
        evaluator.getVariables().forEach((name, var) ->
            System.out.println(name + " = " + var.getValue()));

        evaluator.cleanup();             // release parsed resources
    } catch (Exception e) {
        System.err.println("Evaluation error: " + e.getMessage());
    }
}

// Register a custom evaluator factory for a new source type
EvaluatorFactory.Registry.INSTANCE.registerFactory(
    EvaluatorFactory.DEFAULT_VARIANT,
    MyCustomSource.class,
    (source, ctx, vars, parent) -> new MyCustomEvaluator(source, ctx, vars, parent)
);
```

--------------------------------

### IDeviceManagementInteractor — Deploy and manage devices

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

The central interface for interacting with an IEC 61499 device's management functions. Implementations are provided for Ethernet (IEC 61499 protocol) and OPC UA.

```APIDOC
## IDeviceManagementInteractor — Deploy and manage devices

The central interface for interacting with an IEC 61499 device's management functions. Implementations are provided for Ethernet (IEC 61499 protocol) and OPC UA.

```java
import org.eclipse.fordiac.ide.deployment.interactors.IDeviceManagementInteractor;
import org.eclipse.fordiac.ide.deployment.interactors.DeviceManagementInteractorFactory;
import org.eclipse.fordiac.ide.deployment.data.FBDeploymentData;
import org.eclipse.fordiac.ide.deployment.data.ConnectionDeploymentData;
import org.eclipse.fordiac.ide.deployment.exceptions.DeploymentException;
import org.eclipse.fordiac.ide.model.libraryElement.Device;
import org.eclipse.fordiac.ide.model.libraryElement.Resource;

Device device   = system.getSystemConfiguration().getDevices().get(0);
Resource res    = device.getResource().get(0);

IDeviceManagementInteractor interactor =
    DeviceManagementInteractorFactory.INSTANCE.getInteractor(device);

try {
    // Connect to device
    interactor.connect();

    // Create a resource on the device
    interactor.createResource(res);

    // Write a device parameter (e.g. MGR_ID / port)
    interactor.writeDeviceParameter(device, "MGR_ID", "192.168.1.10:61499");

    // Deploy an FB instance
    FBDeploymentData fbData = new FBDeploymentData("", fbNetworkElement);
    interactor.createFBInstance(fbData, res);

    // Configure an FB parameter
    interactor.writeFBParameter(res, "E_CYCLE.DT#500ms");

    // Wire connections
    interactor.createConnection(res, connectionDeploymentData);

    // Start the resource (begins execution)
    interactor.startResource(res);

    // Monitor: add a watch on a data pin
    boolean added = interactor.addWatch(res, "E_CYCLE.DT");

    // Read current watch values
    var response = interactor.readWatches();

    // Force a value for testing
    interactor.forceValue(res, "SensorFB.IN", "42");
    interactor.clearForce(res, "SensorFB.IN");

    // Stop/kill/delete lifecycle
    interactor.stopResource(res);
    interactor.killResource(res.getName());
    interactor.deleteResource(res.getName());

} catch (DeploymentException e) {
    System.err.println("Deployment failed: " + e.getMessage());
} finally {
    interactor.disconnect();
}
```
```

--------------------------------

### Access and Query FB Type Entries

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

Retrieve the type library for a project to access and query FB types, data types, and device types. Use getTypeEntry() to look up specific types by name or stream all entries.

```java
import org.eclipse.fordiac.ide.model.typelibrary.TypeLibraryManager;
import org.eclipse.fordiac.ide.model.typelibrary.TypeLibrary;
import org.eclipse.fordiac.ide.model.typelibrary.FBTypeEntry;

IProject project = ...; // open 4diac project

// Get (or load) the type library for a project
TypeLibrary typeLib = TypeLibraryManager.INSTANCE.getTypeLibrary(project);

// Look up a type entry by name
var entry = typeLib.getTypeEntry("ConveyorControl");
if (entry instanceof FBTypeEntry fbEntry) {
    var fbType = fbEntry.getType(); // BasicFBType, CompositeFBType, etc.
    System.out.println(fbType.eClass().getName()); // e.g. "BasicFBType"
}

// Stream all FB type entries
typeLib.getFBTypeEntries().forEach(e ->
    System.out.println(e.getTypeName() + " -> " + e.getFile().getFullPath())
);

// Access data types (IEC 61131-3 primitives + user-defined structs)
typeLib.getDataTypeLibrary().getDerivedDataTypes().forEach(dt ->
    System.out.println("STRUCT: " + dt.getName())
);
```

--------------------------------

### Import 4diac Project into Eclipse Workspace (Headless)

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

The Import4diacProject Ant task is used for loading a 4diac project into the Eclipse workspace, typically for CI/CD pipelines before further automation tasks.

```xml
<!-- build.xml – headless Eclipse Ant script -->
<taskdef name="import4diacProject"
         classname="org.eclipse.fordiac.ide.ant.ant.Import4diacProject"
         classpathref="ant.classpath"/>

<target name="import">
    <import4diacProject projectPath="/ci/workspace/BottlingLine"/>
</target>
```

--------------------------------

### Validate Type Library Headless with CheckTypeLibrary Ant Task

Source: https://context7.com/eclipse-4diac/4diac-ide/llms.txt

The CheckTypeLibrary Ant task validates all type library files within a project, reporting any errors or warnings to the Ant console. This is useful for ensuring the integrity of the type library in automated workflows.

```xml
<taskdef name="checkTypeLibrary"
         classname="org.eclipse.fordiac.ide.ant.ant.CheckTypeLibrary"
         classpathref="ant.classpath"/>

<target name="validate-lib">
    <checkTypeLibrary fordiacProject="BottlingLine"/>
</target>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.