Platform

Compose & Execute Modes

Compose and Execute Modes


Table of Contents

 

Compose and Execute Modes Overview

The Logic Mapper provides two distinct working modes: Compose mode and Execute mode. Each mode supports a different stage of the recipe lifecycle, from authoring workflows to validating them through safe execution.

Compose mode focuses on building and configuring the saved recipe definition. Execute mode focuses on running, testing, and iterating on a recipe while tracking detected changes. Switching between modes supports iteration without altering the saved recipe unless changes are explicitly applied via Preserve Changes. The active mode is always visible in the interface, indicating whether the workflow is being authored or executed.

 

Compose Mode

Compose mode is the primary environment for building and editing recipes. It supports assembling workflows by adding, configuring, and connecting widgets, defining logic and data transformations, and organizing the recipe on the Logic Mapper canvas.


Features and Capabilities

  • Adding and configuring widgets
    Widgets are added from the top toolbar and placed on the canvas. Widget settings define how inputs are processed and outputs are produced. Ports connect widgets to define the data path across the recipe, and widgets can be repositioned to organize the layout.

  • Add catalog (widgets and services)
    The Add catalog provides a searchable entry point for inserting components into the Logic Mapper. The catalog includes:
    • Widgets: core canvas building blocks added and connected through ports to define the workflow structure
    • Hub Services: service-backed integrations added from the same catalog, which may require configuration before they can run

Widgets And Services


  • Recipe persistence
    Recipe state can be saved to the cloud or exported as a local file.

  • Widget context menu (right-click on a widget or selection)

    • Copy: Copies the selected widget(s) to the clipboard for reuse on the canvas
    • Cut: Removes the selected widget(s) from the canvas (and the current flow). The selection can be inserted elsewhere using Paste
    • Create Snippet: Packages the selected widget(s) into a reusable snippet and opens the snippet metadata modal (icon, title, short description, category, tags, visibility, optional URL)
    • Group Widgets: Wraps a multi-selection into a single Group node, preserving internal widgets and their connections
    • Disable: Disables the selected widget
    • Duplicate: Adds a copy of the selected widget(s) on the canvas
    • Remove Selected: Deletes the selected widget(s) from the recipe

Widget Context Menu


  • Canvas context menu (right-click on the canvas)

    • Add Widget or Service: Opens the Add catalog from the canvas
    • Paste: Inserts the most recently copied/cut widget(s) onto the canvas
    • Create custom widget: Defines a reusable widget by encapsulating one or more widgets into a single component with its own ports and settings
    • Create API integration: Opens a prompt-based modal that generates an integration script widget based on the provided description

Canvas Context Menu


  • Supporting panels (settings) to support building and validating workflows

    • Port Inspector
    • Debugging Panel
    • Show Event Animation
    • Status Panel
    • Global Variables Panel
    • Show Success Tick
    • Remove Background Pattern
    • Hide Port Labels

Settings Panel


  • Widget Behavior
    • Widget settings define how each widget processes inputs and produces outputs
    • Port connections define the data path across the workflow
    • Edits are persistent unless manually reverted or overwritten by a later saved state

 

Execute Mode

Execute mode runs recipes for testing and validation, with live outputs displayed on the canvas. It supports controlled experimentation with runtime and configuration changes without automatically applying those changes back to Compose mode.


Features and Capabilities

  • Runs the recipe and displays live results across connected widgets
  • Supports widget interaction during execution
  • Allows widget configuration changes during testing
  • Highlights detected widget changes during execution, including updates caused by movement or configuration changes
  • Applies selected Execute-mode changes back to Compose mode via Preserve Changes
    • Changes can be preserved per widget or across multiple selected widgets
  • Creates snippets from selected widgets
    • Snippets remain available under Kemu Snippets across modes

  • Limitations and Restrictions

    • Changes made in Execute mode are not applied to Compose mode by default; when leaving Execute mode, a confirmation dialog warns that detected changes will be lost
    • Changes are carried back to Compose mode only when explicitly preserved (per widget or via multi-selection)
    • Creating a Custom Widget or API Integration in Execute mode does not persist to Compose mode unless changes are preserved
    • Values edited in the Global Variables Panel persist across mode switching; changes made in Execute remain visible after returning to Compose
    • Widgets (including their current configuration) can be copied in Execute mode and pasted into Compose mode. This allows transferring specific changes without using Preserve Changes.

  • Widget Behavior

    • Widgets execute and produce real outputs based on current inputs and connections
    • Widget interactions during execution can affect downstream outputs, depending on the workflow design
    • Visual change tracking helps identify which widgets were modified during testing

  • Performance Benefits

    • Supports faster iteration cycles for validation and experimentation
    • Supports repeated test-and-adjust loops without requiring immediate permanent edits in Compose mode
    • Reduces rework by allowing validated, targeted changes from Execute mode to be preserved and brought back into Compose mode
    • Supports testing adjustments before deciding which changes should become part of the saved recipe

 

Modified Widgets Highlighting

