# Migrating a TopLogic application from 8.0.0-alpha7 to 8.0.0-alpha8

Audience: an AI coding agent (or developer) upgrading a TopLogic application project.
Sources: release notes https://dev.top-logic.com/tl/content/releases/TL_8.0.0-alpha8/ and the
TopLogic Trac tickets flagged `RequiresMigration` for milestone `TL_8.0.0-alpha8` (ticket numbers
are given as `#NNNNN`; the per-ticket page is `https://dev.top-logic.com/tl/content/releases/TL_8.0.0-alpha8/NNNNN/`).

This release refines the model-based access rights of alpha7 (#29447, #29449), makes user names
and non-binary string columns case-insensitive on all databases (#29423, #29425), unifies the
application logo names (#29457) and moves the agent endpoint of the React view layer into an
optional module (#29430). Three engine migration scripts rewrite data automatically
(#29423, #29447, #29492). Applications on **PostgreSQL** must additionally add an own migration
script (#29425, section 2.3).

## How to use this document

1. Work through the sections in order. Section 1 must be done first (the project does not build
   otherwise); the rest can be done in any order.
2. Every step has a **Detect** line: run the search in the application's source tree. If it finds
   nothing, the step does not apply — skip it. Do not invent changes for steps that do not apply.
3. Many changes are reported as **configuration errors at application start or when a view is
   loaded** (not at compile time). After migrating, start the application, log in — as an
   administrator **and** as a regular (non-admin) user — and open every view; read the log for
   `ConfigurationException` / configuration errors.
4. Some changes only show at run time (filtered script results, changed defaults). They are marked
   **review**: check the described code, do not change it blindly.
5. The engine ships developer articles in its jars (`META-INF/tl-docs/**/*.md`). If the `tl-mcp`
   tools are available, read them with `read_doc`.
6. Ticket descriptions on Trac are partly German; this document translates the instructions.

Search commands below assume the project root as working directory and GNU grep.

---

## 1. Build and platform

### 1.1 Version bump
Set the TopLogic version to `8.0.0-alpha8` (parent `tl-parent-app` / `tl-parent-core` version, or
the `tl.version` property).

Detect: `grep -rn --include=pom.xml -e '8.0.0-alpha7' .`

### 1.2 Own `QueryExecutor` subclasses (#29449) — mandatory if used (Java)
`QueryExecutor.executeWith(EvalContext, Args)` and `QueryExecutor.disableSecurity()` are `final`
now (so are the other `execute…` methods). A subclass overrides the template methods instead:

```java
@Override
protected Object internalExecuteWith(EvalContext definitions, Args args) { … }

@Override
protected void internalDisableSecurity() { … }
```

The run-time consequence of the same ticket (results are filtered) is step 3.1.

Detect: `grep -rn --include=*.java -e 'extends QueryExecutor' -e 'extends DirectQueryExecutor' -e 'extends DeferredQueryExecutor' .`

### 1.3 XML importer model bindings take the security setting (#29447) — mandatory if used (Java)
`ApplicationModelBinding` and `TransientModelBinding` require the security setting of the import
as constructor argument. Code that sets up a binding itself must pass it — an import of external
data passes `false`:

```java
// before:
ModelBinding binding = new ApplicationModelBinding(kb, model);
// after:
ModelBinding binding = new ApplicationModelBinding(kb, model, false);

// TransientModelBinding analogously:
new TransientModelBinding(model, false);
```

Background: the binding applies this setting to every expression of the import definition. An
import definition is application configuration; evaluating it with the importing user's rights would
create duplicates or abort the import instead of protecting data. The engine's import commands
(`XMLImportCommand`, BPML import/update) pass `false`.

Detect: `grep -rn --include=*.java -e 'new ApplicationModelBinding' -e 'new TransientModelBinding' -e 'extends ApplicationModelBinding' -e 'extends TransientModelBinding' .`

### 1.4 "No upper bound" of size constraints (#29465) — mandatory if used (Java)
The encoding of "no upper bound" changed in three public APIs:

- `AttributeOperations.getUpperBound(…)`: a size annotation without upper bound is now reported as
  `Integer.MAX_VALUE` (before: `-1`, a truncated `long`). Replace comparisons with `-1`:
  ```java
  // before
  if (AttributeOperations.getUpperBound(size) == -1) { /* no upper bound */ }
  // after
  if (AttributeOperations.getUpperBound(size) == Integer.MAX_VALUE) { /* no upper bound */ }
  ```
  `getLowerBound()` saturates the same way, but is not affected in practice (`TLSize.NO_LOWER_BOUND` is `0`).
- `AttributeOperations.getLength(…)` returns `null` instead of `-1` if there is no upper bound.
  Assigning the result to an `int` now fails with a `NullPointerException`:
  ```java
  // before
  int length = AttributeOperations.getLength(part); // -1, if no upper bound
  // after
  Integer length = AttributeOperations.getLength(part); // null, if no upper bound
  if (length != null) { … }
  ```
- `StringLengthConstraint`: the constructors normalize a `maxLength` of `Integer.MAX_VALUE` to the
  new constant `StringLengthConstraint.NO_LIMIT` (`-1`). For an unbounded constraint `hasMaxLength()`
  returns `false` and `getMaxLength()` returns `NO_LIMIT`; validation is unchanged. Code that passed
  `Integer.MAX_VALUE` and evaluated `hasMaxLength()` / `getMaxLength()` now sees "no limit". Use
  `StringLengthConstraint.NO_LIMIT` instead of a literal `-1` for an unenforced bound.

Detect: `grep -rn --include=*.java -e 'getUpperBound(' -e 'getLength(' -e 'StringLengthConstraint' . | grep -e AttributeOperations -e StringLengthConstraint`

### 1.5 User name API (#29423) — review (Java)
- New: `Person.normalizeName(String)` (strips leading/trailing whitespace, keeps the case).
- `Person.byName(String)` and `Person.byName(KnowledgeBase, String)` trim their input and look up
  case-insensitively. Code that relied on an exact name match now gets different results.
- `ItemByNameCache` has an additional constructor with a key normalization and the new method
  `lookup(K)`. For a normalizing cache, direct access via `getValue().get(key)` is wrong — switch own
  uses to `lookup(…)`. The existing constructor is unchanged (exact match).
- `TLSecurityDeviceManager.DB_SECURITY` is now `public` (id of the local database authentication
  device; an account at another device counts as externally managed).

Account creation rules are step 2.2.

Detect: `grep -rn --include=*.java -e 'Person.byName' -e 'ItemByNameCache' .`

### 1.6 Favicon tag API (#29457) — mandatory if used (Java / JSP)
- The JSP tag `<basic:favicon>` has no attribute `shortcutIcon` any more. Switch uses to the
  attribute `icon` or drop the attribute.
- `FaviconTag.write(TagWriter, String shortcutIcon, String icon)` and
  `FaviconTag.write(JspWriter, String shortcutIcon, String icon)` are replaced by
  `FaviconTag.writeIcon(TagWriter, String icon)` resp. `FaviconTag.writeIcon(JspWriter, String icon)`.
  The other `FaviconTag.write(…)` methods (context path only) are unchanged.

Detect: `grep -rn -e 'shortcutIcon' -e 'FaviconTag' --include=*.java --include=*.jsp --include=*.jspf --include=*.tag .`

### 1.7 Agent endpoint moved to `tl-layout-view-agent`; package `react.headless` renamed (#29430) — mandatory if used
- The agent endpoint `/agent-api/*` is no longer registered by `tl-layout-react`. It moved to the
  optional module `tl-layout-view-agent` (package `com.top_logic.layout.view.agent`). An application
  that uses agent access (an agent or MCP wrapper calling `/agent-api`) must add the dependency:
  ```xml
  <dependency>
  	<groupId>com.top-logic</groupId>
  	<artifactId>tl-layout-view-agent</artifactId>
  </dependency>
  ```
  Access then requires an access token that a logged-in user issues in their session. Applications
  without agent access need no change (and should not add the module).
- Java code using the package `com.top_logic.layout.react.headless` must switch to
  `com.top_logic.layout.react.scripting` (the classes are named after "scripting" now, e.g.
  `ScriptingSession`, `ScriptingTreeProjector`).

Developer articles: `view-layer/headless-interface` (`tl-layout-react`) and
`view-layer/agent-access` (`tl-layout-view-agent`).

Detect: `grep -rn -e 'agent-api' -e 'react.headless' .`

---

## 2. Server configuration and database

### 2.1 Case-insensitive user names: engine migration (#29423) — mandatory, data-touching
A database migration is required and runs automatically: the engine script
`Ticket_29423_resolve_person_name_collisions` (module `tl`) runs the
`ResolvePersonNameCollisionsProcessor`. It renames accounts whose names differ only in case, so
that at **any point in time** at most one account exists per case-insensitive name:

- All accounts over their **whole history** (including deleted, history-only accounts) are
  considered, per branch. A rename only affects the revision interval of the colliding name version;
  an account that only changed its own spelling does not collide with itself.
- Within a collision one account stays unchanged (priority: alive, then externally managed, then
  smallest id); the others keep their spelling and get the smallest free number suffix
  (e.g. `User` → `User1`).
- On databases that already compare names case-insensitively such collisions cannot exist; the
  processor is a no-op there.
- Every rename is logged; renames of directory-managed accounts (with a real authentication device)
  as **warning**.

The migration must not be skipped: the name cache detects a remaining collision and throws an
`IllegalStateException` while being built — the application is then not operational. Own
migration scripts that create accounts must run **after** the engine script (declare a dependency
on `Ticket_29423_resolve_person_name_collisions`, module `tl`).

After the migration, check the migration log for renames and handle manually:
- **Inform affected users**: a renamed account logs in with its new name.
- **Directory-managed accounts**: if an LDAP account was renamed (e.g. `User` → `User1`), the next
  synchronization no longer finds it under the directory name and creates a **new** account. Roles,
  group memberships and references stay with the renamed account; transfer them or remove the
  surplus account.

No change of the database schema is required; the migration only rewrites colliding name values.

Detect (own migrations creating accounts):
`grep -rln --include=*.migration.xml -e 'Person' -e 'Account' src/main/webapp/WEB-INF/kbase/migration 2>/dev/null`
Report the result of the log check to the user.

### 2.2 Account name rules and `person-name-pattern` (#29423) — review
`Person.create(…)` now throws a `TopLogicException` if the name
- is empty after trimming,
- does not match `person-name-pattern`,
- is not shorter than `person-name-max-length` (default 128, i.e. at most 127 characters), or
- is already taken case-insensitively.

Check every programmatic account creation (imports, scripts, own provisioning, own authentication
devices). The LDAP synchronization skips such an account and logs an error — watch the log after
the upgrade.

The default of `person-name-pattern` (`PersonManager` configuration) changed:

| before | now |
|---|---|
| `[-_a-zA-Z0-9@\.]+` | `[-_\p{L}\p{N}.@+~]+` |

- **Applications with logins containing further characters** — in particular domain-qualified names
  like `DOMAIN\user`, but also names with spaces or a colon — **must** extend the pattern in their
  configuration. Otherwise creation and directory synchronization of these accounts fail.
- **Applications with an own `person-name-pattern`** keep their former, narrower pattern and keep
  rejecting non-ASCII names and e-mail addresses with `+`. Recommendation: remove the override or
  switch to the new pattern.

Detect:
```
grep -rn -e 'person-name-pattern' -e 'person-name-max-length' --include=*.xml .
grep -rn --include=*.java -e 'Person.create' -e 'createPerson' .
```

### 2.3 Case-insensitive string columns on PostgreSQL, Oracle and DB2 (#29425) — mandatory on PostgreSQL / Oracle / DB2
Affects applications on **PostgreSQL**, **Oracle** and **DB2**. H2, MySQL and MS SQL are unchanged.

**DB2: collating sequence.** At start the application checks whether the database uses a
case-insensitive collating sequence (`coll_seq`). Otherwise it logs an error and non-binary string
columns are still compared case-sensitively. DB2 databases must therefore be created with a
case-insensitive collating sequence (this is a property of the database, set when it is created).

**PostgreSQL: prerequisites**
- PostgreSQL **12 or newer**, built **with ICU support**. Both are checked at start and logged as
  error otherwise.
- The database user of the application must be allowed to create a collation (`CREATE` privilege on
  the schema in which the collation is created). The collation `tl_ci` is created on **every**
  initialization of a connection pool on a write connection via
  `CREATE COLLATION IF NOT EXISTS "tl_ci" (provider = icu, locale = 'und-u-ks-level2', deterministic = false)`.
  Without this privilege the **application does not start**.
- If the collation does not exist (e.g. because it lives in another schema that is not in the
  `search_path`), additionally all queries with `ORDER BY` fail: the `NATURAL` sort hint now refers
  to `COLLATE "tl_ci"`.

**PostgreSQL: convert existing columns (required)**
The DDL change only applies to **newly created** columns. An existing database thus gets mixed
collations, and PostgreSQL aborts the comparison of two columns with different implicit collations
(`could not determine which collation to use for string comparison`, SQLSTATE 42P22) — a join or
comparison between a new (`tl_ci`) and an old column fails at run time. Converting the existing
columns is therefore **part of the migration on PostgreSQL**, not optional.

The engine ships **no** migration script for this; add the processor
`RecollateStringColumnsProcessor` to a migration script of the application:

```xml
<?xml version="1.0" encoding="utf-8" ?>

<migration config:interface="com.top_logic.knowledge.service.migration.MigrationConfig"
	xmlns:config="http://www.top-logic.com/ns/config/6.0"
>
	<version name="Ticket_XXXXX_recollate_string_columns"
		module="my-app"
	/>
	<dependencies>
		<dependency name="<last-own-version>"
			module="my-app"
		/>
	</dependencies>
	<processors>
		<processor class="com.top_logic.knowledge.service.migration.processors.RecollateStringColumnsProcessor" />
	</processors>
	<post-processors/>
</migration>
```

Without `table` and `column` **all** non-binary string columns of **all** tables are converted. For
a selective conversion give the logical names of the TopLogic meta schema:

```xml
<processor class="com.top_logic.knowledge.service.migration.processors.RecollateStringColumnsProcessor"
	table="Person"
	column="name"
/>
```

On dialects without column collation (Oracle, DB2) the processor is a no-op and logs that.

**PostgreSQL: check for duplicates first.** The conversion runs one
`ALTER TABLE … ALTER COLUMN … TYPE …` per column; table and indexes are rebuilt. If a column with a
`UNIQUE` index contains values that differ only in case, **the migration fails** while rebuilding
the index. Clean up such values beforehand, e.g.:

```sql
SELECT lower(NAME), count(*) FROM PERSON GROUP BY lower(NAME) HAVING count(*) > 1;
```

**PostgreSQL: run time.** Over all tables the conversion is a long-running, locking `ALTER` sweep
that rewrites the affected tables (locks, temporary disk space of the table's size). Run it in a
maintenance window; for large databases it can be split table by table into several migration steps.

**Oracle: database configuration.** Oracle sets no collation per column; case-insensitivity of
non-binary columns depends on the NLS configuration:

| Parameter | Required value |
|---|---|
| `NLS_COMP` | `LINGUISTIC` |
| `NLS_SORT` | a collation ending in `_CI` or `_AI` (e.g. `GENERIC_M_CI`) |

This is checked at start; if it does not match, an error is logged and **non-binary columns are
still compared case-sensitively** — a `UNIQUE` index then does not reject values that are equal
ignoring case. TopLogic has no hook for per-connection init SQL, so set the values on the database
or instance (instance parameter / `ALTER SYSTEM`, not per session).

**Columns that must stay case-sensitive.** On PostgreSQL and Oracle practically all string columns
become case-insensitive — for comparison, uniqueness and sorting. Where case must be distinguished
(e.g. technical keys, password hashes, Base64 values), declare the column `binary="true"` in the
schema; such columns must not be converted (the processor skips them).

Detect:
```
grep -rn -i -e 'postgres' -e 'oracle' -e 'db2' --include=*.xml --include=*.txt --include=*.properties src/main/webapp/WEB-INF/conf
grep -rn -e 'binary="true"' --include=*.xml src/main/webapp/WEB-INF/kbase
```
No hit for PostgreSQL/Oracle/DB2 → skip. Report the DBA-side prerequisites (privilege, ICU, NLS
parameters, DB2 collating sequence) to the user; they cannot be done in the source tree.

### 2.4 Layout key column enlarged (#29492) — no manual steps
The column `LAYOUT_KEY` of the tables `TEMPLATE_LAYOUTS` and `LAYOUT_CONFIGURATIONS` grows from 150
to 300 characters. The engine migration `Ticket_29492_enlarge_layout_key` (module `tl`) does this
automatically.

### 2.5 Security parents are navigation rules (#29447) — mandatory if used
The rules under `<security-parents>` are now navigation rules. Attributes that were silently
ignored there (`role`, `source-role`, `source-meta-element`, `type`, `resource-key`) are rejected as
unknown properties (configuration error at start) and must be removed:

```xml
<security-parents>
	<rule
		id="..."
		meta-element="my.module:MyType"
		inherit="true"
		role="myRole"                 <!-- remove -->
	>
		<path>
			<step attribute="my.module:MyType#owner"/>
		</path>
	</rule>
</security-parents>
```

Configurations that only use `id`, `meta-element`, `inherit` and the path stay valid.

Detect: `grep -rn -A12 '<security-parents' --include=*.xml . | grep -E 'role=|source-role=|source-meta-element=|type=|resource-key='`

### 2.6 Types without access control (#29447) — optional, temporary only
An application whose grants are not yet complete after the upgrade to the model-based access rights
(#29088, alpha7) can exempt single types or modules temporarily with `without-security="true"` on
the `<class>` resp. `<module>` entry of the `SecurityConfigurationService` configuration:

```xml
<class name="my.module:MyType"
	without-security="true"
/>
```

**Warning:** every user may read, change, create and delete objects of such a type (and of its
subtypes; on a module: all its classes), regardless of roles. Remove the flag as soon as the grants
are configured. Do not add it unless the user asks for it. From 8.0.0-alpha9 on, the coverage view of
the access control shows the types marked this way. A type that is only used by application
code is marked `internal="true"` instead (available from 8.0.0-alpha9 on; not in 8.0.0-alpha8).

Detect (existing uses to review): `grep -rn 'without-security' --include=*.xml .`

---

## 3. Security / access checks

### 3.1 `QueryExecutor` filters its result (#29449) — review (Java)
`QueryExecutor.executeWith(…)` (and the other `execute…` methods) now filter the result to the
read rights of the logged-in user, unless security is switched off with `disableSecurity()`. Code
that uses a `QueryExecutor` for internal computations whose result does not go to a user must
switch security off — otherwise objects the current user may not read are missing from the result.
This is no compile error but run-time behavior:

```java
QueryExecutor executor = QueryExecutor.compile(expr);
executor.disableSecurity();
```

The engine extension points working with definer's rights (computed attributes, attribute locators,
constraints, lock strategies, migration and maintenance scripts, JMS consumers, process engine)
already do this.

Detect: `grep -rn --include=*.java -e 'QueryExecutor.compile' -e 'QueryExecutor.compileOptional' -e 'QueryExecutor.interpret' .`
For each hit decide: result shown to the user → keep; internal computation → `disableSecurity()`.

**Review — business objects inside data objects.** Besides model elements (`TLModelPart`),
`filterSecurity` also passes `ReflectiveDataObject` values (msgbuf objects, e.g. flow diagrams)
unfiltered. Business objects a script stores in the `userObject` of a flow diagram are therefore not
checked for read access and reach the selection channel when the user clicks the node. Check flow
diagrams that put business objects into `userObject`; where a user must not see some of them, filter
them in the script (e.g. with `filterSecurity(…)`) before building the diagram.

Detect: `grep -rn -e 'userObject' --include=*.xml --include=*.java src/main`

### 3.2 OpenAPI client calls in scripts with definer's rights (#29447) — review
A script executed without access checks (computed attribute, maintenance script, migration) now
also calls an OpenAPI client method without checks. Requests that so far silently went out with
missing values now contain the complete data. Projects that relied on the former behavior must
restrict the access in the script themselves.

Detect: `grep -rln -e 'OpenApiClient' -e 'openapi.client' --include=*.xml --include=*.java . `

### 3.3 Anonymous account leaves the default group (#29447) — no manual steps
Existing databases contain the membership of the anonymous account (and its representative group)
in the default group. The engine migration `Ticket_29447_anonymous_not_in_default_group` removes it
automatically from every group with the `defaultGroup` flag. Applications without a configured
`default-group` are not affected.

---

## 5. Classic UI, resources and tests

### 5.1 Uniform application logo names (#29457) — mandatory if own logos are shipped
Only applications that ship own logos or reference the engine's logo resources directly are
affected. Without adjustment the display silently falls back to the TopLogic standard logo; no
error is reported.

1. **Rename an own logo for the collapsed sidebar:**
   ```
   src/main/webapp/images/TL_App_icon_blue.svg
     -> src/main/webapp/images/appLogoMinimized.svg
   src/main/webapp/themes/<theme-id>/images/TL_App_icon_blue.svg
     -> src/main/webapp/themes/<theme-id>/images/appLogoMinimized.svg
   ```
2. **Own theme settings:** if an own `theme-settings.xml` sets `IMAGES_APP_LOGO_MINIMIZED` to
   `/images/TL_App_icon_blue.svg`, change it to the new file name — or simpler, remove the entry and
   ship the own file under the default name `appLogoMinimized.svg`.
3. **References to removed files** — switch to the remaining file with identical content:

   | removed | use instead |
   |---|---|
   | `/images/appLogoSmall.svg` | `/images/appLogoMinimized.svg` |
   | `/themes/core/images/TL_Logo_blue.svg` | `/images/appLogo.svg` |
   | `/themes/core/images/TL-Logo-without-text.svg` | `/images/TL-Logo-without-text.svg` |
   | `/images/shortcut.ico` | `/images/favicon.png` |

4. **Favicon configuration at the main layout:** the properties `icon` and `shortcutIcon` of the main
   layout (`com.top_logic.mig.html.layout.MainLayout.Config`, typically set on the component
   `masterFrame`) are gone. Unlike the logos this does not fail silently: an application setting
   them in an own layout fails to start with a configuration error (unknown property). Remove the
   attributes. A different favicon is delivered as own file `/images/favicon.png`, or the theme
   variable `com.top_logic.gui.Icons.DEFAULT_ICON` is set to another path.

No database migration is required. The developer manual describes the logos under
"Theming > Applikations-Logos".

Detect:
```
grep -rn -e 'TL_App_icon_blue' -e 'appLogoSmall' -e 'TL_Logo_blue' -e 'TL-Logo-without-text' -e 'shortcut.ico' -e 'IMAGES_APP_LOGO_MINIMIZED' .
grep -rn -e 'shortcutIcon=' -e 'masterFrame' --include=*.xml src/main/webapp/WEB-INF/layouts | grep -e 'icon=' -e 'shortcutIcon='
find . -path ./target -prune -o -name 'TL_App_icon_blue.svg' -print
```

### 5.2 Account user name label and resource keys (#29484) — mandatory for scripted tests
- The field for the user name of an account is now labelled "Benutzername" instead of "Login".
  Scripted tests that address the field by its label (`label="Login"` in a `FormInput` action) must
  be switched to the new label or re-recorded (the engine's own tests were adjusted accordingly).
- Resource keys of deleted model parts were removed (among others `model.tl.bpe.bpml.Edge.label`,
  `model.tl.bpe.bpml.Task.label`, `model.tl.bpe.bpml.Task.labelFunction`); overrides of these keys
  in own bundles are obsolete and can be deleted. The `model.mandatorStructure.*` entries moved to
  the new bundle `model.mandatorStructure.messages` (`tl-element`); since resolution is by key, an
  application overriding these keys in own bundles is not affected.

Detect:
```
grep -rn --include=*.script.xml -e 'label="Login"' .
grep -rn -e 'model.tl.bpe.bpml.Edge.label' -e 'model.tl.bpe.bpml.Task.label' --include=*.properties .
```

### 5.3 Anonymous account must not be edited: own account form (#29447) — mandatory if overridden
The layout `admin/security/accounts/detailsForm.layout.xml` (module `tl-layout-formeditor`) now
prevents editing the anonymous account with an `editExecutability` rule. An application shipping an
own (overridden or exported) version of this layout must add the block to the `<arguments>` of its
template call:

```xml
<editExecutability>
	<anonymous-account-disabled>
		<account expression="contact -> $contact.get(`Contacts:PersonContact#account`)"/>
		<message key="dynamic.3b5115de-b1a6-4529-9f74-ee51069286ee">
			<en>The anonymous account cannot be edited.</en>
			<de>Der anonyme Zugang kann nicht bearbeitet werden.</de>
		</message>
	</anonymous-account-disabled>
</editExecutability>
```

(The block is the one the engine's own layout received in this release; compare with the engine
version of the file.)

Detect: `grep -rn -e 'accounts/detailsForm' --include=*.xml .` and
`find . -path ./target -prune -o -path '*accounts/detailsForm.layout.xml' -print`

---

## 7. Further notes (no action required)

- **Model editor instance view (#29464):** initially shows only the `main-properties` of the type;
  all other columns (also computed and `hidden` ones) can be switched on via "Spaltenauswahl und
  Reihenfolge...". The Excel export of this table therefore contains fewer columns by default. A
  stored personal column selection overrides the new default.
- **BPML export (#29434):** the workflow export is pretty-printed by default (option `pretty-print`
  of the command).
- **Maintenance mode (#29480):** new option "Anmeldung während der Übergangsphase erlauben" (off by
  default = former behavior); new API `MaintenanceWindowManager.enterMaintenanceWindow(long, boolean)`.
- **Self-service invitations (#29458):** existing invitations can be edited and re-sent in a new
  dialog of the account administration; entered e-mail addresses are compared case-insensitively.
- **React UI (#29446, #29448, #29404, #29427):** page state (selection, scroll position, expansion,
  form input, pager page) survives a browser reload; tables get a column chooser, `fixed-columns`,
  type-specific filters; `tl.core:Tristate` is edited as a three-state checkbox; `<boolean-display>`
  annotations take effect; new `<switch>` view element. Attach/detach now also reaches the content
  of a `<split-panel>`, so tab bars inside split panels write route segments (URLs may change).
- **Role profiles (#29445):** command groups are sorted stably.
- **Fixes without action:** dialogs opened while a popup is open (#29460), command executability on a
  deleted target model (#29461), row objects in grid header functions (#29456), identity-based
  constraints in React forms (#29468), fewer queries when deleting objects (#29493).

---

## 8. Verification checklist

1. `mvn clean install` of the application (with tests if possible).
2. Start the application against a copy of the production database (PostgreSQL: with the
   recollation script of step 2.3; check the DB privileges first; DB2: check the collating sequence).
3. Read the startup and migration log: no configuration errors (`<security-parents>` attributes,
   `icon` / `shortcutIcon` on the main layout), collation / NLS / collating sequence errors
   (PostgreSQL, Oracle, DB2), the
   account renames of `Ticket_29423_resolve_person_name_collisions`, no `IllegalStateException`
   from the name cache.
4. Log in as administrator and as a regular user (also with a name in different case and with
   surrounding spaces); open every view and every dialog.
5. Check that lists and script results still contain what a regular user should see (step 3.1),
   and that flow diagrams do not expose objects the user must not read.
6. Try to edit the anonymous account in the account administration: it must be refused (step 5.3).
   If the application uses agent access, check `/agent-api` with an issued access token (step 1.7).
7. Check the application logo in expanded and collapsed sidebar and the browser favicon.
8. Run the scripted tests (label "Benutzername").
9. Report to the user every step that was skipped, needed a decision, or touches data (account
   renames, LDAP duplicates, column recollation, `without-security`).
