Sync ako/mxcli: local test loop, OData publishing, JAR dependency resolution, and 20 fixes

.claude/skills/mendix/cheatsheet-errors.md

@@ -217,6 +217,19 @@ set $count = 1;
 1. Check microflow exists: `show microflows in ModuleName`
 2. Use fully qualified name: `Module.MicroflowName`
 
+### "page not found" for a page the script creates further down (MDL-PAGE01)
+
+**Problem**: A widget action targets a page created by a LATER statement in the
+same script. Page references resolve in statement order, and `exec` is not
+transactional — the statements before the failure are already written.
+
+**Fix**:
+1. Move the `create page` for the target above the page that links to it.
+2. If two pages link to each other, no ordering works: create one without the
+   linking widget, then add it with `alter page ... insert`.
+3. Commit before executing a large script — recovery from a partial run is
+   `git checkout -- App.mpr mprcontents/`.
+
 ## Studio Pro Error Code Reference
 
 | Code | Message | Common Cause |

.claude/skills/mendix/create-page.md

@@ -1082,8 +1082,38 @@ textbox txtHidden (label: 'Hidden', attribute: Name, visible: false)
 -- A quoted-string expression is also accepted (CREATE and ALTER). Unlike the
 -- bracket form, it is NOT auto-rooted — write $currentObject/ yourself.
 dynamictext ovChip (content: 'chip', visible: '$currentObject/Name != empty')
+
+-- Function calls work in the bracket form, including functions whose name is
+-- also an MDL keyword (trim, length, find). Arguments are rooted like any other
+-- reference.
+dynamictext tTrim (content: 'x', visible: [trim($currentObject/Slug) != ''])
+textbox txtSlug (label: 'Slug', attribute: Slug, editable: [length(Slug) > 0])
 ```
 
+> **`visible:`/`editable:` is a Mendix *expression*, not XPath** — a different
+> function set from a datasource `where` clause, even though both use `[ ... ]`:
+>
+> | | `visible:` / `editable:` (client expression) | `where [ … ]` (XPath) |
+> |---|---|---|
+> | String tests | `trim()`, `length()`, `toUpperCase()`, `find()`, `contains()` | `contains()`, `starts-with()`, `ends-with()`, `string-length()` |
+> | `length()` | character count | number of elements in a list |
+> | Emptiness | `$currentObject/X != ''` / `!= empty` | `[X = empty]` or `[X = NULL]` — a **keyword**, never `empty(…)` |
+> | Aggregates | not available | `count()`/`avg()`/`min()`/`max()`/`sum()` are Java-API-only |
+>
+> mxcli's grammar accepts any function name in both and lets MxBuild adjudicate,
+> so a wrong-context call surfaces as **CE0117** "Error(s) in expression" at
+> build rather than as a parse error. See the Mendix reference guide:
+> [XPath constraint functions](https://docs.mendix.com/refguide/xpath-constraint-functions/),
+> [XPath keywords](https://docs.mendix.com/refguide/xpath-keywords-and-system-variables/).
+
+> **An unparseable conditional is an error, not a silent drop.** If the
+> expression inside `visible: [ ... ]` / `editable: [ ... ]` can't be parsed, the
+> property has nowhere to go and would vanish on write — leaving the widget
+> unconditionally visible/editable, which looks identical to a specificity bug in
+> the running app. `mxcli check` reports this as **MDL-WIDGET19** and fails the
+> command instead. Until v0.16.x, `trim(…)` and `length(…)` hit exactly this path
+> and disappeared without a word (issue #852).
+
 > **Attribute rooting is automatic** — a bare attribute in a widget
 > visibility/editability expression (`[Name != '']`, `[IsActive]`) is rooted in the
 > widget data context as `$currentObject/Name != ''` for you, so it no longer

.claude/skills/mendix/database-connections.md

@@ -76,14 +76,60 @@ end;
 
 ### Supported Database Types
 
-| Database | TYPE Value |
-|----------|------------|
-| Oracle | `'Oracle'` |
-| PostgreSQL | `'PostgreSQL'` |
-| MySQL | `'MySQL'` |
-| SQL Server | `'MSSQL'` or `'SQLServer'` |
-| Snowflake | `'Snowflake'` |
-| Amazon Redshift | `'Redshift'` |
+These are the values Studio Pro's own connector editor offers — read out of the
+shipped bundle at `modeler/ide-client/database-connector-editor/`, identical on
+11.10.0, 11.12.1 and 11.13.0.
+
+| Database | TYPE Value | Studio Pro label |
+|----------|------------|------------------|
+| SQL Server | `'MSSQL'` | Microsoft SQL |
+| MySQL | `'MySQL'` | MySQL |
+| Oracle | `'Oracle'` | Oracle |
+| PostgreSQL | `'PostgreSQL'` | PostgreSQL |
+| Snowflake | `'Snowflake'` | Snowflake |
+| *anything else* | `'BYOD'` | Other |
+
+**`'BYOD'` — bring your own driver.** Selecting it forces connection-string
+configuration and **skips the driver-presence check**; its only validation is
+that the connection string is non-empty. That is the hook for any JDBC driver
+Mendix ships no picker entry for (DuckDB, SQLite, ClickHouse, …). Verified end to
+end on Mendix 11.13: a booted runtime opened `jdbc:duckdb:` through a `BYOD`
+connection and returned real rows — the runtime accepts it, not just the editor.
+
+### Getting the driver onto the classpath
+
+The driver JAR has to be *resolved*, and declaring it is not resolving it:
+
+```sql
+ALTER MODULE MyModule ADD JAR DEPENDENCY (
+  group = 'org.duckdb', artifact = 'duckdb_jdbc', version = '1.5.5.1', included = true
+);
+```
+
+writes the coordinate to the model — `list jar dependencies` will report it — and
+downloads **nothing**. MxBuild does not resolve it either: a full
+`mxbuild --target=deploy` emits a `build.gradle` with no dependencies block. The
+first symptom is a runtime `SQLException: No JDBC driver found in app for URL`,
+from a connection that looks correctly configured.
+
+Studio Pro runs the resolution when you edit Module Settings. Headless, ask for it:
+
+```bash
+mxcli sync-java-deps -p app.mpr          # download into vendorlib/
+mxcli sync-java-deps -p app.mpr --check  # report what is missing, exit 1 (build gate)
+```
+
+`mxcli run --local` does this automatically for anything not already in
+`vendorlib/`, so the warm loop works from a fresh clone. Dropping the jar into
+`userlib/` by hand works too — it is the same classpath — but then the model and
+the file system disagree about where the dependency comes from.
+
+**`'Redshift'` and `'SQLServer'` are not real values.** Both appeared in an
+earlier version of this table and neither is in the picker on any version
+checked. mxcli writes the type string through unchanged and **mxbuild does not
+validate it** — `type 'Redshift'` builds 0 errors and simply does not connect —
+so `mxcli check` warns about an unrecognised type (MDL-DB01) rather than letting
+a green build hide it.
 
 ## Query Definition Syntax
 
@@ -315,6 +361,30 @@ $ResultList = execute database query Module.Connection.QueryName
   dynamic 'SELECT id, name FROM employees WHERE active = true LIMIT 10';
 ```
 