Widgets modified during Execute mode are visually highlighted on the canvas to show detected changes.


  • Highlight indicators (Execute mode)

    • Orange outline (settings change): Shown when a widget’s configuration or displayed output/state changes during Execute mode. This can be triggered by direct edits on the widget or by changes propagated through the workflow.

    • Blue outline (positional change): Shown when a widget is moved to a new position on the Logic Mapper canvas during Execute mode.

  • Highlight priority

    • If a widget has a detected settings/state change (orange outline) and is later repositioned, the widget remains highlighted as orange. The positional highlight (blue outline) is shown only for widgets that were moved without an existing settings/state change.

Execute Highlighting

 

Preserving Changes

Changes made during testing in Execute mode can be kept and applied back to the recipe in Compose mode using Preserve Changes.


  • Preserve Changes workflow
    1. Make changes during Execute mode (e.g., configuration updates or canvas repositioning).
    2. Select one or more modified widgets.
    3. Right-click the selection and choose Preserve Changes.

    Note — Once changes are preserved, the modified-state highlighting clears for the preserved widgets.

    1. Switch back to Compose mode.
    2. The preserved widget changes are then reflected in the recipe.

Preserving Changes


  • Decision guide: preserve vs discard
    • Preserve changes when the adjustments made during testing are confirmed and should become part of the recipe (whether a single fix or a larger refactor). Discard changes when modifications are exploratory, temporary, or used only to validate behavior during a test run. This flow allows selective adoption of Execute-mode changes, from small widget updates to larger workflow adjustments.

 

Switching Between Modes

The current mode is controlled through a two-option toggle at the top of the Logic Mapper. The active mode is highlighted in blue, making it easy to identify whether the workflow is currently in Compose or Execute. Switching to Execute also displays a notice that changes made during testing will not carry back to Compose unless they are preserved.

Active Mode


Mode transition behavior

  • Switching to Execute mode enables safe testing.
  • Switching back to Compose mode discards all temporary changes unless they were explicitly preserved.
  • The Changes Detected confirmation dialog is shown only when unpreserved changes remain in the workflow. If all detected changes were preserved, switching back to Compose mode proceeds without the dialog.
  • The design supports experimentation while keeping the saved recipe intact.

Changes Detected

 

Error Handling

Errors are reported consistently in both Compose mode and Execute mode.

When a widget or service fails during execution, the affected widget displays a red alert indicator (exclamation icon). A corresponding on-screen alert card also appears to surface the failure and indicate where the failure occurred in the workflow.

Error Handling

 

Use Cases and Examples

When to Use Compose mode

  • Building a recipe from scratch
  • Structuring widget connections
  • Defining final configurations
  • Preparing a workflow for testing

When to Use Execute mode

  • Testing logic and runtime behavior
  • Validating transformations with live outputs
  • Inspecting outputs during execution
  • Fine-tuning widget parameters during testing

Example Scenarios

  • Testing different values before committing a configuration change
  • Adjusting widget settings based on observed output
  • Preserving a validated change discovered during testing


Example — Image Convolution Tuning (Compose → Execute → Preserve Changes)

This example uses a simple image pipeline to show how Compose and Execute modes support iterative tuning and selective promotion of changes back to the saved recipe.


Drag the example onto the workspace to explore and experiment!



In this example

Phase 1 — Compose baseline (authoring + initial validation)

  • Pipeline: Drop Images Service → Convolution Filter Widget (default matrix) → Display Widget.
  • Key behavior
    • The recipe definition is maintained in Compose and can be executed to establish a baseline output before tuning.
    • Visual changes reflect configuration updates to the pipeline (filter matrix and display sizing).
  • Step flow
    • An image is loaded through the Drop Images Service, then the workflow is executed to preview the default output produced by the Convolution Filter Widget.
    • The Display Widget is resized to improve inspection of the rendered result.
    • The convolution matrix is updated to produce a brighter/sharper rendering, and the workflow is executed again to confirm the visual change.
    • The resulting image is downloaded from the Display Widget for reuse during Execute-mode experimentation.

Phase 2 — Execute iteration (tuning + tracked changes)

  • Key behavior
    • Execute mode supports live experimentation while tracking detected workflow edits.
    • Detected changes are highlighted on the canvas:
      • Settings/state changes appear with an orange outline.
      • Pure repositioning appears with a blue outline when no settings/state change is already present.
  • Step flow
    • A Resize Image Widget is introduced into the pipeline and configured to resize the output to 400×400.
    • A layout adjustment is made by repositioning a widget, producing a blue outline to indicate a positional change.
    • The downloaded image is loaded again via the Drop Images Service, and the convolution matrix is updated to an edge-detection configuration to produce a dark background with emphasized edges.
    • The workflow is executed to validate both the visual result (edge detection) and the dimension change (225×225 → 400×400).

