@@ -713,3 +713,4 @@
 {"area": "mdl/executor", "date": "2026-09-25", "symptom": "`textbox t (Attribute: FullName)` at the top of a page (CREATE PAGE/SNIPPET, a plain container, or ALTER PAGE … INSERT at page level) passed plain `mxcli check`, `exec --no-check`/ALTER reported success, and `bson dump` showed `AttributeRef: null` — mxbuild 11.13.0: CE0544 \"This widget can only function inside a data context\" + CE7005 (textbox/textarea/datepicker/checkbox/radiobuttons/dropdown), CE0402 (dynamictext Attribute:), CE0642 (combobox). Qualified `Mod.Ent.Attr` there is stored and fails CE0544/CE2421/CE1365/CE7247 \"Move this widget into a data container\" + CE7006. `Attribute: $P/Attr` / `$currentObject/Attr` dropped even INSIDE a data view.", "cause": "resolveAttributePath returns the bare name when entityContext is \"\", and attributeRefToGen (and widgetobj setAttributeRefField) write nil for any path with < 2 dots, so the binding vanished between builder and writer; refuseBareAttributeRefs never sees it because no Attribute string is emitted. The only refusal (validatePageContextTree) runs in the --references phase for CREATE PAGE/SNIPPET, so plain check, --no-check and ALTER were unguarded. `$x/Attr` parses via the generic property rule as an *ast.DataSourceV3, so GetAttribute() returns \"\" and every builder skipped it.", "file": "mdl/executor/cmd_pages_input_binding_context.go (inputBindingProblem, checkInputBinding, validateInputBindingContext = MDL-WIDGET34), wired in cmd_pages_builder_v3_widgets.go (6 input builders + buildDynamicTextV3), widget_engine.go (primary Attribute mapping), validate_widgets.go (validateWidgetTreeIn); tests cmd_pages_input_binding_context_test.go; bug-tests input-binding-without-context{,.fail}.mdl", "insight": "Reuse the MDL-PAGEARG01 three-state context (pageArgContext known/present) rather than entityContext==\"\" as the 'outside a data container' signal: entityContext is also empty INSIDE a container whose flow cannot be resolved (excluded ShareFeedback_Logo), where DESCRIBE writes qualified names that must keep building — refusing qualified-on-empty-entity would have broken that round trip. So known-absent context refuses bare AND qualified; unknown context (ALTER) refuses only the bare name the writer provably nulls. Two existing unit tests (OnChangeSurvivesBuilder, DynamicTextV3_AttributeBinds) built inputs with NO entity and passed — the second asserted a bare `Title` AttributeRef counted as 'bound', i.e. it pinned the bug: when a fixture has no entity context, ask what the writer does with its output. The `$P/Attr` drop was found only by dumping the control page, not from the report — print the AST value type with a probe test before assuming a spelling reaches the builder. Evidence: 22 mxbuild errors before on the probe matrix; after, every case refused with nothing written, controls (dataview/listview/gallery/datagrid/snippet dataview/ALTER into dataview) 0 errors, 17/17 stock pages + 4/4 snippets describe→exec round trip.", "refs": ["MDL-WIDGET34"], "ce": ["CE0544", "CE7005", "CE0402", "CE0642", "CE2421", "CE1365", "CE7247", "CE7006"]}
 {"area":"mdl/executor","date":"2026-09-25","symptom":"`alter page FeedbackModule.ShareFeedback_Logo { insert after textBox1 { image zzImg (ImageType: imageUrl, ImageUrl: '{1}', ImageUrlParams: [{1} = ImageB64]) } }` passed `check --references`; exec wrote a bare AttributeRef and `mx check` could not LOAD the project (ArgumentNullException setting 'Attribute'). Same at page top level outside any data container; a text box's `Attribute:` there is silently dropped (CE7005).","cause":"ALTER's entity context comes from the STORED document (nearest enclosing data source, or a flow source's return type via resolveDataSourceFlowEntity). With the flow missing (Feedback v4.0.2 ships no DS_FeedbackForm) or no container at all, entityContext is \"\" and resolveAttributePath returns the bare name. CREATE PAGE refused this at check time (relaxExcludedWidgetRefs/unscopedBindings, #678); ALTER's check never opened the document, so nothing could know the scope.","file":"mdl/executor/validate_alter_unscoped.go, mdl/executor/cmd_alter_page.go (alterEntityContext), mdl/executor/validate.go (bindingsWithoutScope)","insight":"For ALTER, scope is a property of the stored document, not the statement: a check-time question about it must open the document (OpenPageForMutation, never Save; validate_alter_set.go already does this) and ask through the SAME function exec uses, so the INSERT/REPLACE entity resolution was lifted into alterEntityContext rather than restated, and the binding walk lifted out of unscopedBindings (bindingsWithoutScope) rather than copied. Controls that keep it from blocking working scripts: skip a target the stored doc lacks (added earlier in the script), a flow the script declares with an entity return (sc.flowParams), DataGrid2 column and list-view-template paths, and documents the script creates. Reproduce with a Studio Pro-authored page whose flow is genuinely absent.","refs":["#678","#685"]}
 {"area": "mdl/executor", "date": "2026-09-25", "symptom": "`describe page` on a File Uploader (files mode) emits `DataSource: association …`, and exec of that output fails: \"widget `upFiles` (fileuploader) exposes 2 datasources, so a generic `datasource:` clause is ambiguous — name the one you mean: associatedFiles, associatedImages\"", "cause": "DESCRIBE chose generic vs named by counting CONFIGURED datasources (namedCustomWidgetDataSources drops unset ones, so files mode = 1), while the builder's refuseAmbiguousGenericDataSource counts DECLARED datasource mappings (a generated def maps every top-level datasource = 2). Two sides of one round trip deciding the same question from different evidence.", "file": "mdl/executor/cmd_pages_describe_parse.go", "insight": "When describe and build each decide 'is this ambiguous?', they must count the same set. Fix read the DECLARED count from the stored schema (PropertyTypes with ValueType.Type=DataSource, excluding IsLinked) and excluded widgets with an embedded .def.json — those are hand-written and pick one datasource mapping per mode, so a database-mode ComboBox (two declared) must keep the generic clause. The #956 bug-test script itself authored the refused generic clause on a File Uploader: a bug-test that only runs `mxcli check` without a project can't see an exec-time refusal, so grep bug-tests for the old spelling whenever a builder starts refusing one.", "refs": ["mendixlabs/mxcli#1199", "mendixlabs/mxcli#956", "mendixlabs/mxcli#1109"], "rules": []}
