From c195f842c8f63349043d6629b4de7065c183df5c Mon Sep 17 00:00:00 2001
From: Ruben van der Linde <ruben@conduction.nl>
Date: Sat, 23 May 2026 10:54:58 +0200
Subject: [PATCH 1/2] feat(rule-editor): extended JsonLogic ops + bespoke
 action forms (closes #877)

Visual condition leaf gains the remaining ops jwadhams/json-logic-php
supports: var, cat, +, -, *, /, %, substr, merge, map, filter, reduce,
all, none, some, if, missing. The picker now groups them
(comparison / arithmetic / string / array / control-flow / negation)
and renders the right input slots per op-kind (binary, unary, ternary,
if, array-op, merge, var-only). JSON slots get a textarea with parse
error feedback; literal slots keep the same coerce()-on-input path.

Per-action-type forms replace the JSON-textarea fallback for all 15
canonical rule action types. Each form lives at
src/views/Rule/actionForms/<Name>Form.vue and round-trips its slice of
`configuration[<type>]` via update:value. RuleActionConfig wires them
through ACTION_FORM_MAP; the JSON-textarea fallback stays for any
future action type without a bespoke form. Two outliers
(`mapping` writes to configuration.mapping bare id; `javascript`
writes to configuration.javascript bare string) are special-cased.

Also fixes the malformed `<nextcloud-app id="openregister">` line in
appinfo/info.xml (collateral from #895's canonicalize sweep) so
eslint can parse the project again.
---
 appinfo/info.xml                              |   2 +-
 src/views/Rule/RuleActionConfig.vue           | 275 +++++-------
 src/views/Rule/RuleConditionLeaf.vue          | 407 +++++++++++++++---
 .../Rule/actionForms/AuthenticationForm.vue   |  91 ++++
 src/views/Rule/actionForms/DownloadForm.vue   |  57 +++
 src/views/Rule/actionForms/ErrorForm.vue      |  76 ++++
 .../actionForms/ExtendExternalInputForm.vue   | 103 +++++
 .../Rule/actionForms/ExtendInputForm.vue      | 115 +++++
 src/views/Rule/actionForms/FetchFileForm.vue  | 182 ++++++++
 .../Rule/actionForms/FilepartUploadForm.vue   |  65 +++
 .../Rule/actionForms/FilepartsCreateForm.vue  |  90 ++++
 src/views/Rule/actionForms/JavascriptForm.vue |  49 +++
 src/views/Rule/actionForms/LockingForm.vue    |  74 ++++
 src/views/Rule/actionForms/MappingForm.vue    |  64 +++
 src/views/Rule/actionForms/SaveObjectForm.vue |  90 ++++
 .../Rule/actionForms/SynchronizationForm.vue  | 119 +++++
 src/views/Rule/actionForms/UploadForm.vue     |  62 +++
 src/views/Rule/actionForms/WriteFileForm.vue  |  59 +++
 src/views/Rule/actionForms/shared.js          |  80 ++++
 19 files changed, 1822 insertions(+), 238 deletions(-)
 create mode 100644 src/views/Rule/actionForms/AuthenticationForm.vue
 create mode 100644 src/views/Rule/actionForms/DownloadForm.vue
 create mode 100644 src/views/Rule/actionForms/ErrorForm.vue
 create mode 100644 src/views/Rule/actionForms/ExtendExternalInputForm.vue
 create mode 100644 src/views/Rule/actionForms/ExtendInputForm.vue
 create mode 100644 src/views/Rule/actionForms/FetchFileForm.vue
 create mode 100644 src/views/Rule/actionForms/FilepartUploadForm.vue
 create mode 100644 src/views/Rule/actionForms/FilepartsCreateForm.vue
 create mode 100644 src/views/Rule/actionForms/JavascriptForm.vue
 create mode 100644 src/views/Rule/actionForms/LockingForm.vue
 create mode 100644 src/views/Rule/actionForms/MappingForm.vue
 create mode 100644 src/views/Rule/actionForms/SaveObjectForm.vue
 create mode 100644 src/views/Rule/actionForms/SynchronizationForm.vue
 create mode 100644 src/views/Rule/actionForms/UploadForm.vue
 create mode 100644 src/views/Rule/actionForms/WriteFileForm.vue
 create mode 100644 src/views/Rule/actionForms/shared.js

diff --git a/appinfo/info.xml b/appinfo/info.xml
index 24a084875..a4a8df760 100644
--- a/appinfo/info.xml
+++ b/appinfo/info.xml
@@ -35,7 +35,7 @@ The OpenConnector Nextcloud app provides a ESB-framework to work together in an
 
         <!-- Chain B/C OR cutover: openconnector now stores domain data in OpenRegister.
              OR's ObjectService is required to boot openconnector controllers. -->
-        <nextcloud min-version="0.2.0" max-version="34"-app id="openregister"/>
+        <nextcloud-app id="openregister" min-version="0.2.0"/>
 	</dependencies>
 
 	<background-jobs>
diff --git a/src/views/Rule/RuleActionConfig.vue b/src/views/Rule/RuleActionConfig.vue
index 234ff8b78..6a5e10b98 100644
--- a/src/views/Rule/RuleActionConfig.vue
+++ b/src/views/Rule/RuleActionConfig.vue
@@ -2,24 +2,21 @@
 <!-- Copyright (C) 2026 Conduction B.V. -->
 <!--
   RuleActionConfig — picks the rule action type and renders the
-  parameter form for that action. Mirrors the legacy EditRule modal's
-  `typeOptions` switch but only ships rich forms for the two most-
-  used actions in v1:
-    - synchronization → Synchronization picker + "retain response"
-    - error → HTTP code + title + message + includeJsonLogicResult
-  All other action types fall through to a JSON editor for the
-  matching `configuration[<type>]` sub-object, matching what
-  RuleService::processCustomRule actually reads at evaluation time.
+  parameter form for that action.
 
-  Picker pattern follows #867's JobFormFields.vue: load
-  synchronizations once on demand from
-  `/apps/openregister/api/objects/openconnector/synchronization`.
+  Action-type → bespoke-form wiring lives in ACTION_FORM_MAP below.
+  Each bespoke form lives under `src/views/Rule/actionForms/` and
+  owns `v-model:value` over its slice of `configuration[<type>]`,
+  with the exception of `mapping` which is stored as a bare id at
+  `configuration.mapping` (no nested slot) — that single irregularity
+  is handled by the form's `v-model:id` contract.
 
-  Out of scope (deferred to follow-up): rich forms for fetch_file,
-  write_file, save_object, extend_input, extend_external_input. Each
-  has a non-trivial param surface (file paths, schema pickers,
-  property maps) that warrants its own component — tracked as a
-  follow-up issue alongside drag-reorder.
+  Action types without a bespoke form (currently none — every type
+  enumerated by the legacy modal has a dedicated form as of #877)
+  still fall through to the JSON-textarea path so unknown future
+  types stay editable.
+
+  Closes #877 (action-form half).
 -->
 <template>
 	<div class="rule-action-config">
@@ -39,61 +36,28 @@
 			</p>
 		</div>
 
-		<!-- Synchronization-specific parameters -->
-		<div v-if="actionType === 'synchronization'" class="rule-action-config__params">
-			<label class="rule-action-config__label" :for="'rule-action-sync-' + uid">
-				{{ t('openconnector', 'Synchronization') }}
-			</label>
-			<NcSelect
-				:input-id="'rule-action-sync-' + uid"
-				:value="selectedSynchronization"
-				:options="synchronizationOptions"
-				:loading="synchronizationsLoading"
-				:placeholder="t('openconnector', 'Select a synchronization')"
-				@input="onSynchronizationPick" />
-			<NcCheckboxRadioSwitch
-				type="switch"
-				:checked="!!retainResponse"
-				@update:checked="onRetainResponseToggle">
-				{{ t('openconnector', 'Retain original response') }}
-			</NcCheckboxRadioSwitch>
-			<span class="rule-action-config__helper">
-				{{ t('openconnector', 'When enabled, the synchronization runs but the rule preserves the original response body instead of replacing it.') }}
-			</span>
+		<!-- Bespoke form for the picked action type. `mapping` is the one
+		     outlier: its value lives at configuration.mapping (bare id)
+		     instead of configuration.mapping.mapping. -->
+		<div v-if="actionType === 'mapping'" class="rule-action-config__params">
+			<MappingForm
+				:id="configuration.mapping || ''"
+				@update:id="onMappingIdUpdate" />
 		</div>
-
-		<!-- Error-specific parameters -->
-		<div v-else-if="actionType === 'error'" class="rule-action-config__params">
-			<NcTextField
-				:label="t('openconnector', 'HTTP status code')"
-				type="number"
-				:value="errorCodeString"
-				placeholder="500"
-				@update:value="(value) => updateNested('error', 'code', value === '' ? null : Number(value))" />
-			<NcTextField
-				:label="t('openconnector', 'Error title')"
-				:value="errorTitle"
-				:placeholder="t('openconnector', 'Something went wrong')"
-				@update:value="(value) => updateNested('error', 'name', value)" />
-			<label class="rule-action-config__label" :for="'rule-action-error-msg-' + uid">
-				{{ t('openconnector', 'Error message') }}
-			</label>
-			<textarea
-				:id="'rule-action-error-msg-' + uid"
-				class="rule-action-config__textarea"
-				:value="errorMessage"
-				:placeholder="t('openconnector', 'We encountered an unexpected problem')"
-				rows="3"
-				@input="updateNested('error', 'message', $event.target.value)" />
-			<NcCheckboxRadioSwitch
-				type="switch"
-				:checked="!!includeJsonLogicResult"
-				@update:checked="(value) => updateNested('error', 'includeJsonLogicResult', value)">
-				{{ t('openconnector', 'Include JSON Logic results in errors array') }}
-			</NcCheckboxRadioSwitch>
+		<div v-else-if="actionType === 'javascript'" class="rule-action-config__params">
+			<JavascriptForm
+				:code="typeof configuration.javascript === 'string' ? configuration.javascript : ''"
+				@update:code="onJavascriptCodeUpdate" />
+		</div>
+		<div v-else-if="formComponent" class="rule-action-config__params">
+			<component
+				:is="formComponent"
+				:value="slotValue"
+				@update:value="onSlotUpdate" />
 		</div>
 
-		<!-- Fallback: raw JSON editor for the matching configuration[<type>] slot -->
+		<!-- Fallback: raw JSON editor for the matching configuration[<type>] slot.
+		     Only fires for action types with no entry in ACTION_FORM_MAP. -->
 		<div v-else-if="actionType" class="rule-action-config__params">
 			<label class="rule-action-config__label" :for="'rule-action-raw-' + uid">
 				{{ rawEditorLabel }}
@@ -109,20 +73,29 @@
 			<span
 				class="rule-action-config__helper"
 				:class="{ 'rule-action-config__helper--error': rawError }">
-				{{ rawError || t('openconnector', 'Rich form coming in a follow-up. Edit the raw JSON for now — it is written back as configuration.{type}.', { type: actionType }) }}
+				{{ rawError || t('openconnector', 'No bespoke form yet for this action type. Edit the raw JSON for now — it is written back as configuration.{type}.', { type: actionType }) }}
 			</span>
 		</div>
 	</div>
 </template>
 
 <script>
-import {
-	NcCheckboxRadioSwitch,
-	NcSelect,
-	NcTextField,
-} from '@nextcloud/vue'
-import axios from '@nextcloud/axios'
-import { generateUrl } from '@nextcloud/router'
+import { NcSelect } from '@nextcloud/vue'
+import SynchronizationForm from './actionForms/SynchronizationForm.vue'
+import ErrorForm from './actionForms/ErrorForm.vue'
+import MappingForm from './actionForms/MappingForm.vue'
+import JavascriptForm from './actionForms/JavascriptForm.vue'
+import AuthenticationForm from './actionForms/AuthenticationForm.vue'
+import DownloadForm from './actionForms/DownloadForm.vue'
+import UploadForm from './actionForms/UploadForm.vue'
+import LockingForm from './actionForms/LockingForm.vue'
+import FetchFileForm from './actionForms/FetchFileForm.vue'
+import WriteFileForm from './actionForms/WriteFileForm.vue'
+import FilepartsCreateForm from './actionForms/FilepartsCreateForm.vue'
+import FilepartUploadForm from './actionForms/FilepartUploadForm.vue'
+import SaveObjectForm from './actionForms/SaveObjectForm.vue'
+import ExtendInputForm from './actionForms/ExtendInputForm.vue'
+import ExtendExternalInputForm from './actionForms/ExtendExternalInputForm.vue'
 
 /**
  * Canonical list of rule action types. Lifted from the legacy modal's
@@ -149,22 +122,60 @@ const ACTION_TYPES = [
 	{ id: 'extend_external_input', label: 'Extend external input' },
 ]
 
+/**
+ * Map from action-type id (as used at `configuration.type`) to the
+ * component name to render. Forms that need to read/write a different
+ * slot than `configuration[type]` (currently only `mapping` and
+ * `javascript`) are special-cased in the template above.
+ */
+const ACTION_FORM_MAP = {
+	synchronization: 'SynchronizationForm',
+	error: 'ErrorForm',
+	mapping: 'MappingForm',
+	javascript: 'JavascriptForm',
+	authentication: 'AuthenticationForm',
+	download: 'DownloadForm',
+	upload: 'UploadForm',
+	locking: 'LockingForm',
+	fetch_file: 'FetchFileForm',
+	write_file: 'WriteFileForm',
+	fileparts_create: 'FilepartsCreateForm',
+	filepart_upload: 'FilepartUploadForm',
+	save_object: 'SaveObjectForm',
+	extend_input: 'ExtendInputForm',
+	extend_external_input: 'ExtendExternalInputForm',
+}
+
 let actionUidCounter = 0
 
 export default {
 	name: 'RuleActionConfig',
 
 	components: {
-		NcCheckboxRadioSwitch,
 		NcSelect,
-		NcTextField,
+		SynchronizationForm,
+		ErrorForm,
+		MappingForm,
+		JavascriptForm,
+		AuthenticationForm,
+		DownloadForm,
+		UploadForm,
+		LockingForm,
+		FetchFileForm,
+		WriteFileForm,
+		FilepartsCreateForm,
+		FilepartUploadForm,
+		SaveObjectForm,
+		ExtendInputForm,
+		ExtendExternalInputForm,
 	},
 
 	props: {
 		/**
 		 * Current `configuration` blob from the rule object. The action
 		 * type lives at `configuration.type`; the action-specific
-		 * sub-config lives at `configuration[<type>]`.
+		 * sub-config lives at `configuration[<type>]` (except for the
+		 * two outliers documented in ACTION_FORM_MAP).
 		 * @type {object}
 		 */
 		configuration: { type: Object, default: () => ({}) },
@@ -173,8 +184,6 @@ export default {
 	data() {
 		return {
 			uid: ++actionUidCounter,
-			synchronizationOptions: [],
-			synchronizationsLoading: false,
 			/** Draft JSON string for the fallback editor, keyed by action type. */
 			rawDrafts: {},
 			rawError: '',
@@ -191,39 +200,12 @@ export default {
 		selectedTypeOption() {
 			return this.typeOptions.find((option) => option.id === this.actionType) || null
 		},
-		syncConfig() {
-			const value = this.configuration?.synchronization
-			return value && typeof value === 'object' ? value : {}
-		},
-		retainResponse() {
-			return !!this.syncConfig.retainResponse
-		},
-		synchronizationId() {
-			return this.syncConfig.synchronization || this.syncConfig.synchronizationId || ''
-		},
-		selectedSynchronization() {
-			const id = String(this.synchronizationId)
-			if (!id) return null
-			return this.synchronizationOptions.find((option) => option.id === id) ?? {
-				id,
-				label: id,
-			}
-		},
-		errorConfig() {
-			const value = this.configuration?.error
-			return value && typeof value === 'object' ? value : {}
+		formComponent() {
+			return ACTION_FORM_MAP[this.actionType] || null
 		},
-		errorCodeString() {
-			return this.errorConfig.code != null ? String(this.errorConfig.code) : ''
-		},
-		errorTitle() {
-			return this.errorConfig.name || ''
-		},
-		errorMessage() {
-			return this.errorConfig.message || ''
-		},
-		includeJsonLogicResult() {
-			return !!this.errorConfig.includeJsonLogicResult
+		slotValue() {
+			const raw = this.configuration?.[this.actionType]
+			return raw && typeof raw === 'object' ? raw : {}
 		},
 		rawDraft() {
 			const draft = this.rawDrafts[this.actionType]
@@ -238,17 +220,6 @@ export default {
 		},
 	},
 
-	watch: {
-		actionType: {
-			immediate: true,
-			handler(value) {
-				if (value === 'synchronization' && this.synchronizationOptions.length === 0) {
-					this.fetchSynchronizations()
-				}
-			},
-		},
-	},
-
 	methods: {
 		onTypePick(option) {
 			if (!option) return
@@ -256,29 +227,23 @@ export default {
 			this.$emit('update', next)
 		},
 
-		onSynchronizationPick(option) {
-			const nextSync = { ...this.syncConfig }
-			if (option?.id) {
-				nextSync.synchronization = String(option.id)
-			} else {
-				delete nextSync.synchronization
-				delete nextSync.synchronizationId
-			}
-			const next = { ...(this.configuration || {}), synchronization: nextSync }
-			this.$emit('update', next)
+		onSlotUpdate(next) {
+			const merged = { ...(this.configuration || {}), [this.actionType]: next }
+			this.$emit('update', merged)
 		},
 
-		onRetainResponseToggle(value) {
-			const nextSync = { ...this.syncConfig, retainResponse: !!value }
-			const next = { ...(this.configuration || {}), synchronization: nextSync }
+		onMappingIdUpdate(id) {
+			const next = { ...(this.configuration || {}) }
+			if (id) {
+				next.mapping = String(id)
+			} else {
+				delete next.mapping
+			}
 			this.$emit('update', next)
 		},
 
-		updateNested(section, key, value) {
-			const current = this.configuration?.[section]
-			const base = current && typeof current === 'object' ? current : {}
-			const nextSection = { ...base, [key]: value }
-			const next = { ...(this.configuration || {}), [section]: nextSection }
+		onJavascriptCodeUpdate(code) {
+			const next = { ...(this.configuration || {}), javascript: code }
 			this.$emit('update', next)
 		},
 
@@ -301,32 +266,6 @@ export default {
 				this.rawError = this.t('openconnector', 'Invalid JSON: {message}', { message: parseErr.message })
 			}
 		},
-
-		async fetchSynchronizations() {
-			this.synchronizationsLoading = true
-			try {
-				const response = await axios.get(
-					generateUrl('/apps/openregister/api/objects/openconnector/synchronization'),
-					{ params: { limit: 500 } },
-				)
-				const data = response.data
-				const list = Array.isArray(data?.results)
-					? data.results
-					: Array.isArray(data)
-						? data
-						: []
-				this.synchronizationOptions = list.map((sync) => ({
-					id: String(sync.id || sync.uuid),
-					label: sync.name || sync.title || sync.id,
-				}))
-			} catch (err) {
-				// eslint-disable-next-line no-console
-				console.warn('[RuleActionConfig] synchronization fetch failed', err)
-				this.synchronizationOptions = []
-			} finally {
-				this.synchronizationsLoading = false
-			}
-		},
 	},
 }
 </script>
diff --git a/src/views/Rule/RuleConditionLeaf.vue b/src/views/Rule/RuleConditionLeaf.vue
index f95341114..5dcb70772 100644
--- a/src/views/Rule/RuleConditionLeaf.vue
+++ b/src/views/Rule/RuleConditionLeaf.vue
@@ -3,30 +3,36 @@
 <!--
   RuleConditionLeaf — one predicate in the visual condition tree.
 
-  A leaf is a (var, operator, value) triple. JsonLogic represents this
-  as `{ "<op>": [ { "var": "<path>" }, <literal> ] }` for binary ops,
-  or `{ "<op>": [ { "var": "<path>" } ] }` for unary ones (e.g. `!`,
-  `!!`). This component owns the inputs for those three slots and
-  emits the rebuilt JsonLogic node up to RuleConditionGroup.
-
-  Scope is MVP: a hand-picked subset of operators (==, !=, >, >=, <,
-  <=, in, !in, exists). String/number/boolean values share one text
-  input — JsonLogic is type-flexible at evaluation time, so coercion
-  is deferred to the rule engine. The advanced operators (`some`,
-  `all`, regex `match`, arithmetic) are out of scope for v1; users
-  who need them can still hand-edit the JSON via the raw editor
-  fallback in RuleDetailPage.
-
-  Closes #833 (leaf-half of the visual builder).
+  A leaf is one of:
+    - binary: `{ "<op>": [ { "var": "<path>" }, <literal> ] }`
+    - unary:  `{ "<op>": [ { "var": "<path>" } ] }`
+    - ternary (e.g. `if`, `substr` with length): `{ "<op>": [a, b, c] }`
+    - higher-order array op (e.g. `map`, `filter`, `reduce`, `all`,
+      `none`, `some`): `{ "<op>": [<collection>, <predicate>] }`
+    - `var` reference: `{ "var": "<path>" }` — the leaf renders this as
+      a plain text input; the leaf's own variable slot still exists for
+      consistency but is hidden when the picked op is `var` itself.
+
+  The operator picker is grouped (comparison / arithmetic / string /
+  array / control-flow / negation) so users can scan the list. Closes
+  the leaf half of #877.
 -->
 <template>
 	<div class="rule-condition-leaf" data-testid="rule-condition-leaf">
 		<NcTextField
+			v-if="schema.kind !== 'var-only'"
 			class="rule-condition-leaf__var"
 			:label="t('openconnector', 'Field')"
 			:value="varPath"
 			:placeholder="t('openconnector', 'e.g. body.status')"
 			@update:value="onVarInput" />
+		<NcTextField
+			v-else
+			class="rule-condition-leaf__var"
+			:label="t('openconnector', 'Variable path')"
+			:value="varOnlyPath"
+			:placeholder="t('openconnector', 'e.g. user.email')"
+			@update:value="onVarOnlyInput" />
 		<NcSelect
 			class="rule-condition-leaf__op"
 			:input-id="'rule-condition-op-' + uid"
@@ -34,16 +40,94 @@
 			:options="operatorOptions"
 			:clearable="false"
 			:placeholder="t('openconnector', 'Operator')"
-			@input="onOperatorPick" />
-		<NcTextField
-			v-if="needsValue"
-			class="rule-condition-leaf__value"
-			:label="t('openconnector', 'Value')"
-			:value="valueString"
-			:placeholder="t('openconnector', 'Comparison value')"
-			@update:value="onValueInput" />
-		<span v-else class="rule-condition-leaf__value rule-condition-leaf__value--placeholder">
-			{{ t('openconnector', '(no value needed)') }}
+			label="label"
+			:reduce="(option) => option"
+			@input="onOperatorPick">
+			<template #option="{ label, group }">
+				<div class="rule-condition-leaf__op-option">
+					<span class="rule-condition-leaf__op-option-label">{{ label }}</span>
+					<span v-if="group" class="rule-condition-leaf__op-option-group">{{ group }}</span>
+				</div>
+			</template>
+		</NcSelect>
+		<template v-if="schema.kind === 'binary' || schema.kind === 'ternary'">
+			<NcTextField
+				class="rule-condition-leaf__value"
+				:label="schema.labels?.[0] || t('openconnector', 'Value')"
+				:value="slotString(1)"
+				:placeholder="schema.placeholders?.[0] || t('openconnector', 'Comparison value')"
+				@update:value="(value) => onSlotInput(1, value)" />
+			<NcTextField
+				v-if="schema.kind === 'ternary'"
+				class="rule-condition-leaf__value"
+				:label="schema.labels?.[1] || t('openconnector', 'Length')"
+				:value="slotString(2)"
+				:placeholder="schema.placeholders?.[1] || ''"
+				@update:value="(value) => onSlotInput(2, value)" />
+		</template>
+		<template v-else-if="schema.kind === 'if'">
+			<label class="rule-condition-leaf__json-label">
+				{{ t('openconnector', 'Then (JsonLogic)') }}
+				<textarea
+					class="rule-condition-leaf__textarea"
+					:value="slotJson(1)"
+					spellcheck="false"
+					rows="2"
+					placeholder="{ &quot;var&quot;: &quot;a&quot; }"
+					@input="(event) => onJsonSlotInput(1, event.target.value)" />
+			</label>
+			<label class="rule-condition-leaf__json-label">
+				{{ t('openconnector', 'Else (JsonLogic)') }}
+				<textarea
+					class="rule-condition-leaf__textarea"
+					:value="slotJson(2)"
+					spellcheck="false"
+					rows="2"
+					placeholder="{ &quot;var&quot;: &quot;b&quot; }"
+					@input="(event) => onJsonSlotInput(2, event.target.value)" />
+			</label>
+		</template>
+		<template v-else-if="schema.kind === 'array-op'">
+			<label class="rule-condition-leaf__json-label">
+				{{ schema.labels?.[0] || t('openconnector', 'Collection (JsonLogic)') }}
+				<textarea
+					class="rule-condition-leaf__textarea"
+					:value="slotJson(0, { fallback: '' })"
+					spellcheck="false"
+					rows="2"
+					:placeholder="schema.placeholders?.[0] || '{ &quot;var&quot;: &quot;items&quot; }'"
+					@input="(event) => onJsonSlotInput(0, event.target.value)" />
+			</label>
+			<label class="rule-condition-leaf__json-label">
+				{{ schema.labels?.[1] || t('openconnector', 'Predicate (JsonLogic)') }}
+				<textarea
+					class="rule-condition-leaf__textarea"
+					:value="slotJson(1)"
+					spellcheck="false"
+					rows="2"
+					:placeholder="schema.placeholders?.[1] || '{ &quot;==&quot;: [{&quot;var&quot;: &quot;&quot;}, true] }'"
+					@input="(event) => onJsonSlotInput(1, event.target.value)" />
+			</label>
+		</template>
+		<template v-else-if="schema.kind === 'merge'">
+			<label class="rule-condition-leaf__json-label">
+				{{ t('openconnector', 'Arrays to merge (JSON array of JsonLogic)') }}
+				<textarea
+					class="rule-condition-leaf__textarea"
+					:value="mergeJson"
+					spellcheck="false"
+					rows="3"
+					placeholder="[ { &quot;var&quot;: &quot;a&quot; }, [ 1, 2 ] ]"
+					@input="(event) => onMergeInput(event.target.value)" />
+			</label>
+		</template>
+		<template v-else-if="schema.kind === 'unary' || schema.kind === 'var-only'">
+			<span class="rule-condition-leaf__value rule-condition-leaf__value--placeholder">
+				{{ t('openconnector', '(no value needed)') }}
+			</span>
+		</template>
+		<span v-if="parseError" class="rule-condition-leaf__error">
+			{{ parseError }}
 		</span>
 		<NcButton
 			class="rule-condition-leaf__remove"
@@ -62,23 +146,54 @@ import { NcButton, NcSelect, NcTextField } from '@nextcloud/vue'
 import Close from 'vue-material-design-icons/Close.vue'
 
 /**
- * Operators the visual builder exposes. Each entry maps a JsonLogic
- * operator string to a human label plus a flag for whether the
- * second operand (the value) is required. Unary operators (`!`, `!!`)
- * are emitted with a single-element args array.
+ * Operator schema. `kind` drives which inputs render:
+ *
+ *   - 'binary'    — 2 args: field + value
+ *   - 'unary'     — 1 arg: field only
+ *   - 'ternary'   — 3 args: field + value + length (currently `substr`)
+ *   - 'if'        — 3 args: condition leaf + then JSON + else JSON
+ *   - 'array-op'  — 2 args: collection JSON + predicate JSON
+ *   - 'merge'     — variadic: a JSON array of JsonLogic nodes
+ *   - 'var-only'  — single dotted-path string emitted as `{ var: "..." }`
  *
- * @type {Array<{ id: string, label: string, unary: boolean }>}
+ * `group` is purely cosmetic for the picker.
+ *
+ * @type {Array<{ id: string, label: string, group: string, kind: string,
+ *                labels?: string[], placeholders?: string[] }>}
  */
 const OPERATORS = [
-	{ id: '==', label: 'equals', unary: false },
-	{ id: '!=', label: 'does not equal', unary: false },
-	{ id: '>', label: 'greater than', unary: false },
-	{ id: '>=', label: 'greater than or equal', unary: false },
-	{ id: '<', label: 'less than', unary: false },
-	{ id: '<=', label: 'less than or equal', unary: false },
-	{ id: 'in', label: 'in (string contains / array member)', unary: false },
-	{ id: '!!', label: 'exists / truthy', unary: true },
-	{ id: '!', label: 'missing / falsy', unary: true },
+	// Comparison
+	{ id: '==', label: 'equals', group: 'comparison', kind: 'binary' },
+	{ id: '!=', label: 'does not equal', group: 'comparison', kind: 'binary' },
+	{ id: '>', label: 'greater than', group: 'comparison', kind: 'binary' },
+	{ id: '>=', label: 'greater than or equal', group: 'comparison', kind: 'binary' },
+	{ id: '<', label: 'less than', group: 'comparison', kind: 'binary' },
+	{ id: '<=', label: 'less than or equal', group: 'comparison', kind: 'binary' },
+	{ id: 'in', label: 'in (string contains / array member)', group: 'comparison', kind: 'binary' },
+	// Negation / existence
+	{ id: '!!', label: 'exists / truthy', group: 'negation', kind: 'unary' },
+	{ id: '!', label: 'missing / falsy', group: 'negation', kind: 'unary' },
+	{ id: 'missing', label: 'missing (list of required paths)', group: 'negation', kind: 'binary', labels: ['Comma-separated paths'], placeholders: ['a,b,c'] },
+	// Arithmetic
+	{ id: '+', label: 'add', group: 'arithmetic', kind: 'binary' },
+	{ id: '-', label: 'subtract', group: 'arithmetic', kind: 'binary' },
+	{ id: '*', label: 'multiply', group: 'arithmetic', kind: 'binary' },
+	{ id: '/', label: 'divide', group: 'arithmetic', kind: 'binary' },
+	{ id: '%', label: 'modulo', group: 'arithmetic', kind: 'binary' },
+	// String
+	{ id: 'cat', label: 'concatenate strings', group: 'string', kind: 'binary', labels: ['Right operand'] },
+	{ id: 'substr', label: 'substring', group: 'string', kind: 'ternary', labels: ['Start', 'Length'], placeholders: ['0', '5'] },
+	// Array / higher-order
+	{ id: 'map', label: 'map (collection, predicate)', group: 'array', kind: 'array-op' },
+	{ id: 'filter', label: 'filter (collection, predicate)', group: 'array', kind: 'array-op' },
+	{ id: 'reduce', label: 'reduce (collection, predicate)', group: 'array', kind: 'array-op' },
+	{ id: 'all', label: 'all (collection, predicate)', group: 'array', kind: 'array-op' },
+	{ id: 'none', label: 'none (collection, predicate)', group: 'array', kind: 'array-op' },
+	{ id: 'some', label: 'some (collection, predicate)', group: 'array', kind: 'array-op' },
+	{ id: 'merge', label: 'merge arrays', group: 'array', kind: 'merge' },
+	// Control flow / refs
+	{ id: 'if', label: 'if (condition, then, else)', group: 'control', kind: 'if' },
+	{ id: 'var', label: 'var (read value at path)', group: 'control', kind: 'var-only' },
 ]
 
 let leafUidCounter = 0
@@ -95,12 +210,9 @@ export default {
 
 	props: {
 		/**
-		 * The JsonLogic node this leaf renders. Shape is one of:
-		 *   `{ "<op>": [ { "var": "<path>" }, <literal> ] }` (binary)
-		 *   `{ "<op>": [ { "var": "<path>" } ] }`            (unary)
-		 *
-		 * Anything else is treated as an empty leaf so the UI never
-		 * blanks the user out of a malformed-but-recoverable node.
+		 * The JsonLogic node this leaf renders. Shape is one of the
+		 * forms enumerated in the file header. Anything unrecognised
+		 * is coerced to an empty `==` leaf so the UI never blanks out.
 		 *
 		 * @type {object}
 		 */
@@ -110,29 +222,38 @@ export default {
 	data() {
 		return {
 			uid: ++leafUidCounter,
+			parseError: '',
 		}
 	},
 
 	computed: {
 		operatorOptions() {
-			return OPERATORS.map((op) => ({ id: op.id, label: this.t('openconnector', op.label) }))
+			return OPERATORS.map((op) => ({
+				id: op.id,
+				label: this.t('openconnector', op.label),
+				group: op.group ? this.t('openconnector', op.group) : '',
+			}))
 		},
 		currentOperator() {
 			const keys = Object.keys(this.node || {})
 			const op = keys.find((key) => OPERATORS.some((entry) => entry.id === key))
 			return op || '=='
 		},
+		schema() {
+			return OPERATORS.find((entry) => entry.id === this.currentOperator) || OPERATORS[0]
+		},
 		selectedOperator() {
 			return this.operatorOptions.find((option) => option.id === this.currentOperator)
 				?? this.operatorOptions[0]
 		},
-		needsValue() {
-			const op = OPERATORS.find((entry) => entry.id === this.currentOperator)
-			return op ? !op.unary : true
-		},
 		args() {
 			const value = this.node?.[this.currentOperator]
-			return Array.isArray(value) ? value : []
+			if (Array.isArray(value)) return value
+			// `var` accepts a bare string too.
+			if (this.currentOperator === 'var') {
+				return [typeof value === 'string' ? value : '']
+			}
+			return []
 		},
 		varPath() {
 			const first = this.args[0]
@@ -142,16 +263,17 @@ export default {
 			if (typeof first === 'string') return first
 			return ''
 		},
-		rawValue() {
-			return this.args.length > 1 ? this.args[1] : ''
-		},
-		valueString() {
-			const raw = this.rawValue
-			if (raw === null || raw === undefined) return ''
-			if (typeof raw === 'object') {
-				try { return JSON.stringify(raw) } catch (_e) { return String(raw) }
+		varOnlyPath() {
+			// For top-level `var` ops, args[0] is the dotted-path string.
+			const first = this.args[0]
+			if (typeof first === 'string') return first
+			if (first && typeof first === 'object' && Object.prototype.hasOwnProperty.call(first, 'var')) {
+				return String(first.var ?? '')
 			}
-			return String(raw)
+			return ''
+		},
+		mergeJson() {
+			try { return JSON.stringify(this.args, null, 2) } catch (_e) { return '[]' }
 		},
 	},
 
@@ -159,12 +281,66 @@ export default {
 		onVarInput(value) {
 			this.emitUpdate({ varPath: value })
 		},
+		onVarOnlyInput(value) {
+			// Emit `{ "var": [<path>] }` — jsonlogic-php accepts both
+			// `{ var: "a" }` and `{ var: ["a"] }`; we use the array form
+			// here for shape parity with other ops in the tree.
+			this.$emit('update', { var: [value] })
+		},
 		onOperatorPick(option) {
 			if (!option) return
 			this.emitUpdate({ operator: option.id })
 		},
-		onValueInput(value) {
-			this.emitUpdate({ rawValue: this.coerce(value) })
+		onSlotInput(slot, value) {
+			this.emitUpdate({ slot, slotValue: this.coerce(value) })
+		},
+		onJsonSlotInput(slot, value) {
+			const trimmed = value.trim()
+			if (trimmed.length === 0) {
+				this.emitUpdate({ slot, slotValue: '' })
+				this.parseError = ''
+				return
+			}
+			try {
+				const parsed = JSON.parse(trimmed)
+				this.parseError = ''
+				this.emitUpdate({ slot, slotValue: parsed })
+			} catch (parseErr) {
+				this.parseError = this.t('openconnector', 'Invalid JSON: {message}', { message: parseErr.message })
+			}
+		},
+		onMergeInput(value) {
+			const trimmed = value.trim()
+			if (trimmed.length === 0) {
+				this.parseError = ''
+				this.$emit('update', { merge: [] })
+				return
+			}
+			try {
+				const parsed = JSON.parse(trimmed)
+				if (!Array.isArray(parsed)) {
+					this.parseError = this.t('openconnector', 'merge expects a JSON array')
+					return
+				}
+				this.parseError = ''
+				this.$emit('update', { merge: parsed })
+			} catch (parseErr) {
+				this.parseError = this.t('openconnector', 'Invalid JSON: {message}', { message: parseErr.message })
+			}
+		},
+		slotString(index) {
+			const raw = this.args[index]
+			if (raw === null || raw === undefined) return ''
+			if (typeof raw === 'object') {
+				try { return JSON.stringify(raw) } catch (_e) { return String(raw) }
+			}
+			return String(raw)
+		},
+		slotJson(index, { fallback = '' } = {}) {
+			const raw = this.args[index]
+			if (raw === undefined) return fallback
+			if (typeof raw === 'string') return raw
+			try { return JSON.stringify(raw, null, 2) } catch (_e) { return String(raw) }
 		},
 		/**
 		 * Best-effort literal coercion. Numbers and booleans get
@@ -188,21 +364,74 @@ export default {
 		/**
 		 * Rebuild the JsonLogic node and emit. Done in one place so
 		 * the operator change can both flip the operator key AND
-		 * trim the value arg for unary operators.
+		 * resize the args array.
 		 *
-		 * @param {{ varPath?: string, operator?: string, rawValue?: * }} patch
+		 * @param {{ varPath?: string, operator?: string, slot?: number, slotValue?: * }} patch
 		 *   Partial change — fields omitted come from current state.
 		 * @return {void}
 		 */
 		emitUpdate(patch) {
 			const operator = patch.operator ?? this.currentOperator
-			const varPath = patch.varPath ?? this.varPath
-			const opEntry = OPERATORS.find((entry) => entry.id === operator)
-			const isUnary = !!opEntry?.unary
-			const value = isUnary ? undefined : (patch.rawValue !== undefined ? patch.rawValue : this.rawValue)
-			const args = isUnary ? [{ var: varPath }] : [{ var: varPath }, value]
+			const nextSchema = OPERATORS.find((entry) => entry.id === operator) || OPERATORS[0]
+
+			// Operator switch: rebuild args from scratch using current
+			// var/value where possible, falling back to defaults.
+			if (patch.operator !== undefined) {
+				const args = this.argsForKind(nextSchema, { carryVar: this.varPath, carryValue: this.args[1] })
+				this.$emit('update', { [operator]: args })
+				return
+			}
+
+			// var-only schema funnels through onVarOnlyInput; here we
+			// rebuild non-var-only schemas.
+			const args = (this.node?.[this.currentOperator] && Array.isArray(this.node[this.currentOperator]))
+				? this.node[this.currentOperator].slice()
+				: this.argsForKind(nextSchema, { carryVar: this.varPath, carryValue: this.args[1] })
+
+			if (patch.varPath !== undefined) {
+				args[0] = { var: patch.varPath }
+			}
+			if (patch.slot !== undefined) {
+				args[patch.slot] = patch.slotValue
+			}
+
+			// For unary, trim trailing slots.
+			if (nextSchema.kind === 'unary') {
+				this.$emit('update', { [operator]: [args[0] ?? { var: this.varPath }] })
+				return
+			}
+
 			this.$emit('update', { [operator]: args })
 		},
+		/**
+		 * Build a fresh args array for a given schema kind. Used when
+		 * switching ops so the new shape is well-formed.
+		 *
+		 * @param {object} schema Operator schema.
+		 * @param {{ carryVar: string, carryValue: * }} carry Best-effort
+		 *   reuse of the current var/value across an op change.
+		 * @return {Array} Initial args array.
+		 */
+		argsForKind(schema, { carryVar = '', carryValue = '' } = {}) {
+			switch (schema.kind) {
+			case 'unary':
+				return [{ var: carryVar }]
+			case 'binary':
+				return [{ var: carryVar }, carryValue ?? '']
+			case 'ternary':
+				return [{ var: carryVar }, carryValue ?? '', '']
+			case 'if':
+				return [{ var: carryVar }, '', '']
+			case 'array-op':
+				return [{ var: carryVar }, { '==': [{ var: '' }, true] }]
+			case 'merge':
+				return [{ var: carryVar }]
+			case 'var-only':
+				return [carryVar]
+			default:
+				return [{ var: carryVar }, carryValue ?? '']
+			}
+		},
 	},
 }
 </script>
@@ -224,6 +453,46 @@ export default {
 	padding: 8px 0;
 }
 
+.rule-condition-leaf__json-label {
+	display: flex;
+	flex-direction: column;
+	gap: 4px;
+	grid-column: 1 / -2;
+	font-size: 13px;
+	color: var(--color-text-maxcontrast);
+}
+
+.rule-condition-leaf__textarea {
+	width: 100%;
+	padding: 6px 8px;
+	font-family: var(--font-face-monospace, monospace);
+	font-size: 12px;
+	background: var(--color-main-background);
+	color: var(--color-main-text);
+	border: 1px solid var(--color-border);
+	border-radius: var(--border-radius);
+	resize: vertical;
+}
+
+.rule-condition-leaf__error {
+	grid-column: 1 / -2;
+	font-size: 12px;
+	color: var(--color-error);
+}
+
+.rule-condition-leaf__op-option {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	gap: 12px;
+}
+
+.rule-condition-leaf__op-option-group {
+	font-size: 11px;
+	color: var(--color-text-maxcontrast);
+	text-transform: uppercase;
+}
+
 @media (max-width: 720px) {
 	.rule-condition-leaf {
 		grid-template-columns: 1fr;
diff --git a/src/views/Rule/actionForms/AuthenticationForm.vue b/src/views/Rule/actionForms/AuthenticationForm.vue
new file mode 100644
index 000000000..51b7a541d
--- /dev/null
+++ b/src/views/Rule/actionForms/AuthenticationForm.vue
@@ -0,0 +1,91 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  AuthenticationForm — drives EndpointService::processAuthenticationRule.
+  The `type` discriminator selects between apikey / jwt / jwt-zgw /
+  basic / oauth, each of which reads different sub-fields. We expose
+  the common header override + a per-type panel for the most-used
+  shapes; the rest stay as raw arrays (comma-separated input).
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Authentication type') }}</label>
+		<NcSelect
+			:value="selectedTypeOption"
+			:options="typeOptions"
+			:clearable="false"
+			@input="onTypePick" />
+		<NcTextField
+			:label="t('openconnector', 'Header (default: Authorization)')"
+			:value="value.header || ''"
+			placeholder="Authorization"
+			@update:value="(next) => patch('header', next)" />
+		<template v-if="value.type === 'apikey'">
+			<NcTextField
+				:label="t('openconnector', 'API keys (comma-separated)')"
+				:value="csv(value.keys)"
+				placeholder="key-one,key-two"
+				@update:value="(next) => patch('keys', toArray(next))" />
+		</template>
+		<template v-else-if="value.type === 'basic' || value.type === 'oauth'">
+			<NcTextField
+				:label="t('openconnector', 'Allowed users (comma-separated UIDs)')"
+				:value="csv(value.users)"
+				placeholder="alice,bob"
+				@update:value="(next) => patch('users', toArray(next))" />
+			<NcTextField
+				:label="t('openconnector', 'Allowed groups (comma-separated)')"
+				:value="csv(value.groups)"
+				placeholder="admin,users"
+				@update:value="(next) => patch('groups', toArray(next))" />
+		</template>
+		<span class="action-form__helper">
+			{{ t('openconnector', 'For JWT / JWT-ZGW the rule only checks the signed bearer; no extra fields are required.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcSelect, NcTextField } from '@nextcloud/vue'
+import { patchMethod, valueProp } from './shared.js'
+
+const AUTH_TYPES = [
+	{ id: 'apikey', label: 'API key' },
+	{ id: 'jwt', label: 'JWT' },
+	{ id: 'jwt-zgw', label: 'JWT (ZGW)' },
+	{ id: 'basic', label: 'Basic (users/groups)' },
+	{ id: 'oauth', label: 'OAuth (users/groups)' },
+]
+
+export default {
+	name: 'AuthenticationForm',
+	components: { NcSelect, NcTextField },
+	props: { ...valueProp },
+	computed: {
+		typeOptions() {
+			return AUTH_TYPES.map((row) => ({ id: row.id, label: this.t('openconnector', row.label) }))
+		},
+		selectedTypeOption() {
+			return this.typeOptions.find((opt) => opt.id === this.value.type) || null
+		},
+	},
+	methods: {
+		patch: patchMethod(),
+		onTypePick(option) {
+			this.patch('type', option?.id || '')
+		},
+		csv(value) {
+			return Array.isArray(value) ? value.join(',') : (value || '')
+		},
+		toArray(text) {
+			return (text || '').split(',').map((entry) => entry.trim()).filter(Boolean)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/DownloadForm.vue b/src/views/Rule/actionForms/DownloadForm.vue
new file mode 100644
index 000000000..67e7b46a8
--- /dev/null
+++ b/src/views/Rule/actionForms/DownloadForm.vue
@@ -0,0 +1,57 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  DownloadForm — EndpointService::processDownloadRule reads
+  `configuration.filenamePosition` (dotted path on the object) to
+  resolve the filename. The legacy modal also collected
+  `fileIdPosition` (path-index of the file id in the URL) which the
+  current backend ignores, but we keep it so existing data round-trips.
+-->
+<template>
+	<div class="action-form">
+		<NcTextField
+			:label="t('openconnector', 'Filename position (dotted path on object)')"
+			:value="value.filenamePosition || ''"
+			placeholder="attachments.0.filename"
+			@update:value="(next) => patch('filenamePosition', next)" />
+		<NcTextField
+			:label="t('openconnector', 'File ID position in URL path (legacy)')"
+			type="number"
+			:value="value.fileIdPosition != null ? String(value.fileIdPosition) : ''"
+			placeholder="2"
+			@update:value="onFileIdInput" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'The endpoint checks if the authenticated user is allowed to read the resolved file before sending bytes back.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcTextField } from '@nextcloud/vue'
+import { patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'DownloadForm',
+	components: { NcTextField },
+	props: { ...valueProp },
+	methods: {
+		patch: patchMethod(),
+		onFileIdInput(raw) {
+			if (raw === '' || raw == null) {
+				const next = { ...(this.value || {}) }
+				delete next.fileIdPosition
+				this.$emit('update:value', next)
+				return
+			}
+			const num = Number(raw)
+			if (Number.isNaN(num)) return
+			this.patch('fileIdPosition', num)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/ErrorForm.vue b/src/views/Rule/actionForms/ErrorForm.vue
new file mode 100644
index 000000000..1b8d0d9fd
--- /dev/null
+++ b/src/views/Rule/actionForms/ErrorForm.vue
@@ -0,0 +1,76 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  ErrorForm — configures the `error` action's HTTP code, title,
+  message, and includeJsonLogicResult toggle. Shape matches what
+  EndpointService::processErrorRule reads at evaluation time.
+-->
+<template>
+	<div class="action-form">
+		<NcTextField
+			:label="t('openconnector', 'HTTP status code')"
+			type="number"
+			:value="value.code != null ? String(value.code) : ''"
+			placeholder="500"
+			@update:value="onCodeInput" />
+		<NcTextField
+			:label="t('openconnector', 'Error title')"
+			:value="value.name || ''"
+			:placeholder="t('openconnector', 'Something went wrong')"
+			@update:value="(next) => patch('name', next)" />
+		<label class="action-form__label" :for="'rule-action-error-msg-' + uid">
+			{{ t('openconnector', 'Error message') }}
+		</label>
+		<textarea
+			:id="'rule-action-error-msg-' + uid"
+			class="action-form__textarea"
+			:value="value.message || ''"
+			rows="3"
+			:placeholder="t('openconnector', 'We encountered an unexpected problem')"
+			@input="(event) => patch('message', event.target.value)" />
+		<NcCheckboxRadioSwitch
+			type="switch"
+			:checked="!!value.includeJsonLogicResult"
+			@update:checked="(next) => patch('includeJsonLogicResult', !!next)">
+			{{ t('openconnector', 'Include JSON Logic results in errors array') }}
+		</NcCheckboxRadioSwitch>
+	</div>
+</template>
+
+<script>
+import { NcCheckboxRadioSwitch, NcTextField } from '@nextcloud/vue'
+import { patchMethod, valueProp } from './shared.js'
+
+let uidCounter = 0
+
+export default {
+	name: 'ErrorForm',
+	components: { NcCheckboxRadioSwitch, NcTextField },
+	props: { ...valueProp },
+	data() { return { uid: ++uidCounter } },
+	methods: {
+		patch: patchMethod(),
+		onCodeInput(raw) {
+			if (raw === '' || raw == null) {
+				const next = { ...(this.value || {}) }
+				delete next.code
+				this.$emit('update:value', next)
+				return
+			}
+			const num = Number(raw)
+			if (Number.isNaN(num)) return
+			this.patch('code', num)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__textarea {
+	width: 100%; padding: 8px; font-family: var(--font-face, sans-serif);
+	font-size: 14px; background: var(--color-main-background); color: var(--color-main-text);
+	border: 1px solid var(--color-border); border-radius: var(--border-radius); resize: vertical;
+}
+</style>
diff --git a/src/views/Rule/actionForms/ExtendExternalInputForm.vue b/src/views/Rule/actionForms/ExtendExternalInputForm.vue
new file mode 100644
index 000000000..c13d83f79
--- /dev/null
+++ b/src/views/Rule/actionForms/ExtendExternalInputForm.vue
@@ -0,0 +1,103 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  ExtendExternalInputForm — RuleService::extendExternalUrl iterates
+  `properties` (each `{ property, schema }`) and validates fetched
+  objects against the named schema when `validate` is true.
+-->
+<template>
+	<div class="action-form">
+		<NcCheckboxRadioSwitch
+			type="switch"
+			:checked="!!value.validate"
+			@update:checked="onValidateToggle">
+			{{ t('openconnector', 'Validate fetched object against schema') }}
+		</NcCheckboxRadioSwitch>
+
+		<label class="action-form__label">{{ t('openconnector', 'Properties to fetch') }}</label>
+		<div v-for="(row, index) in rows" :key="index" class="action-form__row">
+			<NcTextField
+				:label="t('openconnector', 'Property (dot path)')"
+				:value="row.property"
+				placeholder="body.relations.contact"
+				@update:value="(next) => onPropertyInput(index, next)" />
+			<NcTextField
+				:label="t('openconnector', 'Schema ID')"
+				:value="row.schema"
+				placeholder="contact"
+				@update:value="(next) => onSchemaInput(index, next)" />
+			<NcButton
+				type="tertiary-no-background"
+				:aria-label="t('openconnector', 'Remove row')"
+				@click="removeRow(index)">
+				<template #icon>
+					<Close :size="18" />
+				</template>
+			</NcButton>
+		</div>
+		<NcButton type="secondary" @click="addRow">
+			<template #icon>
+				<Plus :size="18" />
+			</template>
+			{{ t('openconnector', 'Add property') }}
+		</NcButton>
+	</div>
+</template>
+
+<script>
+import { NcButton, NcCheckboxRadioSwitch, NcTextField } from '@nextcloud/vue'
+import Close from 'vue-material-design-icons/Close.vue'
+import Plus from 'vue-material-design-icons/Plus.vue'
+import { valueProp } from './shared.js'
+
+export default {
+	name: 'ExtendExternalInputForm',
+	components: { NcButton, NcCheckboxRadioSwitch, NcTextField, Close, Plus },
+	props: { ...valueProp },
+	computed: {
+		rows() {
+			const props = Array.isArray(this.value?.properties) ? this.value.properties : []
+			return props.map((entry) => ({
+				property: String(entry?.property || ''),
+				schema: String(entry?.schema || ''),
+			}))
+		},
+	},
+	methods: {
+		emitRows(rows) {
+			const next = { ...(this.value || {}), properties: rows.filter((row) => row.property) }
+			this.$emit('update:value', next)
+		},
+		onValidateToggle(checked) {
+			this.$emit('update:value', { ...(this.value || {}), validate: !!checked })
+		},
+		onPropertyInput(index, value) {
+			const rows = this.rows.slice()
+			rows[index] = { ...rows[index], property: value }
+			this.emitRows(rows)
+		},
+		onSchemaInput(index, value) {
+			const rows = this.rows.slice()
+			rows[index] = { ...rows[index], schema: value }
+			this.emitRows(rows)
+		},
+		addRow() {
+			const rows = this.rows.slice()
+			rows.push({ property: '', schema: '' })
+			this.emitRows(rows)
+		},
+		removeRow(index) {
+			const rows = this.rows.slice()
+			rows.splice(index, 1)
+			this.emitRows(rows)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__row { display: grid; grid-template-columns: 1fr 1fr auto; gap: 8px; align-items: end; }
+@media (max-width: 720px) { .action-form__row { grid-template-columns: 1fr; } }
+</style>
diff --git a/src/views/Rule/actionForms/ExtendInputForm.vue b/src/views/Rule/actionForms/ExtendInputForm.vue
new file mode 100644
index 000000000..6d4c36f12
--- /dev/null
+++ b/src/views/Rule/actionForms/ExtendInputForm.vue
@@ -0,0 +1,115 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  ExtendInputForm — EndpointService::processExtendInputRule iterates
+  `configuration.extend_input.properties`, treating each entry as a
+  dotted path on the parameters whose value (a uuid) gets resolved into
+  the matching OpenRegister object. Optional `extends` map provides
+  per-property extend paths.
+
+  We model this as a list of `{ property, extends }` rows. Properties
+  serialise to a flat array of strings (the legacy backend shape) but
+  the optional `extends` map is preserved separately for round-tripping.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Properties to extend') }}</label>
+		<div v-for="(row, index) in rows" :key="index" class="action-form__row">
+			<NcTextField
+				:label="t('openconnector', 'Property (dot path)')"
+				:value="row.property"
+				placeholder="a.b"
+				@update:value="(next) => onPropertyInput(index, next)" />
+			<NcTextField
+				:label="t('openconnector', 'Extends (comma-separated paths, optional)')"
+				:value="(row.extends || []).join(',')"
+				placeholder="x.y,z"
+				@update:value="(next) => onExtendsInput(index, next)" />
+			<NcButton
+				type="tertiary-no-background"
+				:aria-label="t('openconnector', 'Remove row')"
+				@click="removeRow(index)">
+				<template #icon>
+					<Close :size="18" />
+				</template>
+			</NcButton>
+		</div>
+		<NcButton type="secondary" @click="addRow">
+			<template #icon>
+				<Plus :size="18" />
+			</template>
+			{{ t('openconnector', 'Add property') }}
+		</NcButton>
+	</div>
+</template>
+
+<script>
+import { NcButton, NcTextField } from '@nextcloud/vue'
+import Close from 'vue-material-design-icons/Close.vue'
+import Plus from 'vue-material-design-icons/Plus.vue'
+import { valueProp } from './shared.js'
+
+export default {
+	name: 'ExtendInputForm',
+	components: { NcButton, NcTextField, Close, Plus },
+	props: { ...valueProp },
+	computed: {
+		rows() {
+			const props = Array.isArray(this.value?.properties) ? this.value.properties : []
+			const extendsMap = (this.value?.extends && typeof this.value.extends === 'object') ? this.value.extends : {}
+			return props.map((property) => ({
+				property: String(property || ''),
+				extends: Array.isArray(extendsMap[property]) ? extendsMap[property] : [],
+			}))
+		},
+	},
+	methods: {
+		emitRows(rows) {
+			const properties = rows.map((row) => row.property).filter(Boolean)
+			const extendsMap = {}
+			for (const row of rows) {
+				if (row.property && row.extends && row.extends.length > 0) {
+					extendsMap[row.property] = row.extends
+				}
+			}
+			const next = { ...(this.value || {}), properties }
+			if (Object.keys(extendsMap).length > 0) {
+				next.extends = extendsMap
+			} else {
+				delete next.extends
+			}
+			this.$emit('update:value', next)
+		},
+		onPropertyInput(index, value) {
+			const rows = this.rows.slice()
+			rows[index] = { ...rows[index], property: value }
+			this.emitRows(rows)
+		},
+		onExtendsInput(index, value) {
+			const rows = this.rows.slice()
+			rows[index] = {
+				...rows[index],
+				extends: value.split(',').map((entry) => entry.trim()).filter(Boolean),
+			}
+			this.emitRows(rows)
+		},
+		addRow() {
+			const rows = this.rows.slice()
+			rows.push({ property: '', extends: [] })
+			this.emitRows(rows)
+		},
+		removeRow(index) {
+			const rows = this.rows.slice()
+			rows.splice(index, 1)
+			this.emitRows(rows)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__row { display: grid; grid-template-columns: 1fr 1fr auto; gap: 8px; align-items: end; }
+@media (max-width: 720px) { .action-form__row { grid-template-columns: 1fr; } }
+</style>
diff --git a/src/views/Rule/actionForms/FetchFileForm.vue b/src/views/Rule/actionForms/FetchFileForm.vue
new file mode 100644
index 000000000..ec86b61d8
--- /dev/null
+++ b/src/views/Rule/actionForms/FetchFileForm.vue
@@ -0,0 +1,182 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  FetchFileForm — SynchronizationService::processFetchFileRule reads
+  `source`, `filePath`, `endpoint`, `objectIdPath`, `originIdPath`,
+  `contentPath`, `filenamePath`, `fileExtension`, `subObjectFilepath`,
+  `tags`, `autoShare`, `sourceConfiguration` (JSON blob).
+
+  Source picker resolves OpenConnector sources via OpenRegister.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Source') }}</label>
+		<NcSelect
+			data-testid="action-form-fetch-source"
+			:value="selectedSource"
+			:options="sourceOptions"
+			:loading="sourcesLoading"
+			:placeholder="t('openconnector', 'Select a source')"
+			@input="onSourcePick" />
+
+		<NcTextField
+			:label="t('openconnector', 'File path (dot path)')"
+			:value="value.filePath || ''"
+			placeholder="body.attachment.url"
+			@update:value="(next) => patch('filePath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Endpoint (optional)')"
+			:value="value.endpoint || ''"
+			placeholder="https://upstream/file/123"
+			@update:value="(next) => patch('endpoint', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Object ID path (optional)')"
+			:value="value.objectIdPath || ''"
+			placeholder="body.id"
+			@update:value="(next) => patch('objectIdPath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Origin ID path (optional)')"
+			:value="value.originIdPath || ''"
+			placeholder="body.origin.id"
+			@update:value="(next) => patch('originIdPath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Content path (optional)')"
+			:value="value.contentPath || ''"
+			placeholder="body.attachment.content"
+			@update:value="(next) => patch('contentPath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Filename path (optional)')"
+			:value="value.filenamePath || ''"
+			placeholder="body.attachment.name"
+			@update:value="(next) => patch('filenamePath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'File extension (optional)')"
+			:value="value.fileExtension || ''"
+			placeholder="pdf"
+			@update:value="(next) => patch('fileExtension', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Sub-object filepath (optional)')"
+			:value="value.subObjectFilepath || ''"
+			placeholder="body.objects.0.url"
+			@update:value="(next) => patch('subObjectFilepath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Tags (comma-separated)')"
+			:value="csv(value.tags)"
+			placeholder="invoice,inbox"
+			@update:value="(next) => patch('tags', toArray(next))" />
+		<NcCheckboxRadioSwitch
+			type="switch"
+			:checked="!!value.autoShare"
+			@update:checked="(next) => patch('autoShare', !!next)">
+			{{ t('openconnector', 'Auto-share fetched files') }}
+		</NcCheckboxRadioSwitch>
+
+		<label class="action-form__label" :for="'rule-fetch-source-config-' + uid">
+			{{ t('openconnector', 'Source configuration (JSON, optional)') }}
+		</label>
+		<textarea
+			:id="'rule-fetch-source-config-' + uid"
+			class="action-form__textarea action-form__textarea--code"
+			:value="sourceConfigDraft"
+			spellcheck="false"
+			rows="5"
+			placeholder="[]"
+			@input="onSourceConfigInput" />
+		<span v-if="sourceConfigError" class="action-form__helper action-form__helper--error">
+			{{ sourceConfigError }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcCheckboxRadioSwitch, NcSelect, NcTextField } from '@nextcloud/vue'
+import { fetchOpenRegisterCollection, patchMethod, valueProp } from './shared.js'
+
+let uidCounter = 0
+
+export default {
+	name: 'FetchFileForm',
+	components: { NcCheckboxRadioSwitch, NcSelect, NcTextField },
+	props: { ...valueProp },
+	data() {
+		return {
+			uid: ++uidCounter,
+			sourceOptions: [],
+			sourcesLoading: false,
+			sourceConfigDraft: '',
+			sourceConfigError: '',
+		}
+	},
+	computed: {
+		selectedSource() {
+			const id = String(this.value?.source || '')
+			if (!id) return null
+			return this.sourceOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+	},
+	watch: {
+		// Keep textarea in sync if parent feeds in a value from a remote
+		// fetch. Drift is rare because the rule loads once.
+		'value.sourceConfiguration'(next) {
+			const serialized = this.serialiseSourceConfig(next)
+			if (serialized !== this.sourceConfigDraft) {
+				this.sourceConfigDraft = serialized
+			}
+		},
+	},
+	async mounted() {
+		this.sourcesLoading = true
+		this.sourceOptions = await fetchOpenRegisterCollection('source')
+		this.sourcesLoading = false
+		this.sourceConfigDraft = this.serialiseSourceConfig(this.value?.sourceConfiguration)
+	},
+	methods: {
+		patch: patchMethod(),
+		onSourcePick(option) {
+			this.patch('source', option?.id ? String(option.id) : '')
+		},
+		csv(value) {
+			return Array.isArray(value) ? value.join(',') : (value || '')
+		},
+		toArray(text) {
+			return (text || '').split(',').map((entry) => entry.trim()).filter(Boolean)
+		},
+		serialiseSourceConfig(value) {
+			if (value === undefined || value === null) return ''
+			if (typeof value === 'string') return value
+			try { return JSON.stringify(value, null, 2) } catch (_e) { return String(value) }
+		},
+		onSourceConfigInput(event) {
+			const raw = event.target.value
+			this.sourceConfigDraft = raw
+			if (raw.trim().length === 0) {
+				this.sourceConfigError = ''
+				const next = { ...(this.value || {}) }
+				delete next.sourceConfiguration
+				this.$emit('update:value', next)
+				return
+			}
+			try {
+				const parsed = JSON.parse(raw)
+				this.sourceConfigError = ''
+				this.patch('sourceConfiguration', parsed)
+			} catch (parseErr) {
+				this.sourceConfigError = this.t('openconnector', 'Invalid JSON: {message}', { message: parseErr.message })
+			}
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+.action-form__helper--error { color: var(--color-error); }
+.action-form__textarea {
+	width: 100%; padding: 8px; font-family: var(--font-face, sans-serif);
+	font-size: 14px; background: var(--color-main-background); color: var(--color-main-text);
+	border: 1px solid var(--color-border); border-radius: var(--border-radius); resize: vertical;
+}
+.action-form__textarea--code { font-family: var(--font-face-monospace, monospace); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/FilepartUploadForm.vue b/src/views/Rule/actionForms/FilepartUploadForm.vue
new file mode 100644
index 000000000..9294265b1
--- /dev/null
+++ b/src/views/Rule/actionForms/FilepartUploadForm.vue
@@ -0,0 +1,65 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  FilepartUploadForm — EndpointService::processFilePartUploadRule
+  reads `mappingId` (required) plus an optional `mappingOutId`.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Inbound mapping (required)') }}</label>
+		<NcSelect
+			data-testid="action-form-filepart-upload-mapping"
+			:value="selectedInbound"
+			:options="mappingOptions"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Select a mapping')"
+			@input="(option) => patch('mappingId', option?.id ? String(option.id) : '')" />
+
+		<label class="action-form__label">{{ t('openconnector', 'Outbound mapping (optional)') }}</label>
+		<NcSelect
+			:value="selectedOutbound"
+			:options="mappingOptions"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Select a mapping')"
+			@input="(option) => patch('mappingOutId', option?.id ? String(option.id) : '')" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'Inbound runs before the part is written; outbound runs over the written object before it returns.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcSelect } from '@nextcloud/vue'
+import { fetchOpenRegisterCollection, patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'FilepartUploadForm',
+	components: { NcSelect },
+	props: { ...valueProp },
+	data() { return { mappingOptions: [], loading: false } },
+	computed: {
+		selectedInbound() {
+			const id = String(this.value?.mappingId || '')
+			if (!id) return null
+			return this.mappingOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+		selectedOutbound() {
+			const id = String(this.value?.mappingOutId || '')
+			if (!id) return null
+			return this.mappingOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+	},
+	async mounted() {
+		this.loading = true
+		this.mappingOptions = await fetchOpenRegisterCollection('mapping')
+		this.loading = false
+	},
+	methods: { patch: patchMethod() },
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/FilepartsCreateForm.vue b/src/views/Rule/actionForms/FilepartsCreateForm.vue
new file mode 100644
index 000000000..363a190ee
--- /dev/null
+++ b/src/views/Rule/actionForms/FilepartsCreateForm.vue
@@ -0,0 +1,90 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  FilepartsCreateForm — EndpointService::processFilePartRule reads
+  `sizeLocation` (required), `schemaId`, `filenameLocation`,
+  `filePartLocation`, `mappingId`.
+-->
+<template>
+	<div class="action-form">
+		<NcTextField
+			:label="t('openconnector', 'Size location (dot path, required)')"
+			:value="value.sizeLocation || ''"
+			placeholder="body.size"
+			@update:value="(next) => patch('sizeLocation', next)" />
+		<label class="action-form__label">{{ t('openconnector', 'Schema') }}</label>
+		<NcSelect
+			data-testid="action-form-fileparts-schema"
+			:value="selectedSchema"
+			:options="schemaOptions"
+			:loading="schemasLoading"
+			:placeholder="t('openconnector', 'Select a schema')"
+			@input="(option) => patch('schemaId', option?.id ? String(option.id) : '')" />
+		<NcTextField
+			:label="t('openconnector', 'Filename location (default: filename)')"
+			:value="value.filenameLocation || ''"
+			placeholder="filename"
+			@update:value="(next) => patch('filenameLocation', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Filepart location (default: fileParts)')"
+			:value="value.filePartLocation || ''"
+			placeholder="fileParts"
+			@update:value="(next) => patch('filePartLocation', next)" />
+		<label class="action-form__label">{{ t('openconnector', 'Mapping (optional)') }}</label>
+		<NcSelect
+			:value="selectedMapping"
+			:options="mappingOptions"
+			:loading="mappingsLoading"
+			:placeholder="t('openconnector', 'Pick a mapping')"
+			@input="(option) => patch('mappingId', option?.id ? String(option.id) : '')" />
+	</div>
+</template>
+
+<script>
+import { NcSelect, NcTextField } from '@nextcloud/vue'
+import { fetchOpenRegisterCollection, patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'FilepartsCreateForm',
+	components: { NcSelect, NcTextField },
+	props: { ...valueProp },
+	data() {
+		return {
+			schemaOptions: [],
+			schemasLoading: false,
+			mappingOptions: [],
+			mappingsLoading: false,
+		}
+	},
+	computed: {
+		selectedSchema() {
+			const id = String(this.value?.schemaId || '')
+			if (!id) return null
+			return this.schemaOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+		selectedMapping() {
+			const id = String(this.value?.mappingId || '')
+			if (!id) return null
+			return this.mappingOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+	},
+	async mounted() {
+		this.schemasLoading = true
+		this.mappingsLoading = true
+		const [schemas, mappings] = await Promise.all([
+			fetchOpenRegisterCollection('schema', 'openregister'),
+			fetchOpenRegisterCollection('mapping'),
+		])
+		this.schemaOptions = schemas
+		this.mappingOptions = mappings
+		this.schemasLoading = false
+		this.mappingsLoading = false
+	},
+	methods: { patch: patchMethod() },
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+</style>
diff --git a/src/views/Rule/actionForms/JavascriptForm.vue b/src/views/Rule/actionForms/JavascriptForm.vue
new file mode 100644
index 000000000..04c91b8d0
--- /dev/null
+++ b/src/views/Rule/actionForms/JavascriptForm.vue
@@ -0,0 +1,49 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  JavascriptForm — single-textarea code editor for the `javascript`
+  action. Stored as a bare string at `configuration.javascript`.
+  EndpointService::processJavaScriptRule is currently a stub but we
+  preserve the legacy modal's shape so it round-trips cleanly.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label" :for="'rule-action-js-' + uid">
+			{{ t('openconnector', 'JavaScript code') }}
+		</label>
+		<textarea
+			:id="'rule-action-js-' + uid"
+			class="action-form__textarea action-form__textarea--code"
+			:value="code"
+			spellcheck="false"
+			rows="10"
+			:placeholder="t('openconnector', 'Enter your JavaScript code here...')"
+			@input="(event) => $emit('update:code', event.target.value)" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'Sandboxed script that runs against the request data. Stored as configuration.javascript.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+let uidCounter = 0
+export default {
+	name: 'JavascriptForm',
+	props: {
+		code: { type: String, default: '' },
+	},
+	data() { return { uid: ++uidCounter } },
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+.action-form__textarea {
+	width: 100%; padding: 8px; font-family: var(--font-face, sans-serif);
+	font-size: 14px; background: var(--color-main-background); color: var(--color-main-text);
+	border: 1px solid var(--color-border); border-radius: var(--border-radius); resize: vertical;
+}
+.action-form__textarea--code { font-family: var(--font-face-monospace, monospace); font-size: 13px; }
+</style>
diff --git a/src/views/Rule/actionForms/LockingForm.vue b/src/views/Rule/actionForms/LockingForm.vue
new file mode 100644
index 000000000..e3e6f64b3
--- /dev/null
+++ b/src/views/Rule/actionForms/LockingForm.vue
@@ -0,0 +1,74 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  LockingForm — EndpointService::processLockingRule reads
+  `configuration.locking.action` (lock|unlock) and `duration` (seconds,
+  default 3600). Legacy modal used `timeout` (minutes); we expose both
+  knobs but the backend currently honours `duration`.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Lock action') }}</label>
+		<NcSelect
+			:value="selectedAction"
+			:options="actionOptions"
+			:clearable="false"
+			@input="onActionPick" />
+		<NcTextField
+			:label="t('openconnector', 'Duration (seconds, default 3600)')"
+			type="number"
+			:value="value.duration != null ? String(value.duration) : ''"
+			placeholder="3600"
+			@update:value="onDurationInput" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'Lock or unlock the object identified by the request. Duration only applies to lock; unlock ignores it.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcSelect, NcTextField } from '@nextcloud/vue'
+import { patchMethod, valueProp } from './shared.js'
+
+const LOCK_ACTIONS = [
+	{ id: 'lock', label: 'Lock resource' },
+	{ id: 'unlock', label: 'Unlock resource' },
+]
+
+export default {
+	name: 'LockingForm',
+	components: { NcSelect, NcTextField },
+	props: { ...valueProp },
+	computed: {
+		actionOptions() {
+			return LOCK_ACTIONS.map((row) => ({ id: row.id, label: this.t('openconnector', row.label) }))
+		},
+		selectedAction() {
+			return this.actionOptions.find((opt) => opt.id === this.value.action) || null
+		},
+	},
+	methods: {
+		patch: patchMethod(),
+		onActionPick(option) {
+			this.patch('action', option?.id || '')
+		},
+		onDurationInput(raw) {
+			if (raw === '' || raw == null) {
+				const next = { ...(this.value || {}) }
+				delete next.duration
+				this.$emit('update:value', next)
+				return
+			}
+			const num = Number(raw)
+			if (Number.isNaN(num)) return
+			this.patch('duration', num)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/MappingForm.vue b/src/views/Rule/actionForms/MappingForm.vue
new file mode 100644
index 000000000..c7296d0a3
--- /dev/null
+++ b/src/views/Rule/actionForms/MappingForm.vue
@@ -0,0 +1,64 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  MappingForm — picks the mapping that EndpointService::processMappingRule
+  feeds to mappingService->getMapping(). Stored as a single id string at
+  configuration.mapping, NOT under configuration[<type>]. We surface it
+  here regardless so the UI is uniform; the parent RuleActionConfig
+  knows to write this slot to `configuration.mapping` rather than
+  `configuration.mapping.mapping`.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Mapping') }}</label>
+		<NcSelect
+			data-testid="action-form-mapping"
+			:value="selected"
+			:options="options"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Select a mapping')"
+			@input="onPick" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'Pick the mapping that will transform the request/response body.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcSelect } from '@nextcloud/vue'
+import { fetchOpenRegisterCollection } from './shared.js'
+
+export default {
+	name: 'MappingForm',
+	components: { NcSelect },
+	props: {
+		// For mapping, the raw value is a bare id string at
+		// `configuration.mapping`. Parent supplies it via the `id` prop.
+		id: { type: [String, Number, null], default: '' },
+	},
+	data() { return { options: [], loading: false } },
+	computed: {
+		selected() {
+			const idStr = String(this.id || '')
+			if (!idStr) return null
+			return this.options.find((opt) => opt.id === idStr) ?? { id: idStr, label: idStr }
+		},
+	},
+	async mounted() {
+		this.loading = true
+		this.options = await fetchOpenRegisterCollection('mapping')
+		this.loading = false
+	},
+	methods: {
+		onPick(option) {
+			this.$emit('update:id', option?.id ? String(option.id) : '')
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/SaveObjectForm.vue b/src/views/Rule/actionForms/SaveObjectForm.vue
new file mode 100644
index 000000000..e6b2df19a
--- /dev/null
+++ b/src/views/Rule/actionForms/SaveObjectForm.vue
@@ -0,0 +1,90 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  SaveObjectForm — EndpointService::processSaveObjectRule reads
+  `register`, `schema`, and an optional `mapping` id (applied before
+  save).
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Register (required)') }}</label>
+		<NcSelect
+			data-testid="action-form-save-register"
+			:value="selectedRegister"
+			:options="registerOptions"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Select a register')"
+			@input="(option) => patch('register', option?.id ? String(option.id) : '')" />
+
+		<label class="action-form__label">{{ t('openconnector', 'Schema (required)') }}</label>
+		<NcSelect
+			data-testid="action-form-save-schema"
+			:value="selectedSchema"
+			:options="schemaOptions"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Select a schema')"
+			@input="(option) => patch('schema', option?.id ? String(option.id) : '')" />
+
+		<label class="action-form__label">{{ t('openconnector', 'Mapping (optional)') }}</label>
+		<NcSelect
+			:value="selectedMapping"
+			:options="mappingOptions"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Pick a mapping to transform before save')"
+			@input="(option) => patch('mapping', option?.id ? String(option.id) : '')" />
+	</div>
+</template>
+
+<script>
+import { NcSelect } from '@nextcloud/vue'
+import { fetchOpenRegisterCollection, patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'SaveObjectForm',
+	components: { NcSelect },
+	props: { ...valueProp },
+	data() {
+		return {
+			registerOptions: [],
+			schemaOptions: [],
+			mappingOptions: [],
+			loading: false,
+		}
+	},
+	computed: {
+		selectedRegister() {
+			const id = String(this.value?.register || '')
+			if (!id) return null
+			return this.registerOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+		selectedSchema() {
+			const id = String(this.value?.schema || '')
+			if (!id) return null
+			return this.schemaOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+		selectedMapping() {
+			const id = String(this.value?.mapping || '')
+			if (!id) return null
+			return this.mappingOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+	},
+	async mounted() {
+		this.loading = true
+		const [registers, schemas, mappings] = await Promise.all([
+			fetchOpenRegisterCollection('register', 'openregister'),
+			fetchOpenRegisterCollection('schema', 'openregister'),
+			fetchOpenRegisterCollection('mapping'),
+		])
+		this.registerOptions = registers
+		this.schemaOptions = schemas
+		this.mappingOptions = mappings
+		this.loading = false
+	},
+	methods: { patch: patchMethod() },
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+</style>
diff --git a/src/views/Rule/actionForms/SynchronizationForm.vue b/src/views/Rule/actionForms/SynchronizationForm.vue
new file mode 100644
index 000000000..0c0096ecf
--- /dev/null
+++ b/src/views/Rule/actionForms/SynchronizationForm.vue
@@ -0,0 +1,119 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  SynchronizationForm — configures a `synchronization` action.
+
+  Fields mirror what EndpointService::processSyncRule reads at
+  evaluation time: `synchronization` (id), `retainResponse`,
+  `objectIdPath`, `preDelay`, `postDelay`. Picker shells the
+  OpenRegister `/objects/openconnector/synchronization` endpoint
+  once on mount.
+-->
+<template>
+	<div class="action-form">
+		<label class="action-form__label">{{ t('openconnector', 'Synchronization') }}</label>
+		<NcSelect
+			data-testid="action-form-sync"
+			:value="selectedSync"
+			:options="syncOptions"
+			:loading="loading"
+			:placeholder="t('openconnector', 'Select a synchronization')"
+			@input="onSyncPick" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'The synchronization that runs when this rule matches. Pick by name; the underlying UUID is what gets stored.') }}
+		</span>
+
+		<NcCheckboxRadioSwitch
+			type="switch"
+			:checked="!!value.retainResponse"
+			@update:checked="(next) => patch('retainResponse', !!next)">
+			{{ t('openconnector', 'Retain original response') }}
+		</NcCheckboxRadioSwitch>
+		<span class="action-form__helper">
+			{{ t('openconnector', 'When enabled, the sync still runs but the rule preserves the original response body instead of replacing it.') }}
+		</span>
+
+		<NcTextField
+			:label="t('openconnector', 'Object ID path (optional)')"
+			:value="value.objectIdPath || ''"
+			placeholder="body.id"
+			@update:value="(next) => patch('objectIdPath', next)" />
+
+		<div class="action-form__row">
+			<NcTextField
+				:label="t('openconnector', 'Pre-delay (seconds)')"
+				type="number"
+				:value="value.preDelay != null ? String(value.preDelay) : ''"
+				placeholder="0"
+				@update:value="(next) => patchNumber('preDelay', next)" />
+			<NcTextField
+				:label="t('openconnector', 'Post-delay (seconds)')"
+				type="number"
+				:value="value.postDelay != null ? String(value.postDelay) : ''"
+				placeholder="0"
+				@update:value="(next) => patchNumber('postDelay', next)" />
+		</div>
+	</div>
+</template>
+
+<script>
+import { NcCheckboxRadioSwitch, NcSelect, NcTextField } from '@nextcloud/vue'
+import { fetchOpenRegisterCollection, patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'SynchronizationForm',
+	components: { NcCheckboxRadioSwitch, NcSelect, NcTextField },
+	props: { ...valueProp },
+	data() {
+		return { syncOptions: [], loading: false }
+	},
+	computed: {
+		// Both shapes round-trip — legacy `synchronization` was sometimes
+		// a bare id, sometimes nested under `synchronization.synchronization`.
+		syncId() {
+			return this.value?.synchronization || ''
+		},
+		selectedSync() {
+			const id = String(this.syncId)
+			if (!id) return null
+			return this.syncOptions.find((opt) => opt.id === id) ?? { id, label: id }
+		},
+	},
+	async mounted() {
+		this.loading = true
+		this.syncOptions = await fetchOpenRegisterCollection('synchronization')
+		this.loading = false
+	},
+	methods: {
+		patch: patchMethod(),
+		patchNumber(key, raw) {
+			if (raw === '' || raw == null) {
+				const next = { ...(this.value || {}) }
+				delete next[key]
+				this.$emit('update:value', next)
+				return
+			}
+			const num = Number(raw)
+			if (Number.isNaN(num)) return
+			this.patch(key, num)
+		},
+		onSyncPick(option) {
+			const next = { ...(this.value || {}) }
+			if (option?.id) {
+				next.synchronization = String(option.id)
+			} else {
+				delete next.synchronization
+			}
+			this.$emit('update:value', next)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__label { font-weight: bold; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+.action-form__row { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+@media (max-width: 720px) { .action-form__row { grid-template-columns: 1fr; } }
+</style>
diff --git a/src/views/Rule/actionForms/UploadForm.vue b/src/views/Rule/actionForms/UploadForm.vue
new file mode 100644
index 000000000..b3cbf459b
--- /dev/null
+++ b/src/views/Rule/actionForms/UploadForm.vue
@@ -0,0 +1,62 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  UploadForm — `upload` is not yet dispatched by the rule engine
+  (no `case 'upload'` in EndpointService) but the legacy modal
+  persisted `path`, `allowedTypes`, `maxSize`. We surface the same
+  fields so existing data round-trips and new rules can be authored
+  in anticipation of the backend handler landing.
+-->
+<template>
+	<div class="action-form">
+		<NcTextField
+			:label="t('openconnector', 'Upload path')"
+			:value="value.path || ''"
+			placeholder="/path/to/upload/directory"
+			@update:value="(next) => patch('path', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Allowed file types (comma-separated)')"
+			:value="value.allowedTypes || ''"
+			placeholder="jpg,png,pdf"
+			@update:value="(next) => patch('allowedTypes', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Max file size (MB)')"
+			type="number"
+			:value="value.maxSize != null ? String(value.maxSize) : ''"
+			placeholder="10"
+			@update:value="onMaxSizeInput" />
+		<span class="action-form__helper">
+			{{ t('openconnector', 'Note: the backend handler for upload is still pending. Configuration is persisted so it activates once the dispatcher case lands.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcTextField } from '@nextcloud/vue'
+import { patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'UploadForm',
+	components: { NcTextField },
+	props: { ...valueProp },
+	methods: {
+		patch: patchMethod(),
+		onMaxSizeInput(raw) {
+			if (raw === '' || raw == null) {
+				const next = { ...(this.value || {}) }
+				delete next.maxSize
+				this.$emit('update:value', next)
+				return
+			}
+			const num = Number(raw)
+			if (Number.isNaN(num)) return
+			this.patch('maxSize', num)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/WriteFileForm.vue b/src/views/Rule/actionForms/WriteFileForm.vue
new file mode 100644
index 000000000..cb85a7ac3
--- /dev/null
+++ b/src/views/Rule/actionForms/WriteFileForm.vue
@@ -0,0 +1,59 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 -->
+<!-- Copyright (C) 2026 Conduction B.V. -->
+<!--
+  WriteFileForm — EndpointService::processWriteFileRule reads
+  `filePath`, `fileNamePath`, `tags`, plus the auto-share toggle.
+-->
+<template>
+	<div class="action-form">
+		<NcTextField
+			:label="t('openconnector', 'File path (dot path on data, required)')"
+			:value="value.filePath || ''"
+			placeholder="body.attachment"
+			@update:value="(next) => patch('filePath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Filename path (dot path on data, required)')"
+			:value="value.fileNamePath || ''"
+			placeholder="body.filename"
+			@update:value="(next) => patch('fileNamePath', next)" />
+		<NcTextField
+			:label="t('openconnector', 'Tags (comma-separated)')"
+			:value="csv(value.tags)"
+			placeholder="invoice,outbox"
+			@update:value="(next) => patch('tags', toArray(next))" />
+		<NcCheckboxRadioSwitch
+			type="switch"
+			:checked="!!value.autoShare"
+			@update:checked="(next) => patch('autoShare', !!next)">
+			{{ t('openconnector', 'Auto-share written files') }}
+		</NcCheckboxRadioSwitch>
+		<span class="action-form__helper">
+			{{ t('openconnector', 'The dot path under the rule data tells the engine where to find the file bytes; the filename path supplies the name.') }}
+		</span>
+	</div>
+</template>
+
+<script>
+import { NcCheckboxRadioSwitch, NcTextField } from '@nextcloud/vue'
+import { patchMethod, valueProp } from './shared.js'
+
+export default {
+	name: 'WriteFileForm',
+	components: { NcCheckboxRadioSwitch, NcTextField },
+	props: { ...valueProp },
+	methods: {
+		patch: patchMethod(),
+		csv(value) {
+			return Array.isArray(value) ? value.join(',') : (value || '')
+		},
+		toArray(text) {
+			return (text || '').split(',').map((entry) => entry.trim()).filter(Boolean)
+		},
+	},
+}
+</script>
+
+<style scoped>
+.action-form { display: flex; flex-direction: column; gap: 10px; }
+.action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+</style>
diff --git a/src/views/Rule/actionForms/shared.js b/src/views/Rule/actionForms/shared.js
new file mode 100644
index 000000000..be612239b
--- /dev/null
+++ b/src/views/Rule/actionForms/shared.js
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: EUPL-1.2
+// Copyright (C) 2026 Conduction B.V.
+
+/**
+ * Shared helpers for the bespoke per-action-type form SFCs under
+ * src/views/Rule/actionForms. Each form receives a `value` prop (the
+ * slice of `configuration[<type>]`) and emits `update:value` with the
+ * next slice; RuleActionConfig wraps that back into the full
+ * configuration blob.
+ *
+ * Picker helpers (`fetchOpenRegisterCollection`) follow the pattern
+ * established by RuleActionConfig.vue's `fetchSynchronizations` — load
+ * once on demand, no Vuex, no global cache.
+ */
+
+import axios from '@nextcloud/axios'
+import { generateUrl } from '@nextcloud/router'
+
+/**
+ * Fetch a paginated list of OpenRegister objects for picker
+ * components. Tolerates both `{ results: [] }` and bare arrays.
+ *
+ * @param {string} schema  OpenRegister schema slug (e.g. 'synchronization').
+ * @param {string} register Register slug (defaults to 'openconnector').
+ * @param {number} limit   Max rows to load (default 500).
+ * @return {Promise<Array<{ id: string, label: string, raw: object }>>}
+ *   Resolved options ready for NcSelect.
+ */
+export async function fetchOpenRegisterCollection(schema, register = 'openconnector', limit = 500) {
+	try {
+		const response = await axios.get(
+			generateUrl(`/apps/openregister/api/objects/${register}/${schema}`),
+			{ params: { limit } },
+		)
+		const data = response.data
+		const list = Array.isArray(data?.results)
+			? data.results
+			: Array.isArray(data)
+				? data
+				: []
+		return list.map((row) => ({
+			id: String(row.id || row.uuid),
+			label: row.name || row.title || row.id || '(unnamed)',
+			raw: row,
+		}))
+	} catch (err) {
+		// eslint-disable-next-line no-console
+		console.warn(`[actionForms] fetch ${register}/${schema} failed`, err)
+		return []
+	}
+}
+
+/**
+ * Mixin-like default behaviour: every action form uses the same
+ * `value` ↔ `update:value` contract, so we centralise the props
+ * declaration and the patch helper here. Components spread this into
+ * their `props` / `methods` to stay terse.
+ */
+export const valueProp = {
+	value: { type: Object, default: () => ({}) },
+}
+
+/**
+ * Patch-helper factory — returns a closure that, when called from a
+ * Vue component as `this.patch('field', newValue)`, emits an updated
+ * copy of the form's `value` with that key/value pair applied.
+ *
+ * The returned function takes:
+ *   - key  {string} Field name within the action's config slot.
+ *   - next {*}      New value to write at that key.
+ *
+ * @return {Function} The patch closure to be installed on a component.
+ */
+export function patchMethod() {
+	return function patch(key, next) {
+		const base = (this.value && typeof this.value === 'object') ? this.value : {}
+		const merged = { ...base, [key]: next }
+		this.$emit('update:value', merged)
+	}
+}

From b7ab8f8c0808b106fa358725b6a0621a02b8ebf9 Mon Sep 17 00:00:00 2001
From: Ruben van der Linde <ruben@conduction.nl>
Date: Sat, 23 May 2026 10:56:37 +0200
Subject: [PATCH 2/2] fix(rule-editor): satisfy stylelint
 rule-empty-line-before

---
 src/views/Rule/actionForms/AuthenticationForm.vue      | 2 ++
 src/views/Rule/actionForms/DownloadForm.vue            | 1 +
 src/views/Rule/actionForms/ErrorForm.vue               | 2 ++
 src/views/Rule/actionForms/ExtendExternalInputForm.vue | 2 ++
 src/views/Rule/actionForms/ExtendInputForm.vue         | 2 ++
 src/views/Rule/actionForms/FetchFileForm.vue           | 5 +++++
 src/views/Rule/actionForms/FilepartUploadForm.vue      | 2 ++
 src/views/Rule/actionForms/FilepartsCreateForm.vue     | 1 +
 src/views/Rule/actionForms/JavascriptForm.vue          | 4 ++++
 src/views/Rule/actionForms/LockingForm.vue             | 2 ++
 src/views/Rule/actionForms/MappingForm.vue             | 2 ++
 src/views/Rule/actionForms/SaveObjectForm.vue          | 1 +
 src/views/Rule/actionForms/SynchronizationForm.vue     | 3 +++
 src/views/Rule/actionForms/UploadForm.vue              | 1 +
 src/views/Rule/actionForms/WriteFileForm.vue           | 1 +
 15 files changed, 31 insertions(+)

diff --git a/src/views/Rule/actionForms/AuthenticationForm.vue b/src/views/Rule/actionForms/AuthenticationForm.vue
index 51b7a541d..c7ba9c254 100644
--- a/src/views/Rule/actionForms/AuthenticationForm.vue
+++ b/src/views/Rule/actionForms/AuthenticationForm.vue
@@ -86,6 +86,8 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/DownloadForm.vue b/src/views/Rule/actionForms/DownloadForm.vue
index 67e7b46a8..b48a6a6a6 100644
--- a/src/views/Rule/actionForms/DownloadForm.vue
+++ b/src/views/Rule/actionForms/DownloadForm.vue
@@ -53,5 +53,6 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/ErrorForm.vue b/src/views/Rule/actionForms/ErrorForm.vue
index 1b8d0d9fd..6ae5c8b06 100644
--- a/src/views/Rule/actionForms/ErrorForm.vue
+++ b/src/views/Rule/actionForms/ErrorForm.vue
@@ -67,7 +67,9 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__textarea {
 	width: 100%; padding: 8px; font-family: var(--font-face, sans-serif);
 	font-size: 14px; background: var(--color-main-background); color: var(--color-main-text);
diff --git a/src/views/Rule/actionForms/ExtendExternalInputForm.vue b/src/views/Rule/actionForms/ExtendExternalInputForm.vue
index c13d83f79..df216e0f9 100644
--- a/src/views/Rule/actionForms/ExtendExternalInputForm.vue
+++ b/src/views/Rule/actionForms/ExtendExternalInputForm.vue
@@ -97,7 +97,9 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__row { display: grid; grid-template-columns: 1fr 1fr auto; gap: 8px; align-items: end; }
 @media (max-width: 720px) { .action-form__row { grid-template-columns: 1fr; } }
 </style>
diff --git a/src/views/Rule/actionForms/ExtendInputForm.vue b/src/views/Rule/actionForms/ExtendInputForm.vue
index 6d4c36f12..36f3f87f6 100644
--- a/src/views/Rule/actionForms/ExtendInputForm.vue
+++ b/src/views/Rule/actionForms/ExtendInputForm.vue
@@ -109,7 +109,9 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__row { display: grid; grid-template-columns: 1fr 1fr auto; gap: 8px; align-items: end; }
 @media (max-width: 720px) { .action-form__row { grid-template-columns: 1fr; } }
 </style>
diff --git a/src/views/Rule/actionForms/FetchFileForm.vue b/src/views/Rule/actionForms/FetchFileForm.vue
index ec86b61d8..9d144dca4 100644
--- a/src/views/Rule/actionForms/FetchFileForm.vue
+++ b/src/views/Rule/actionForms/FetchFileForm.vue
@@ -170,13 +170,18 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+
 .action-form__helper--error { color: var(--color-error); }
+
 .action-form__textarea {
 	width: 100%; padding: 8px; font-family: var(--font-face, sans-serif);
 	font-size: 14px; background: var(--color-main-background); color: var(--color-main-text);
 	border: 1px solid var(--color-border); border-radius: var(--border-radius); resize: vertical;
 }
+
 .action-form__textarea--code { font-family: var(--font-face-monospace, monospace); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/FilepartUploadForm.vue b/src/views/Rule/actionForms/FilepartUploadForm.vue
index 9294265b1..35a0ee2ec 100644
--- a/src/views/Rule/actionForms/FilepartUploadForm.vue
+++ b/src/views/Rule/actionForms/FilepartUploadForm.vue
@@ -60,6 +60,8 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/FilepartsCreateForm.vue b/src/views/Rule/actionForms/FilepartsCreateForm.vue
index 363a190ee..a78ec3da5 100644
--- a/src/views/Rule/actionForms/FilepartsCreateForm.vue
+++ b/src/views/Rule/actionForms/FilepartsCreateForm.vue
@@ -86,5 +86,6 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
 </style>
diff --git a/src/views/Rule/actionForms/JavascriptForm.vue b/src/views/Rule/actionForms/JavascriptForm.vue
index 04c91b8d0..d6e938853 100644
--- a/src/views/Rule/actionForms/JavascriptForm.vue
+++ b/src/views/Rule/actionForms/JavascriptForm.vue
@@ -38,12 +38,16 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+
 .action-form__textarea {
 	width: 100%; padding: 8px; font-family: var(--font-face, sans-serif);
 	font-size: 14px; background: var(--color-main-background); color: var(--color-main-text);
 	border: 1px solid var(--color-border); border-radius: var(--border-radius); resize: vertical;
 }
+
 .action-form__textarea--code { font-family: var(--font-face-monospace, monospace); font-size: 13px; }
 </style>
diff --git a/src/views/Rule/actionForms/LockingForm.vue b/src/views/Rule/actionForms/LockingForm.vue
index e3e6f64b3..63e817ed8 100644
--- a/src/views/Rule/actionForms/LockingForm.vue
+++ b/src/views/Rule/actionForms/LockingForm.vue
@@ -69,6 +69,8 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/MappingForm.vue b/src/views/Rule/actionForms/MappingForm.vue
index c7296d0a3..05cc85013 100644
--- a/src/views/Rule/actionForms/MappingForm.vue
+++ b/src/views/Rule/actionForms/MappingForm.vue
@@ -59,6 +59,8 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/SaveObjectForm.vue b/src/views/Rule/actionForms/SaveObjectForm.vue
index e6b2df19a..24104d370 100644
--- a/src/views/Rule/actionForms/SaveObjectForm.vue
+++ b/src/views/Rule/actionForms/SaveObjectForm.vue
@@ -86,5 +86,6 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
 </style>
diff --git a/src/views/Rule/actionForms/SynchronizationForm.vue b/src/views/Rule/actionForms/SynchronizationForm.vue
index 0c0096ecf..551c831ad 100644
--- a/src/views/Rule/actionForms/SynchronizationForm.vue
+++ b/src/views/Rule/actionForms/SynchronizationForm.vue
@@ -112,8 +112,11 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__label { font-weight: bold; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
+
 .action-form__row { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
 @media (max-width: 720px) { .action-form__row { grid-template-columns: 1fr; } }
 </style>
diff --git a/src/views/Rule/actionForms/UploadForm.vue b/src/views/Rule/actionForms/UploadForm.vue
index b3cbf459b..b9e660ed4 100644
--- a/src/views/Rule/actionForms/UploadForm.vue
+++ b/src/views/Rule/actionForms/UploadForm.vue
@@ -58,5 +58,6 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>
diff --git a/src/views/Rule/actionForms/WriteFileForm.vue b/src/views/Rule/actionForms/WriteFileForm.vue
index cb85a7ac3..b36fd8bb8 100644
--- a/src/views/Rule/actionForms/WriteFileForm.vue
+++ b/src/views/Rule/actionForms/WriteFileForm.vue
@@ -55,5 +55,6 @@ export default {
 
 <style scoped>
 .action-form { display: flex; flex-direction: column; gap: 10px; }
+
 .action-form__helper { color: var(--color-text-maxcontrast); font-size: 12px; }
 </style>