Phase 3 — Preserve Changes (promoting updates to Compose)

  • Key behavior
    • Preserve Changes supports multi-selection and applies selected Execute-mode changes back to the saved recipe.
    • Once changes are preserved, the modified-state highlighting clears for the preserved widgets.
    • When all detected changes are preserved, switching back to Compose proceeds without the Changes Detected dialog.
  • Step flow
    • The modified widgets (Drop Images Service, Resize Image Widget, Convolution Filter Widget) are selected together, and the context menu is used to apply Preserve Changes.
    • After preservation, the selection no longer shows modified-state highlighting, indicating the changes have been committed.
    • Switching back to Compose reflects the preserved Execute changes in the recipe definition.

 

Advanced Example — PDF Conversion Workflow (Compose → Execute → Preserve Changes)

This example demonstrates a practical Compose/Execute iteration loop using a PDF-to-Markdown pipeline. It highlights how the recipe is authored in Compose, tested and extended in Execute, and selectively promoted back to Compose via Preserve Changes.


Drag the example onto the workspace to explore and experiment!



In this example

Phase 1 — Compose baseline (authoring + panels + initial output)

  • Pipeline: Button Widget → Global Variable Widget (BinaryFile) → PDF To Markdown Service → Markdown To Object Widget → Text Widget.

  • Key behavior

    • Compose mode is used to assemble and configure the saved recipe definition without modification tracking highlights.
    • The Global Variables Panel is enabled from Logic Mapper Settings to provide file-based inputs (BinaryFile) to the workflow.
    • Running the workflow produces Markdown output rendered in the Text Widget.

  • Step flow

    • The PDF To Markdown Service and supporting widgets are added, positioned, and connected to form the pipeline.
    • Logic Mapper Settings is used to enable the Global Variables Panel.
    • A BinaryFile variable (e.g., Pdf1 (BinaryFile)) is created in the Global Variables Panel, and a PDF is uploaded and assigned to the variable.
    • The workflow is triggered via the Button Widget, and the Text Widget displays the converted Markdown output.
    • The recipe is saved as part of the Compose workflow (cloud save).

Phase 2 — Execute iteration (switching + highlighting + extending the recipe)

  • Key behavior

    • Switching to Execute preserves the visual layout and current recipe state, then enables controlled experimentation.
    • Detected changes are highlighted during Execute mode:
      • Settings/state changes appear with an orange outline.
      • Positional-only changes appear with a blue outline (when no settings/state change is already present).
    • Execute mode supports extending the workflow by adding new widgets/services for validation before committing changes back to Compose.

  • Step flow

    • The mode switch is used to enter Execute mode, where a banner indicates that changes made in Execute are not preserved when switching back (unless explicitly preserved).
    • Widgets are repositioned to refine the layout, producing a blue outline on repositioned widgets.
    • The Text Widget is resized and its content is cleared; the widget outline changes to orange, reflecting a settings/state modification (and taking priority over positional highlighting).
    • A write-to-disk branch is introduced by adding:
    • Newly added widgets/services appear with orange outlines, reflecting detected changes introduced during Execute mode.

Phase 3 — Grouping (simplifying the canvas during testing)

  • Key behavior
    • Execute mode supports grouping widgets to reduce visual complexity while preserving internal logic.
  • Step flow
    • The Array Item Widget and Sequence Widget are grouped into a single Group Widget, simplifying the view while maintaining the same connections and behavior.

Phase 4 — Configuration changes, alternate inputs, and error validation

  • Key behavior

    • Workflow configuration changes in Execute mode are tracked and can be validated immediately through execution.
    • Errors are surfaced consistently via a red alert indicator on the affected widget/service and can be inspected (e.g., via hover details).

  • Step flow

    • The Write Contents Service is configured (path/destination) via its settings to write the Markdown file to disk.
    • A second PDF variable (e.g., Pdf2 (BinaryFile)) is created in the Global Variables Panel, and the workflow input is switched to validate the pipeline with a different document.
    • The workflow is executed; an error is surfaced in the write step, showing the red alert indicator and error details on inspection.
    • The write configuration is adjusted and the workflow is executed again until the Display Widget confirms success (e.g., TRUE).

Phase 5 — Preserve Changes (selective promotion back to Compose)

  • Key behavior

    • Preserve Changes supports multi-selection and selectively applies Execute-mode changes back to the saved recipe definition in Compose.
    • Once preserved, the modified-state highlighting clears for the preserved widgets.
    • The Changes Detected dialog appears only when unpreserved changes remain at the time of switching to Compose mode.

  • Step flow

    • All modified widgets are selected except the Display Widget, then Preserve Changes is applied from the context menu.
    • Preserved widgets clear their highlighting, while the unpreserved Display Widget remains highlighted.
    • Switching back to Compose triggers the Changes Detected dialog because an unpreserved change remains (the Display Widget).
    • After exiting Execute mode, Compose reflects only the preserved changes: the Group Widget, the write branch configuration, and the updated global variable selection remain, while the unpreserved Display Widget does not carry over.
    • Back in Compose mode, the Text Widget content is cleared and the workflow is executed again to confirm the preserved updates run successfully in the saved recipe definition.