+{"area": "mdl/executor", "date": "2026-09-26", "symptom": "`gallery g (…, OnClick: microflow M.Open(Item: $currentObject))`: check clean, exec 'Created page', stored gallery `onClick` is Forms$NoAction; describe shows no OnClick", "cause": "The Gallery definition in sdk/widgets/definitions is hand-written and never regenerated per project; it mapped `onClickTrigger` but not the `onClick` action, and `OnClick` is a built-in MDL property name so MDL-WIDGET01/06 never inspect it. Describe had no read for the gallery click slot either.", "file": "sdk/widgets/definitions/gallery.def.json", "insight": "Generated defs gained action mappings in generator version 13, but the nine hand-written definitions (combobox, gallery, image, filters, …) do not pass through the generator, so every generator-side fix skips them. When a generated-def fix lands, diff the hand-written defs against what the generator would emit for the same .mpk. Settled by reading back the stored WidgetValue.Action of the gallery's onClick property.", "rules": []}
@@ -571,6 +571,24 @@ gallery productGallery (datasource: database Module.Product, selection: single)
 }
 ```
 
+**With a click action** — `onclick:` on the gallery runs when an item is clicked,
+with the clicked item as `$currentObject` (the gallery's "On click action", the
+same slot as a Data grid 2 row click). Any action form works. It needs
+`selection: none`: the click that runs the action is the click that would select
+the item, and Mendix rejects the pair as ambiguous — the default selection is
+`Single`, so leaving it out is **MDL-WIDGET35**:
+```sql
+gallery orderGallery (
+  datasource: database Module.Order,
+  selection: none,
+  onclick: microflow Module.ACT_Order_Open(Order: $currentObject)
+) {
+  template template1 {
+    dynamictext orderNr (content: '{1}', contentparams: [{1} = Number])
+  }
+}
+```
+
 ### Filter Widgets
 
 A filter widget lives in one of two places: **inside a DATA GRID column's own braces**,
 
@@ -14,6 +14,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Fixed
 
+- **A Gallery's `OnClick:` was dropped without a word** — Gallery declares an `onClick` action for the clicked item, the slot a Data grid 2 row click lives in, but the hand-written Gallery definition mapped only `onClickTrigger`. `gallery g (…, OnClick: microflow M.Open(Item: $currentObject))` passed `check` (OnClick is a built-in property name, so nothing flagged it), `exec` said `Created page`, and the widget was stored with `Forms$NoAction`. It is now written as a `Forms$MicroflowAction` (or any other action) on the gallery's `onClick`, and `describe` prints it back. A click on an item also selects it, and Mendix rejects an item click action beside a selection (mx check: "The item click action is ambiguous"); Selection defaults to Single, so `OnClick:` on a gallery without `selection: none` is refused at check time (**MDL-WIDGET35**) instead of failing the build. `describe` now prints a gallery's stored `Selection: None`, which it used to omit — the default is Single, so a describe → exec round trip turned None into Single.
 - **Keyword operators were fused in some stored expressions** — a page action's microflow argument `Flag: $a and $b` was stored as `$aand$b`, `if $x then 'a' else 'b'` as `if$xthen'a'else'b'`; the same in `contentparams` values, `send rest request … with (…)` parameters and a dynamic `execute database query`. Those four places took the expression's text without its whitespace; literals, `+` and `$currentObject` were unaffected, which is why it went unnoticed, and `check --references` passed. Measured by decoding the stored units on a Mendix 11.14.0 project. The expression is now stored as written, with MDL comments removed, as the microflow expression sites already did.
 - **An input bound to an attribute outside any data container was written with no binding** — `textbox t (Attribute: FullName)` at the top of a page (or of a snippet, or inside a plain container) has no entity to qualify the name with, and the writer stored it as `AttributeRef: null`. Plain `check` passed, `exec --no-check` and `alter page … insert` at page level said success, and mxbuild 11.13.0 failed the page with CE0544 "This widget can only function inside a data context" + CE7005 (text box, text area, date picker, check box, radio buttons, drop-down), CE0402 (dynamic text `Attribute:`) or CE0642 (combo box). A qualified attribute there is stored and fails the same way (CE0544 / CE2421 / CE1365 / CE7247 "Move this widget into a data container"). `Attribute: $P/Name` and `Attribute: $currentObject/Name` never parsed as an attribute path and were dropped even inside a data view. `check` now reports all three as **MDL-WIDGET34** (no project needed), and the page builder refuses them with the widget named, so nothing is written; `alter page` refuses a bare name it has no entity for. Place the widget in a data view, list view, gallery or data grid and bind the attribute by name.
 - **An expression property written in brackets was silently dropped** (mendixlabs/mxcli#750) — `dynamicclasses: [ if $currentObject/Featured then 'a' else 'b' ]`, the spelling #750 proposes, parsed as a list that no writer reads: `check` was clean, `exec` said `Created page`, and the widget was stored with no dynamic class. `alter page … set DynamicClasses = [ … ]` said `Altered page` and changed nothing, and a column's `DynamicCellClass` stored the list's text — tokens fused, `[if$x/Ythen'a'else'b']` — as its expression. Measured on a copy of a Mendix 11.14.0 project with the pre-fix binary. `mxcli check` now reports **MDL-WIDGET32** for `DynamicClasses` and `DynamicCellClass` written as a list (no project needed), and ALTER refuses it, so `check -p` reports that too. Write the expression quoted.
 
@@ -224,6 +224,22 @@ GALLERY galBoard (
 }
 ```
 