+**A dynamic override still requires a value for every declared parameter** —
+including the ones the replacement SQL does not use. The parameter list belongs
+to the query *definition*, not to the SQL string, so Mendix asks for all of them
+whatever you substitute. Pass a placeholder for the unused ones:
+
+```sql
+-- The definition declares $driverId; this SQL ignores it, and the call still
+-- has to supply it.
+$Count = execute database query F1.DuckDB.CountAllDrivers
+  dynamic 'SELECT count(*) AS n FROM read_csv(''/data/f1db-drivers.csv'')'
+  ( driverId = 'unused' );
+```
+
+**A `{param}` placeholder can be concatenated into a path**, which is what keeps
+absolute paths out of the model — bind the data directory as one constant and
+build the file name around it:
+
+```sql
+--   read_csv({dataDir} || '/f1db-drivers.csv')
+```
+
+Verified against DuckDB through the connector on Mendix 11.13, and against a
+standalone JDBC harness before that.
+
 ### Parameterized Queries
 
 Pass values for query parameters defined with `parameter` in the query definition:

.claude/skills/mendix/odata-data-sharing.md

@@ -223,8 +223,12 @@ create odata service ProductApi.ProductDataApi (
   ODataVersion: OData4,
   namespace: 'DefaultNamespace',
   ServiceName: 'ProductDataApi',
-  Summary: 'Product and customer data API',
-  PublishAssociations: No
+  Summary: 'Product and customer data API'
+  -- PublishAssociations is left at its default (Yes = associations as links).
+  -- Setting it to No means "associations as an associated object id", which
+  -- Mendix only allows when the system ID is published as the key — publishing
+  -- an ordinary attribute as the key then fails the build with CE7375, even
+  -- when no associations are exposed at all.
 )
 authentication basic
 {
@@ -412,6 +416,64 @@ alter entity ShopClient.Product set allow_create_change_locally = true;
 alter entity ShopClient.Product set allow_create_change_locally = false;
 ```
 
+## Publishing a Non-Persistable Entity (no copy of the data)
+
+A published entity does **not** have to be persistable. Back it with a read
+microflow and the rows are produced per request — nothing is stored, and there
+is no refresh job to keep a copy in step with the source. This is the shape to
+use when the data lives outside Mendix (an external database, a CSV, an API).
+
+```sql
+create non-persistent entity Api.Lap (
+  LapKey:  string(60),
+  Driver:  string(120),
+  LapTime: decimal
+);
+
+-- While Countable is Yes (the default), the read microflow MUST take a
+-- $Response: System.ODataResponse parameter — Mendix asks it for the count.
+CREATE MICROFLOW Api.Read_Laps ($Response: System.ODataResponse)
+  RETURNS List of Api.Lap AS $Laps
+BEGIN
+  -- retrieve from wherever the data actually lives, e.g. EXECUTE DATABASE QUERY
+  $Laps = CREATE LIST OF Api.Lap;
+  RETURN $Laps;
+END;
+
+create odata service Api.LapApi (
+  path: 'odata/laps/',
+  version: '1.0.0',
+  ODataVersion: OData4,
+  namespace: 'Api.Laps'
+)
+authentication basic
+{
+  publish entity Api.Lap as 'Laps' (
+    ReadMode: microflow Api.Read_Laps,
+    InsertMode: not_supported,
+    UpdateMode: not_supported,
+    DeleteMode: not_supported
+  )
+  expose (
+    LapKey as 'lapKey' (KEY, Filterable, Sortable),
+    Driver (Filterable, Sortable),
+    LapTime (Sortable)
+  );
+};
+```
+
+Two things worth knowing before you write this:
+
+- **`ReadMode: microflow Module.MF`** is the whole feature. `InsertMode`,
+  `UpdateMode` and `DeleteMode` take the same form for a read-write resource.
+- **Counting is not free.** If the count means a full scan of the underlying
+  source, set `Countable: No` on the published entity — the read microflow then
+  takes no parameters at all. `SkipSupported: No` and `TopSupported: No` turn
+  off `$skip` and `$top` the same way. All three default to Yes.
+
+`PublishAssociations` must stay at its default (Yes) here: a non-persistable
+entity cannot publish its ID, so object-id mode can never build for it.
+
 ## Step-by-Step: Read-Write API with Microflow Handlers
 
 For write operations (insert, update, delete), the OData service delegates to microflows that map between the view entity and the underlying persistent entities.

.claude/skills/mendix/run-local.md

@@ -133,6 +133,7 @@ Launch `run --local` as the **sole** command in its invocation (don't chain a tr
 | `--screenshot-path` / `--screenshot-url` | `.mxcli/run-local.png` / app root | Screenshot output / page (URL or `/path`) |
 | `--screenshot-user` / `--screenshot-password` | — | Log in once, reuse session (pages behind login) |
 | `--runtime-log` | `.mxcli/runtime.log` | Runtime log file: JVM stdout/stderr **and** the application log (microflow `LOG` output + server stack traces, via an attached file log subscriber). `-` disables. |
+| `--test-endpoint` | off | Host mxcli's token-guarded test endpoint so `mxcli test … --attach` can run a suite against this app with no boot of its own. Installed **before** the boot (the handler registers from after-startup), your own after-startup microflow is chained not displaced, and both are removed on exit. See `test-microflows.md`. |
 | `--debug` | off | Enable the microflow debugger at boot + start a session, so `mxcli debug break/paused/…` works from another terminal (see `debug-microflows.md`). No breakpoints = no behaviour change; disabled on shutdown. |
 | `--debug-pass` | `mxdebug` | Debugger password when `--debug` is set |
 | `--metrics` | off | Register a Prometheus meter registry at boot; the runtime serves metrics at `http://127.0.0.1:<admin-port>/prometheus` |
@@ -248,6 +249,27 @@ marker); the subscriber is re-attached on every restart and never rotates the fi
 the JVM tee's handle stays valid). Override the path with `--runtime-log <path>`, or
 pass `--runtime-log -` to disable the file (and the subscriber) entirely.
 
+## "Sign in failed" that is not about the password
+
+The local runtime is **unlicensed**, and an unlicensed runtime caps concurrent
+sessions at a handful. Past the cap it refuses the sign-in, and the login page
+reports that as a plain **"Sign in failed"** — exactly what a wrong password
+looks like. The real reason is written only to the runtime log:
+
+```
+Maximum number of sessions exceeded! (You are currently using a trial license)
+```
+
+So: when a login you know is correct starts failing, `grep -c "Maximum number of
+sessions" .mxcli/runtime.log` before touching the credentials or the user's
+password in the model. `--screenshot-user` does this for you — a rejected sign-in
+now reads the log and says so instead of quietly screenshotting the login page.
+
+Sessions are held until they expire; restarting `run --local` clears them all.
+A script that drives the app through a browser should **sign out at the end**,
+otherwise each run leaks a slot and the fifth or sixth run is the one that fails —
+which makes it look like a change you just made broke authentication.
+
 ## External browser preview (`--hub`)
 
 `--hub <url>` exposes the running app in a **browser at a public URL** without the app