+**Click action** — `OnClick:` runs when an item is clicked, with the clicked item
+as `$currentObject`. It takes any action form, as a button does. A click also
+selects an item, so Mendix accepts an item click action only on a gallery with
+`Selection: None`. Selection defaults to `Single`, so an `OnClick:` without
+`Selection: None` is refused (**MDL-WIDGET35**):
+
+```sql
+GALLERY galOrders (
+  DataSource: DATABASE MyModule.Order,
+  Selection: None,
+  OnClick: MICROFLOW MyModule.ACT_Order_Open(Order: $currentObject)
+) {
+  DYNAMICTEXT txtNr (Content: '{1}', Attribute: Number)
+}
+```
+
 ## Input Widgets
 
 All input widgets share common properties:
 
@@ -717,6 +717,9 @@ func outputWidgetMDLV3(ctx *ExecContext, w rawWidget, indent int) {
 			if w.Selection != "" {
 				props = append(props, fmt.Sprintf("Selection: %s", w.Selection))
 			}
+			if w.OnClick != "" {
+				props = append(props, actionProp("OnClick", w.OnClick))
+			}
 			props = appendAppearanceProps(props, w)
 			// Output filter and content widgets
 			hasContent := len(w.Children) > 0 || len(w.FilterWidgets) > 0
 
@@ -471,6 +471,12 @@ func parseRawWidget(ctx *ExecContext, w map[string]any, parentEntityContext ...s
 		if widget.RenderMode == "gallery" {
 			widget.DataSource = extractGalleryDataSource(ctx, w)
 			widget.Selection = extractGallerySelection(ctx, w)
+			// A stored None must be printed: the Gallery definition's default is
+			// Single, so leaving it out turned None into Single on describe ->
+			// exec — and a gallery with OnClick needs None (MDL-WIDGET35).
+			if widget.Selection == "" && customWidgetPropertySelection(w, "itemSelection") == "None" {
+				widget.Selection = "None"
+			}
 			widget.DesktopColumns = extractCustomWidgetPropertyString(ctx, w, "desktopItems")
 			widget.TabletColumns = extractCustomWidgetPropertyString(ctx, w, "tabletItems")
 			widget.PhoneColumns = extractCustomWidgetPropertyString(ctx, w, "phoneItems")
@@ -483,6 +489,9 @@ func parseRawWidget(ctx *ExecContext, w map[string]any, parentEntityContext ...s
 				return extractGalleryContent(ctx, w, widget.EntityContext)
 			})
 			widget.FilterWidgets = extractGalleryFilters(ctx, w)
+			// The gallery's own click action — written from `OnClick:` since the
+			// definition maps it; read back by source like DataGrid2's.
+			widget.OnClick = renderClientActionMDL(ctx, customWidgetActionForSource(ctx, w, "OnClick"))
 		}
 		// For filter widgets, extract filter attributes and expression
 		if widget.RenderMode == "textfilter" || widget.RenderMode == "numberfilter" || widget.RenderMode == "dropdownfilter" || widget.RenderMode == "datefilter" {
 
@@ -856,6 +856,29 @@ func extractGallerySelection(ctx *ExecContext, w map[string]any) string {
 	return ""
 }
 
+// customWidgetPropertySelection returns the Selection stored on the named
+// CustomWidget property ("None", "Single", "Multiple"), or "" when the widget
+// has no such property. Every property value carries a Selection field, None on
+// all but the selection property itself, so it must be looked up by key.
+func customWidgetPropertySelection(w map[string]any, propertyKey string) string {
+	obj, ok := w["Object"].(map[string]any)
+	if !ok {
+		return ""
+	}
+	propTypeKeyMap := buildPropertyTypeKeyMap(w, true)
+	for _, prop := range getBsonArrayElements(obj["Properties"]) {
+		propMap, ok := prop.(map[string]any)
+		if !ok || propTypeKeyMap[extractBinaryID(propMap["TypePointer"])] != propertyKey {
+			continue
+		}
+		if value, ok := propMap["Value"].(map[string]any); ok {
+			sel, _ := value["Selection"].(string)
+			return sel
+		}
+	}
+	return ""
+}
+
 // extractFilterAttributes extracts the filter attributes from a TextFilter/NumberFilter widget.
 func extractFilterAttributes(ctx *ExecContext, w map[string]any) []string {
 	// Use the generic property extraction helper
 
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package executor
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+	"github.com/mendixlabs/mxcli/mdl/linter"
+)
+
+// validateGalleryOnClickSelection (MDL-WIDGET35) reports a Gallery whose item
+// click action sits beside an item selection.
+//
+// A Gallery triggers its `onClick` on a single click (the definition fixes
+// onClickTrigger to "single"), and a single click on an item is also what
+// selects it. Mendix refuses that combination: with `OnClick:` and the
+// definition's default `Selection: Single`, exec wrote the page and mx check
+// (Mendix 11.14.0) reported "The item click action is ambiguous. Change "On
+// click trigger" to "Double click" or set "Selection" to "None"." MDL has no
+// spelling for the trigger, so the remedy is `selection: none`, which checks
+// clean.
+func validateGalleryOnClickSelection(w *ast.WidgetV3, locationPrefix string) []linter.Violation {
+	if w == nil || !strings.EqualFold(w.Type, "gallery") || w.GetAction() == nil {
+		return nil
+	}
+	selection := "Single" // the Gallery definition's default for itemSelection
+	if v, ok := lookupPropCI(w, "Selection"); ok {
+		selection = strings.TrimSpace(fmt.Sprint(v))
+	}
+	if strings.EqualFold(selection, "none") {
+		return nil
+	}
+	return []linter.Violation{{
+		RuleID:   "MDL-WIDGET35",
+		Severity: linter.SeverityError,
+		Message: fmt.Sprintf(
+			"%s: gallery `%s` has an OnClick action and Selection %s — a single click on an item would both select it and run the action, which Mendix rejects as ambiguous",
+			locationPrefix, w.Name, selection),
+		Suggestion: "Add `selection: none` to the gallery, or drop OnClick and put the action on a clickable `container` inside the template",
+	}}
+}