Lime CRM Desktop Client 11.3.4710

Security hardening of the update service and the installer. This release includes security hardening of the Lime Maintenance Service, which installs client updates, and of the installer. Lime recommends that all computers with Lime CRM Desktop Client are updated to this release.

Updates never restart the computer on their own. When a component needs a restart, the restart is completed at the next normal restart of the computer.

Documents that could not be saved to Lime CRM are reported and can be recovered. The client tells you when a document could not be saved. The dialog Tools > Unsent documents lets you retry, save a copy or discard the changes.

Document locking is active again. Two people can no longer overwrite each other's changes to the same document. Locked documents can be found and released.

Safer opening of links and files. The client blocks known dangerous link types and asks before it opens a file that Windows considers unsafe.

Better search in relation fields. Find a record by typing its id, choose the order of search results, and create or edit the search views and filters directly in the search settings.

Fewer freezes and crashes. Several situations where the client stopped responding or closed are fixed, among them record locks, a large favorites cache, the database selection dialog and closing tabs.

VBA works after the update. The VBA setup installs the Visual C++ 2010 runtime that VBA needs.

Security hardening of the update service and the installer. This release includes security hardening of the Lime Maintenance Service, which installs client updates, and of the installer.

Application.Shell hardens how links and files are launched. The single point that opens links and files for the client - used by automation, the action pad, field and content links, and the phone dialer - now blocks documented protocol-abuse schemes (such as ms-msdt) and elevation verbs (runas) outright, and lets ordinary web, mail, telephony, Teams, Slack and document-management links through unchanged. For a program or document that could be unsafe, the client now makes the decision itself rather than handing the launch to Windows: it checks the file against the Windows attachment and zone rules and, when those would warn, asks for confirmation through its own prompt - shown in your language and the same whether the file is being launched, opened or saved - in place of the Windows “Open File - Security Warning”. When the client runs with no user interface, such as an unattended automation, a flagged target is blocked outright instead of launched. The underlying Windows zone check is never bypassed. Administrators can tighten or loosen the behaviour per machine, including a no-prompt hard-block mode.

Documents that could not be saved to Lime CRM are now reported and can be recovered. When a document could not be sent to the server after editing, the client gave no message, and the changes existed only on this computer. The client now records each failed save beside the document. A notification tells you when a document could not be saved, after login and again when you exit. The new dialog Tools > Unsent documents… lists these documents with their state, the reason and the time of the last attempt. From the dialog you can open the document, open its folder, save a copy, copy the path or copy the details for a support case. You can also retry the save, discard the local changes, or replace the version on the server. Discard always asks for confirmation. Replace shows both times and is available only to administrators. A server answer that does not confirm the upload now counts as a failure, so the local copy is kept. The delay before the first check after login is set with Application\UnsentDocumentsScanDelay (default 20 seconds).

The client tells you when a document opens read-only because of its size. A document larger than the size the client can send is opened read-only. This happened without a message, so it looked like a permission problem. The client now says that the document is read-only and that changes cannot be saved to Lime CRM. When the size is known, the message also states it. The document tooltip and the lock information now also say that a locked copy may contain changes that are not in Lime CRM yet.

Find and release locked documents. Every record type with a document field now has predefined filters for locked documents. “Locked - mine” is available to all users. “Locked - all” and “Locked - stale” are available to administrators, together with a view that shows lock details with the oldest lock first. A new Document submenu in the right-click menu, and the Document toolbar menu, let you release a lock. You can always release your own lock. An administrator can also release the lock of another user, after a confirmation that shows the owner and the age of the lock. “Save selected documents” is now in the same Document menu.

The client keeps your document locks active and releases your old locks. While you edit a document, the client now confirms the lock to the server at regular intervals. At login and at exit, it releases your own locks that have no local copy any more, so colleagues no longer wait for the server to clear them. Only locks that this computer recorded are released, so a lock you hold on another computer is not touched.

Login and database selection try a secure connection first. When you paste a server address with http: or https: in the database selection dialog, the client now keeps that protocol and also reads a database= parameter from the address. When a secure (https) connection to a server on a non-standard port fails because of the secure channel, the client asks before it connects over unencrypted http. Your answer is remembered for that server. While the connection is unencrypted, the login dialog shows a red footer and a warning icon with an explanation.

The database selection dialog no longer freezes. The dialog connected to the server on the user interface thread, so it stopped responding for about 25 seconds when a server was not reachable. The connection now runs in the background. The dialog waits until you have finished entering the server and port before it connects. It also does not try the same server, port and protocol again unless you press Refresh or Enter. Enter in the server field no longer moves the cursor to the database field.

Requests to the Lime CRM server handle overload and gateway errors better. When many clients fail at the same moment, they now wait different, random times before the next attempt, so a recovering server does not receive all requests at once. A “Retry-After” answer from the server is now limited to two minutes, and the normal limit on attempts always applies. Server errors (5xx) that the client did not recognize before are now retried.

Message boxes from the standard add-ins now follow the client's settings. Message boxes from the VB6 and .NET add-ins are now shown through the client. They follow Application.DisplayAlerts, so an unattended run no longer stops at a dialog that nobody can close. They also use the same dialog style as the rest of the client. The error window of the Template Manager is replaced by the standard client dialog, and its button that sent the error by e-mail is removed.

Messages from web pages in the integrated browser are clearer. An alert() from a page in an action pad or web bar is now shown through the client. It follows Application.DisplayAlerts and names the page that showed it. An alert with empty text shows a standard text instead of an empty box. When a VBA call from a page fails, the message now names the VBA method, the error text and the error code.

Filter validation catches more cases where a negated condition would include the wrong records. The report that checks a filter now cross-checks each negated condition (such as “not one of” a set) by an extra, independent route: it verifies that the records the condition excludes and those it keeps exactly partition the record type, with none overlapping and none missing. When they do not, the report flags it instead of reporting a clean result and lists the offending record ids, so a fault in how a negated condition is turned into a query is caught rather than passing silently.

Choose how search results are ordered, per record type. When you search for a record to link into a relation field, the order of the results is decided by the view behind the search. A record type without a purpose-built search view borrowed the order of an ordinary browse view, which is rarely the order you want when searching by description. The search settings dialog now carries an explicit sort setting for each record type: leave it on “Default” to keep the view's own order - the option's tooltip spells out what that order currently is - or pick “Ascending by” or “Descending by” a field of your choice, including a field reached through a related record, to override it. The choice is remembered for that record type and applied to the whole result set, not just the rows already fetched. No existing search changes order until you set this; “Default” leaves everything as it was.

Create and edit the views and filters behind a search without leaving the dialog. The search settings dialog could only pick from views and filters that already existed; shaping what a search shows meant going off to the view or filter designer elsewhere. Each drop-down now offers “New…” to create one and a “…” button beside it to edit the one selected, opening the same designers in place. The view drop-down also always lists a “[Search]” entry, marked with a magnifier, even before such a view exists: choosing it opens the designer ready to build the purpose-built search view that governs which columns a search shows. The dialog was tidied in the same pass, with a wider search field, labelled icon buttons and the clearer title “Search settings”.

Open your own record from the Tools menu. A new entry at the top of the Tools menu - named “Edit current” followed by your record's type - opens your own user record (your coworker card) in an inspector, so you no longer have to search for it first. If that record is already open it is brought to the front instead of being opened a second time. The entry appears disabled when your login has no such record.

Pane dividers now show that they can be dragged. The divider between panes carried only a faint marker, so many people never realised it could be moved to resize the panes. Each divider now shows a clearer handle: a thin line along the divider with a rounded grip at its centre, drawn in the standard raised Windows style and following your theme and high-contrast settings. As the pointer moves over a divider the grip follows it and the divider highlights, so it is obvious where to take hold and that the panes can be resized. The strip of record tabs in an inspector, which doubles as a handle for resizing the pane beneath it, gained the same cue: moving the pointer over its resize area shows the vertical resize cursor and highlights the strip.

Recently used values are now offered on option fields too. A relation field's menu has long offered a “Recent” shortcut to values you linked before; the same shortcut now appears on fields backed by a predefined option list. It lists only options that are currently valid for the field, and it is never narrowed by whatever you have typed into the field.

Shortcuts to records related to you. The field menu can offer values reached through your own user record - for example a company or a manager recorded on it. Where it previously offered at most one such shortcut, it now lists every relation from your record that points at the field's target, grouped under a heading naming your record's type (for example “From Coworker”). A relation holding a single value appears directly, as the relation's name followed by the value; one holding several values opens a submenu. Only values that are valid for the field are shown.

The field menu no longer offers to link a record to itself. On a relation that can point at the same kind of record it lives on - a parent or a manager of the same type, for example - the menu's shortcut lists (“Me”, “Recent” and the related-to-you entries) no longer offer the record you are currently editing, so it cannot be linked to itself by accident. A self-link that is genuinely intended can still be made deliberately through Search or the full list of options.

The alternatives menu is always reachable with a right-click. On a field whose arrow button opens the search dropdown, the menu of alternatives - recent values, the related-to-you shortcuts, open and unlink, and so on - could not be opened at all. A right-click on the field now always opens that menu, while the arrow button keeps its usual behaviour.

Option-constrained fields no longer offer ways to set an invalid value. For a field limited to a fixed, predefined set of options, the menu no longer shows “Search…” or “New…”, since either could set a value outside the allowed set - and this now holds however the menu is opened, including the right-click menu on a field whose arrow opens a dropdown. A relation that is merely narrowed by an option query is not treated as such a fixed list: it keeps “Search…” and “New…”, and its dropdown search now applies that option query so only the permitted records are offered. When a field's allowed options resolve to an empty set, the menu shows a disabled “No matches” rather than appearing empty. Together with the valid-only filtering above, every choice the menu offers stays within the field's permitted options.

Filter validation explains a withheld related value instead of showing a bare number. When you check a filter with the validation report, a condition pointing at a person or coworker record showed only that record's numeric id, with no name and no hint why - looking the same as a value that had failed to resolve. The report now marks such a value with the record's type and notes that the name is withheld for privacy (for example “60201 (Coworker - hidden for privacy)”), so it is no longer mistaken for a fault. The name itself is still kept out of the report.

Find a related record by typing its id. Typing a number that is a record's id into a relation field's search now pins that exact record at the top of the dropdown, even when the record's description does not contain those digits. The match resolves instantly from the already-loaded entries, or is fetched from the server when the record has not been loaded yet. The matched id is shown as a bold, right-aligned badge on the pinned row so it is clear why that row is there.

Multi-value option fields can be operated from the keyboard. Fields that present a checkbox list of options (multi-select “set” fields) now support full keyboard use: Down or Space opens the dropdown; the arrow keys, Home / End and Page Up / Page Down move the highlight; and Space checks or unchecks the highlighted option. Previously these fields could only be operated with the mouse.

Type-to-find inside multi-value option fields. With the dropdown open, start typing to jump the highlight to the first option that matches what you have typed. The current search text appears next to a magnifier glyph in the dropdown footer and clears itself after a short pause with no typing. Backspace erases the last character and Delete clears the search; pressing any arrow key ends the search and returns to plain navigation. While no search is in progress, Backspace and Delete clear all checked options.

“Check for updates” can offer the publicly released build. Choosing “Check for updates” from the menu now also looks at the build published on the official download page and offers it when it is newer than what your current update channel would provide, up to the version your administrator allows. Automatic background checks are unchanged.

A view that fails to load because of a field error now names the field at fault. When the database rejects the query behind a view - for example because a field's underlying SQL expression refers to an ambiguous or missing column - the message now points at the specific field and its expression. It suggests removing that relation column from the active view to load right away, and tells you whether to correct the expression in LISA yourself or to ask an administrator, depending on your rights.

Filter validation report. A new diagnostic action on a saved filter opens a side-by-side report showing the filter as written, the form the system rewrites it to (sub-filters resolved, conditions merged and optimised), and the record count returned at each stage - backend query before optimisation, backend query after optimisation, and a step-by-step client-side composition. Any discrepancy between what the user expected and what they got is traceable to a specific stage. Each top-level sub-filter carries its standalone match count, every field resolves to its human-readable name and option labels, and a structured diagnostic log captures the internal decisions made during sub-filter merging and SQL generation. Intended for the “this filter returned weirdly few/many records” support case.

Filter validation report flags self-eliminating user logic. A user-authored filter whose conditions mathematically reduce to “matches everything” or “matches nothing” - typically two NOT IN conditions joined with OR, or two IN joined with AND over disjoint value lists; or any leaf arriving with an empty value list - now shows the affected leaves in the report's filter tree inside a dashed amber frame with an “(eliminated by optimiser)” badge whose tooltip names the rule that dropped it. For the operator-flipped pattern (same operator on both sides plus the opposite boolean) the diagnostic log adds an actionable hint such as “If the intent was to exclude both values, the surrounding group should be ALL OF (AND), not ANY OF (OR)”. The same collapse occurring inside a programmatically-merged filter (sub-filter fused into a host filter during evaluation) is logged at Info instead of Warning - the elimination there is an expected merge by-product rather than a usability problem.

Inspectors with web-based action panes share the embedded browser engine across opens. The first inspector in a session sets the engine up; subsequent inspectors reuse it instead of building a new one each time. Open latency drops noticeably from the second inspector onwards, and the page's compiled JavaScript stays warm in the renderer's cache between opens so it doesn't have to be re-parsed every time.

Inspector contents appear sooner after the page finishes loading. The hand-off between “navigation complete” and “show the page” was going through an extra internal queue hop that could add several hundred milliseconds when the application was busy. That hop is gone, so the inspector switches from blank to populated more promptly.

VBA and binding work dispatches in priority order. Async work in the application now runs in priority buckets — click-driven work runs ahead of background data-source work, and idle-priority work only runs when the UI thread is otherwise quiet. Background items that have been waiting too long are promoted automatically so nothing is starved. Per-pump-cycle work is wall-clock-bounded so the UI thread stays responsive while the queue catches up. Solution developers can target a specific bucket by passing an optional priority argument to Application.RunEx — positive values mean foreground, 0 is normal, negative is background, and -10 or lower is idle. Existing scripts continue to default to normal.

Filters that reference themselves no longer fail with internal errors. Filter expressions that loop back to themselves through a sub-filter chain — directly or transitively — are now detected and the self-referencing portion is skipped. The rest of the filter still runs. Previously these cycles produced either a generic internal error or a silently incorrect result.

Some filter queries now use database indexes that they previously bypassed. Specific patterns in the generated SQL were wrapping indexed columns in functions that prevented SQL Server from doing an index seek. Three of those patterns — aggregate comparisons that already include zero, ORDER BY against non-nullable columns, and certain sub-filter null guards — now emit SQL that the optimizer can use indexes for. Expect noticeable speed-ups on the affected filter shapes.

Switching between records no longer re-fetches the URL when the record has not actually changed. Inspector cards with a web action pane were re-running a backend URL lookup on every internal record-update notification, even when the assigned record was the same one already shown. The lookup now only runs when the record reference actually changes.

QueryTimeout now bounds total wall-clock duration, not just the backend command time. Filter QueryTimeout previously governed only the time the backend had to answer; the client-side wait — initial grace period plus the simultaneous-queries queue — was outside the budget. For short timeouts behind a busy queue the perceived wait could be many times the configured value, even when the backend itself completed within budget. The budget is now resolved once up front and applied both to the queue wait and to the resulting backend command timeout. When the entire budget is consumed before the request leaves the client, the user sees an explicit “Wall-clock timeout expired while waiting in the client-side query queue” message rather than a generic failure — distinguishable in telemetry and support from a server-side timeout. Sub-filter timeouts no longer extend the top-level budget.

Faster failure for misconfigured option fields. Auto-generated relation-option queries — synthesised when no hand-coded option query exists — now time out at 1 second instead of 10. A broken auto-generated query fails fast rather than freezing the inspector for the full 10-second window. Hand-coded option queries continue to use the 10-second default.

Inspector controls and the embedded browser initialise in parallel. WebView2 environment startup, controller creation, profile setup, cookie sync, and the initial navigation now begin while the backend record fetch is still in flight, rather than being gated on the first paint of the host control. Inspectors with web-based action panes open with lower visible latency.

Robustness improvements and better error messages around the embedded browser engine. When the engine fails to start within ten seconds — typically because another Lime instance is holding the user data folder, or because the WebView2 Runtime is corrupt or a renderer child is wedged — Lime now reports an actionable error naming the likely cause rather than letting the inspector hang indefinitely. Engine child processes (renderer, GPU, crashpad) are now closed in order during Lime's shutdown rather than left running as strays. The pool that shares the engine across inspectors also detects and recovers cleanly when WebView2 auto-updates itself between sessions.

Action Pane renders as a unit. VBA bindings on the action pane are now drained in batches per UI pump iteration, and the slide-down animation that staggered each row's reveal has been removed. The pane appears assembled in one paint instead of visibly rendering itself row by row.

DebugView trace for silently-dropped filter conditions. Filter conditions discarded during query generation — typically because the source field doesn't exist in the current schema — now emit a DebugView line identifying the discard, so configuration drift is easier to diagnose.

Lime-link errors now identify which link failed. Errors raised while processing a limecrm:// link — out-of-memory conditions, internal-error catch-alls, and “no class specified” parse failures — now append the offending URL to the error message. The information also reaches the support telemetry channel as a structured event rather than a breadcrumb, so recurring failures in customer environments can be diagnosed without reproducing the case locally. The link URL is preserved across cross-process dispatch (when one Lime CRM instance hands a link off to another via the standard limecrm:// protocol handler), so the receiving instance can report the original URL even when the link arrived second-hand.

Clearer dropdown status texts in link fields. The footer tooltip now says “loaded” rather than “matching” for the partial-results case — the larger number is the loaded set, the smaller is the matching subset, and “matching” was ambiguous about which it qualified. When a backend search returns no rows, the footer states “No matches” outright instead of pointing the user back at the keyboard shortcut they just pressed.

Inspector splitter rework. The Fields tab now retains its state when you navigate between records, the inspector splitter supports smooth drag-resize with animated transitions, and the splitter position is remembered per inspector layout.

Improved field layout in inspectors. Mixed rows that combine a multi-line field (such as a memo or expanded list) with single-line fields no longer leave awkward vertical gaps next to the single-line fields. Inspectors with an expandable field at the bottom now extend that field to fill the remaining space, matching typical form-layout expectations.

Multi-line notes resize live with content. Multi-line text fields in the inspector — Notes (Anteckningar), History, Description, Memo — now grow and shrink as you add or remove content, without having to manually drag the splitter or scroll within the field. When the inspector is compressed, the field keeps at least three lines visible so small notes don't end up behind a scrollbar.

Filter robustness for invalid option values. Pre-existing filters that reference option-set entries no longer present in the data model — values that have been renamed, removed, or otherwise can't be resolved — no longer break the query. Invalid entries are skipped, the surviving values continue to participate, and the filter still runs.

Filter values resolve across locales and ID formats. Filter values authored against the canonical English label, or stored in the semicolon-wrapped ID form that some integrations produce, are now resolved automatically. The user's active locale no longer has to match the value source.

Link-field dropdown search is faster and quieter. Typing into a link field's search box now debounces briefly before querying, so fast typing no longer fires one search per keystroke. Subsequent searches against the same field skip records already known from earlier matches, cutting redundant round-trips. The search box also auto-fills the longest common prefix of the matching options as a selected suggestion — keep typing to override, accept it as-is, or use it as a fast way to disambiguate similar entries.

Long dropdown entries stay readable when the search needle falls in the middle. When a dropdown row's text is wider than the cell, the in-progress search needle inside the displayed value is replaced with an ellipsis so the surrounding context (record description, trailing key data) remains visible.

Link-field dropdown now shows match count and search source. The dropdown popup carries a footer strip with two pieces of feedback: on the left, how many entries match against the total available (with a + when more results were truncated at the server fetch limit); on the right, a glyph indicating where the current results came from — the field's preloaded option list, the local search cache, or a live server lookup. Hovering either area shows a tooltip with details and the relevant keyboard shortcut. When the cache produces no matches, the footer replaces the counter with an explicit hint that a server search is one keystroke away.

On-demand server search from the dropdown. Two new shortcuts let you reach past the local cache: Shift+Enter escalates a zero-match cache result to the server (so “no matches” doesn't quietly mean “not loaded yet”), and Ctrl+Enter discards the local cache entirely and forces a fresh server lookup (useful when you suspect the cache is stale). Both work from inside an inline cell editor without committing the cell.

Right-click and middle-click on link-field dropdown rows. Right-clicking a row opens a context menu with Select, Cancel, Open in desktop, and Open in web client. The web-client entry follows the same per-class gating and prefer-web-client ordering already used by the main right-click menu, so administrators only need to configure web access in one place. Middle-clicking a row opens the inspector for that candidate directly without changing the linked record, and the dropdown stays open so you can keep browsing. Opening an inspector or switching to another application no longer dismisses the popup or loses the in-progress search — focus returning to the link field restores the popup at the same scroll position.

Natural alphanumeric order in link-field dropdowns. When the filter doesn't narrow the cached options (empty search, or a search that matches every loaded row), entries are now sorted so that File 2 sorts before File 10 rather than between File 19 and File 20. Fields backed by a fixed option list retain their curated order.

Optional relevance scoring for link-field search. A new Use relevance scoring for searching relations checkbox under Options → Misc ranks search candidates against a small set of signals — how recent the record's activity is, the position of certain option values (todo / SOS / history / document status), and whether the record is associated with the active user (responsible coworker, creator, or last editor). Off by default and stored per user. Intended for solutions where the obvious “best match” rarely sorts first alphabetically.

The update no longer restarts the computer on its own. When a component of the update needed a restart, the update could restart the computer without asking. The update now never restarts the computer. The restart is completed at the next normal restart of the computer.

VBA works again after the update. After the update to 11.3.4694 or 11.3.4695, the client could report “One of the VBA components is missing or corrupt”, and the VBA setup stopped with an error about FM20.DLL. The update had removed the Visual C++ 2010 runtime that VBA needs. The VBA setup now installs this runtime itself, so a later update cannot remove it. Computers that already have the problem are repaired by this update.

A manual installation no longer stops at an empty setup window. When Lime, or an Office application with a Lime add-in, was running during a manual installation, the setup window could become empty with no button to continue. The setup now shows the list of running applications and asks you to close them. The previous Abort, Retry, Ignore box, which could open behind Lime, is removed.

Running Lime is closed in a controlled way during an update. The installation now asks a running Lime to close through the Windows Restart Manager. In a manual installation the setup lists the applications and asks first. In an automatic (passive or quiet) update they are closed without a question. A Lime that does not close when asked is ended only in an automatic update, or when the setup variable ForceClose is 1.

Lime keeps running when a Windows logoff or shutdown is cancelled. Lime closed without a question also when another application or the Restart Manager cancelled the logoff or shutdown. Lime now closes only when the session really ends.

Lime starts after the whole update is complete, and in front of other windows. After an automatic update, Lime could start before the VBA components were installed. Lime now starts when everything is installed. It also comes to the front, unless you have moved to another window in the meantime.

The installation ships a newer Visual C++ runtime. Some components need a newer Visual C++ runtime than the setup required. The setup now installs Visual C++ runtime 14.51 when the installed version is older. Earlier, any version from 14.38 was accepted.

The mouse pointer no longer disappears over Lime windows. The pointer could become invisible while it was over a Lime window, for example at the login dialog or during the “tasks to do” message at startup. It came back only when it was moved to another program. The client now detects a hidden pointer that the user moves and shows it again. It also no longer removes the pointer when Windows cannot load a cursor. That is a known Windows issue on non-English installations.

A mail from a template now contains the values you have not saved yet. A mail created from a template on a card used the values last saved in the database. A value you were still typing, or any change not yet saved, was missing, and no message was shown. The mail now uses the values that are on screen.

Duplicating a card keeps the values you have not saved yet. Duplicating a card created the copy from the values last saved in the database, so all unsaved changes were lost. The copy now contains the values that are on screen.

Dragging and closing tabs works correctly. Dragging a tab could change the order of other tabs, especially tabs scrolled out of view, and a wide tab could not be moved to the first or last position. A drag now moves only the dragged tab. “Restore tab order” is now saved, so the old order does not return at the next start. Closing a tab, with the middle mouse button or during a drag, could make the client crash. This is fixed.

A card no longer jumps to the bottom when its layout changes. When a change on a card showed more fields, for example a new category on a helpdesk card, the card scrolled to the bottom. The card now stays at the top. A card that you had scrolled to the bottom stays at the bottom, as before.

Sorting a list by a reordered option field no longer fails. Sorting by an option field whose options were reordered in LISA could fail with the error “ORDER BY items must appear in the select list if SELECT DISTINCT is specified”. The list now loads in the expected order.

A “not in” condition on a relation now includes records with no related records. A condition “<relation> not in <sub-filter>” left out records that had no related records at all. These records now match, so “not in” returns exactly the records that “in” does not return.

A count over a to-many relation of a parent record no longer fails. A filter that counted the related records of a parent record, for example the orders of an order's agreement, made the list fail to load with a server error. The filter now loads and counts correctly.

The text of a filter condition shows the correct field name. A condition on the id field of a related record type was described with the name of the current record type, for example “[Order]”. It now shows the localized name of the field.

A list that failed to load reloads when you change the filter or view. After a list failed to load, a change of filter or view did not load the list again. It now loads the list again. If that load also fails, the list stops and does not retry without end.

The options for including record type filters and views now work. The two options in the Options dialog for including the filters and views of a record type were ignored. The client always included them. The options now work after the next start, and their text says so. The option for the browser control no longer says that a restart is required, because it is not.

The record information shows the user name when the user has no coworker card. The “created by” and “modified by” fields were empty for a user without a coworker record. They now show the user name. This also covers a deleted coworker record and a record with no description.

Filter notes keep their line breaks. Notes on a filter showed correctly while you typed them but became a single line after a restart. The line breaks are now kept.

Saving a filter, view or template no longer sends read-only server values back. The client sent four values that only the server calculates (last access user, last access time, cost and points) back to the server when it saved these items. It no longer does.

Views and filters with a name that starts with a bracket are listed last again. In 11.3.4564, a view or filter name starting with “(”, “[”, “{” or “<” was listed first. Such names are again listed after all other names.

Action pads get the correct values from VBA functions. In an action pad, a VBA function called during data binding could return an empty value, and the field stayed empty. The action pad now receives the real value. An empty result from VBA is no longer remembered, so a later call can still return a value.

Action pad VBA calls run against their own card. A VBA call from an action pad on a card could run against the card that had focus instead of the card the action pad belongs to. The call now runs against its own card. When that card is already closed, the call is not run.

Each solution now has its own integrated browser profile. After a new login to another solution, the integrated browser could reuse the session cookie of the previous solution. Each server, database and user combination now has its own browser profile, and a browser control is reused only within the same profile.

Empty action pads now recover without a restart. An action pad could show only the pane background, for example after sending an e-mail or after a button that saves the record. Closing and opening the card did not help. Only a restart of Lime helped. The client now detects a browser process that has stopped responding, ends it and reloads the page.

The web bar refreshes even when a busy pointer stays set. When code set the busy (hourglass) pointer and did not clear it, the web bar did not refresh again for the rest of the session. The client now restores a busy pointer that an event handler leaves set. A refresh that waits for a busy pointer now runs after 60 seconds at the latest.

Server gateway errors now show a clear message. The HTTP errors 502, 503 and 504 from a gateway in front of the server showed only a single line with no explanation. 502 and 503 now say that the server is not available. 504 says that the server did not answer in time and asks you to check the result before you try again.

Closing the database no longer becomes slower over time. Each check-out created a folder in the local documents folder. Word could leave a small owner file in it, so the folder was never removed. Closing the database then became slower with every document template a user had used. Check-in now removes its folder, and the cleanup at close also removes folders that contain only such Office files.

Locking and unlocking a document can no longer make it impossible to open. Locking and then unlocking a document without opening it could rename the stored file, so nobody could open it. The same could happen at login. The client now uploads a document only when its content has changed, and never replaces a known file name or extension with an empty one.

A maximum document size published as text no longer blocks every check-in. When the server published the maximum file size in an unexpected format, the client read it as zero and refused every check-in. The value is now validated. At check-in, the client now only warns about the size, because the server decides what it accepts.

Replacing a checked-out document with changes is refused instead of losing the changes. When automation set a document field to another document while the current document was checked out and edited, the edits were discarded without a message. The client now refuses the change with a message, and the local copy stays. A script that wants to discard the edits needs to check in the document with “abandon changes” first.

The question about a document locked by another user is readable again. When you opened a document that another user had locked, the question showed an internal key instead of the text. It now shows the translated question.

Switching tabs no longer freezes because of the favorites cache. The favorites cache could grow very large, at one customer to 123,000 entries, because it recorded filters that are never stored on the server. Writing the large file during normal work made the client stop responding, for example when switching tabs. The cache now records only filters stored on the server, and is written only in the background and at logout. The cache file moved to the caches folder, and the old file is deleted once at login.

The Tools menu entry for your own record is faster and correct after a logout. The entry that opens your own user record read the record each time the menu was updated. It now reads it once per login. After a logout, the entry shows as unavailable.

Editing a document is protected against two people overwriting each other. When you open a document for editing, the client again takes an edit-lock on it: a colleague who opens the same document while you have it checked out gets it read-only, with a lock indicator showing it is held elsewhere, so a save of yours can no longer be silently overwritten by someone editing the same file at the same time. This protection had not been active for some time. If your team deliberately has several people edit the same document at once and would rather keep that, locking can be switched off - for one file type or for all of them - with the NoLock client setting: set NoLock to 1 under Application\FileExtensions\*.* to disable it for every type (for example HKCU\Software\Lundalogik\Lime\Settings\Custom\Application\FileExtensions\*.*\NoLock = 1), or under Application\FileExtensions\<extension> for a single type such as docx.

Filters that read a value from your own record now follow changes to it. A filter condition that takes a value from your user record (for example ActiveUser.Record) kept using the value the record held when you signed in, so editing your own card - or having it changed elsewhere - did not affect which records the filter returned until the next sign-in. The cached copy is now refreshed when your record is saved in this client and whenever you force a refresh of a view, so these filters match against the current value. Conditions that use only your record's id are unaffected.

An “is not empty” condition could be lost when a filter was optimised. A filter combining “is not empty” on a relation with another condition over a set of values could, after the internal query optimisation, silently drop the “is not empty” part, so the results wrongly included records whose link was empty. The optimisation now keeps the constraint, restoring the behaviour from 11.2.

The shared field list scrolls and is drawn correctly. In the dialog that creates history records for several records at once - and the other places built on the same field list - the scrollbar's line and page steps did nothing and dragging the thumb snapped to the top, the mouse wheel did not scroll the list, and the field area was painted with the wrong background. The list now scrolls by scrollbar, wheel and drag, and the field area matches the surrounding dialog and theme.

Double-clicking a maximized pane tab does something again. Double-clicking the tab area to maximize the panes worked, but double-clicking once they were already maximized did nothing. Double-click is a toggle again: the first double-click maximizes the panes and remembers the previous split, and a second restores that split (or a two-thirds split when no previous size is known).

A network folder link stored on a record stopped opening. After the launch hardening in 11.3.4523, clicking a field that holds the path to a folder on a network share or a mapped drive no longer opened it in Windows Explorer - the open was blocked or raised an unexpected security prompt - while links to individual files on the same share kept working. Folder links open again: opening a folder is treated as navigation rather than as launching a file, so the file-security check no longer applies to it. A folder that is currently unreachable behaves as it did before, with Windows reporting that it cannot be reached. Links to programs and documents are unchanged and still pass through the same security check.

A progress dialog could stay open after a background operation had finished. When a background operation that runs VBA finished while the VBA host was still showing a modal dialog or completing an asynchronous call, the progress window could remain open - and the application could spin at high CPU - instead of closing, even though the work itself had completed. Completion is now retried on a short timer that lets the VBA host settle first, so the progress window closes once the host is ready.

Dragging inside a field could move a pane divider, or the divider could jump to an edge. A click-drag that began inside a field and was released or moved over a pane divider (splitter) could resize the panes as if the divider itself had been grabbed, and in some cases the divider could jump to an extreme position. A divider now responds only to a drag that started on the divider, and ignores a stray drag that merely passes over it.

Opening a record through a filter that matches several records no longer fails. A customisation or report that opens a single record by a filter - rather than by its id - could stop with an “ambiguous results” error when the filter happened to match more than one record, even where having several is perfectly normal (for example a rental object with more than one floorplan picture). Such a filter open now returns the first matching record, the behaviour these customisations expect. Loading a record by its id is unchanged: two records sharing one id still points at a genuine data problem and is still reported.

Clicking an option in a multi-value field toggled it twice. A single click on an option in a checkbox-list (multi-select “set”) field checked it and then immediately unchecked it, so the click appeared to do nothing; if the mouse moved between pressing and releasing the button, two different options toggled. A click now toggles exactly one option, on release. Mouse and keyboard handling in these fields was reworked in the same pass.

“Save as…” on a document could silently do nothing. On machines with a restrictive Windows attachment-security policy, choosing “Save as…” for a document opened the file dialog but then saved nothing, with no error message. The shell security check - intended only to warn about risky files - was being applied before the file was written and treated a policy block as a silent cancel. The check now runs the same way it does when opening a document: a file the policy considers unsafe raises a prompt offering to save it anyway, while an ordinary document saves without interruption.

A saved document's file name could repeat its extension. When a document record carried its name with the extension already included, saving it produced a doubled name such as report.pdf.pdf. This affected “Save as…”, the multi-document save, and documents attached to an outgoing e-mail. The extension is now appended only when the name does not already end with it.

Copying a record could leave out a field named like a built-in column. Copying a record (Record.Copy / CopyTo) skipped any field whose name matched a system column - most often a customised status field - treating it as the built-in column and excluding it, so the copy came back missing that value. Such fields are now copied; only the genuine built-in system columns are skipped.

Opening an inspector could occasionally hang. When an inspector's VBA read a record value that was still being lazy-loaded, the UI thread could take the record's lock and then wait for the background load, while the load worker waited for that same lock to deliver the value - a deadlock that froze the application. The pending load is now drained before the lock is taken, and its result - the loaded value or a load error - is applied or surfaced rather than left unhandled.

The application could freeze in several more situations involving record locks. Following the inspector fix above, a wider review removed the remaining cases where two operations could each wait on a record lock the other already held and hang the application. The cases covered were: setting a field value that displaces related records, refreshing the choices of a relation field whose options depend on another field on the same record, and the batch operations used by imports and bulk edits, including saving or deleting an attached document during a batch. These paths now release the record lock before calling across to other records or documents.

A relation field's dropdown could show outdated choices after another field it depends on was edited. When a relation field's option query references the value of another field on the same record (for example, the available companies depend on which country is selected), changing that other field and returning to the relation control kept the previously-loaded choices in view. The dropdown now reloads the choices on return whenever the underlying option set has been dropped - both when typing into the field and when clicking the arrow to open the list.

The current selection in a relation field narrowed its own search. Reopening a relation field's dropdown on a record that already had a value (with F4 or the mouse) showed only the entries matching that value instead of the full list. The search now filters on what you type, not on the text of the current selection or the autocomplete suffix, so reopening the dropdown shows the broad list again. In addition, Shift+Enter now searches the server first and falls back to the cached results - the reverse of plain Enter - so a fresh server lookup can be forced when the cached list is not enough.

The client could close unexpectedly when switching away with a field dropdown open. With a relation or multi-value option field's dropdown showing, switching to another application - or an action that hid the open record while the dropdown was still up - could occasionally close the client without warning. The dropdown is now dismissed safely in these situations.

The login dialog could show the wrong form after switching server. When picking a different server or database from the Browse dialog, the form on screen could remain set to the previous server's login style - the web-based login or the classic username and password fields - so credentials could not be entered until the dialog was closed and reopened. The dialog now resets to a loading state during the switch and then settles into the form that matches the new server.

The login dialog did not recover when network connectivity returned. Starting the client without a working network connection put the login dialog into an error state that did not clear when the connection came back; the dialog had to be closed and reopened to retry. The dialog now listens for network changes and re-checks the server automatically once an internet connection is available. The automatic re-check only runs while the dialog is showing the error state, so anything typed into a working login form is left alone.

The active tab could be drawn wrong or stay hidden when tabs were scrolled to the right. With more tabs than fit, when the strip was scrolled so the active tab sat off the right edge, that tab could render incorrectly (for example showing only its icon) or stay out of view. The active tab now draws correctly in this case and is scrolled into view, including the tab that is already active when a record is first opened.

Hardened rendering of content defined in CRM customisations. Content rendered from CRM customisations is now sanitised across more of the paths it can reach, closing ways that crafted data could run unintended script. Legitimate integration links and custom address schemes are unaffected.

A checked-in document could be published against the wrong record. When a document was checked back in while it was concurrently repointed to a different document, the check-in could overwrite the wrong record. Check-in now re-confirms the document's identity, not just its file, before publishing.

Double-clicking a record to open it no longer causes a phantom click on the inspector that just appeared. With opens now fast enough that the inspector window can appear under the cursor before the user finishes releasing the second click, the trailing up of the double-click was leaking into the new window — focusing a field, dismissing a popover, or triggering whatever was under the cursor. The leak is now suppressed at the application level for all mouse buttons.

Global search no longer fires against servers that do not support it. The global-search popup is now gated on whether the connected server actually has full-text search enabled, not just on whether the search-bar is visible.

“Show super search on cards” setting controls inspector-card visibility again. A regression in earlier 11.3 builds caused the legacy super-search bar to appear on every inspector card regardless of the EnableInspectorFullTextSearch admin checkbox under Options → Misc. 11.2 behavior is restored: the bar shows on inspector cards only when the admin has opted in. The main window's bar follows the same capability check and stays hidden when neither the webclient integration nor server-side full-text search is available. Setting changes — the opt-in, the IntegrateWebClient / AllowWebClient toggles, or the server's full-text configuration — now reflect on every open inspector and the main window without needing to close and reopen anything. A new View → Bars → Search bar menu entry lets users hide the bar manually within the limits of the capability gate; the menu item is greyed out when no supplier is configured.

Filters with OR-joined “not in” conditions now return the correct results. An internal simplification of expressions shaped like NOT IN A OR NOT IN B was producing the wrong set. The simplification is corrected.

Inspector layout no longer flickers between expanded and collapsed states. A measurement bug in the auto-expand logic could leave the layout oscillating across re-layouts; the calculation is now font-relative and stable.

Server-search shortcut no longer fires on link fields backed by a fixed option list. The local options list is complete by definition for these fields, so the Shift+Enter shortcut now no-ops instead of round-tripping to the server.

TAB on “No matches” cancels instead of linking an invisible row. When typing in a relation field's search box filtered the popup to zero matches but the underlying preloaded options list was still populated, TAB would silently link the first entry in the unfiltered list — typically an option that didn't match what was typed and that the user never saw. TAB on a no-match popup now treats the action as Cancel (same as ESC and the right-click Cancel menu entry) and lets focus move normally to the next field.

Prefix matches always rank above interior matches in relation search. When the typed text appears at the start of an entry, that entry now sorts above entries where the same text appears in the interior, regardless of the field's secondary sort (curated option-list order, logical alphanumeric, or cache relevance). Matches the user expectation that “what I typed should be at the top of the list”.

Dropdown row text stays visible when the typed text matches the entire item. The long-row overflow elision (which substitutes the typed search text with an ellipsis to keep surrounding context visible) no longer collapses the row to a lone ellipsis when the entire item value equals the typed text. The row falls back to clipping at the cell boundary, so at least the prefix of the entry remains readable.

Auto-generated relation-option queries skip virtual fields. When synthesising filter conditions from the source record's other relations, the path now skips link fields backed by SQL expressions (no physical column) and link fields without an in-table foreign key. Those edges can't participate in the synthesised join and previously caused either backend errors or filters that referenced the wrong column.

Inactive-row filtering respects the “active” naming convention. Classes whose inactive-flag column is named active (value 0 = inactive) now compose the auto-include-inactive filter with the correct polarity. Classes using the legacy quit convention continue to work unchanged.

Whitespace inside formula strings survives transpilation to VBScript. Lime-formula expressions containing significant whitespace inside string literals were being collapsed by the formula-to-VBScript lowering pass; the literals are now preserved verbatim across the lowering.

Re-entrancy crash when multiple Lime links arrive close together. In CTI integrations that fire several limecrm:// links in rapid succession — call-center popup sequences in particular — a nested message pump inside one link's inspector creation could dispatch the next link's queued work, run it, and clear the shared queue out from under the outer iteration. The outer iterator then pointed into a cleared list, producing an access violation that the catch-all path reported as a generic “Internal error”. The receiver now snapshots its queue at entry, so nested re-entry can never invalidate the outer iteration; newly-arrived links stay on the queue and are drained on their own scheduled turn — nothing is lost.

Nested field paths in filters no longer cache a partial resolution. Filter conditions that referenced a related-record field via a dotted path — for example, document.fileextension — could fail with a misleading “is not a valid value” error from the backend after the first attempt failed. The internal resolver was caching the partial path it had walked before the error, so subsequent calls saw the cached prefix as a successful resolution and produced a condition that referenced the wrong column. The resolver now caches only after the full path resolves cleanly; failures stay failures, and the next call retries against current schema state.

Filters that combine multiple sub-filters no longer fail with “Condition field not found”. Some filter shapes that merge a sub-filter into the outer query — particularly those that reach across a relation into a nested expression — could fail at evaluation time because an internal join-scope path notation introduced during the merge was leaking into the field lookup. The lookup now strips that notation, so the previously-failing filters run as the user wrote them.

Internal-error reports name the real source location. “An internal error has occurred in source file …” dialogs previously reported the same line (the line inside the catch wrapper) for every catch-all-handled exception, regardless of where the exception actually came from — useless for diagnosis. The message now identifies the actual call site of the catch that fired.

Record.Value with mixed-case field names works again. A regression introduced earlier in 11.3 caused Record.Value(“xyz”) (or any other case variant of a field name) to silently return nothing once a different field had been looked up first in the same record. Mixed-case lookups now work consistently regardless of the order they're made in.

Filter conditions for set-typed fields match whether the value is a single string or an array. Previously the same value resolved to different conditions depending on how it was passed: Field.Value = “Privat” bypassed the option-label lookup that Field.Value = Array(“Privat”) performed. Both forms now produce identical conditions.

Column-filter checkmarks return for set-typed fields. Selecting a value in the column-filter dropdown for a set-typed field shows as checked again. The dropdown also de-duplicates correctly — re-clicking a checked entry removes the condition instead of adding a duplicate — and saved set-field column filters reload as proper conditions instead of being silently demoted to a text match.

Decimal precision preserved when filtering. Filter values for decimal fields were silently truncated to integer before reaching the query, so fractional values were lost. Decimal values now flow through unchanged.

Client no longer hangs when scripts modify records during AfterSave. A VBA AfterSave or BeforeSave handler writing back to the record while the underlying record load was still in flight could deadlock the client until it was force-killed. The locking and async-load sequence is now coordinated so the handler proceeds without blocking.

Refresh in AfterSave handlers no longer deadlocks. A Controls.AfterSave handler calling Controls.Refresh() could deadlock against the still-running save flow. Refresh now defers correctly until the save flow exits and runs from there. A small set of related save-state tracking issues were addressed in the same pass.

Ambiguous-record errors now identify the offending record. When the duplicate-row check trips during record load, the error now names the class and record ID so the entry can be located in the data. Definitive load errors that previously got absorbed into a generic warning are now surfaced to the user.

Adding participants to a campaign no longer fails with “Item not found”. When the participant class had a virtual relationsingle field marked invisible-everywhere, the wizard's confirm step threw Item not found and aborted. The wizard now excludes virtual fields from its candidate field list — those fields were never assignable, so listing them was always a no-op (silent in 11.2, loud after 11.3's stricter field-list checks).

Mass update auto-refreshes the table again. A regression vs 11.2 left the explorer showing pre-update values until manually refreshed. The Mass Update dialog now has a “Reload list after update” checkbox — default on, persisted per user — that requeries the explorer when the batch completes. The label notes that records can drop out of the visible list if their new value no longer matches the active filter.

Inspector fields follow the splitter when scrolled to the bottom. Dragging the inspector's bottom splitter down with the field list scrolled to the end used to leave the fields anchored at their old screen positions with empty space below — the scrollbar range updated but the controls didn't move. They now reposition against the new scroll position so the bottom of the field list stays anchored to the bottom of the viewport.

Stability when controls are detached. A null-pointer crash that could occur when fields fired before/after-command events on a control that had already been detached from its inspector is fixed. The previous symptom was a generic “internal error” log entry with no indication of cause.

Avoided crashes from circular control configurations. When custom inspector layouts placed controls in mutually-referencing arrangements, an internal lookup could recurse and exhaust the stack. A guard now stops the recursion safely.

Client-side incremental refresh reverted. The incremental refresh optimization shipped earlier in 11.3 produced unexpected load patterns on the backend in production. It is reverted in this build; refresh runs the full query as it did before the optimization. The optimization will be re-introduced once the backend impact is resolved.

Trailing multi-line note fields fill the inspector again. Form definitions that used the legacy -1 “fill remaining” indicator on a multi-line field (such as Notes / Anteckningar in History inspectors) regressed to only two lines in earlier 11.3 builds. They now extend to the bottom of the inspector, matching 11.2 behavior. Short notes display without scrollbars; longer notes that need a scrollbar still get a usable three-line pane minimum even when the inspector is heavily compressed.

AllowWebClient is opt-in again. A regression caused AllowWebClient to default to enabled in the Misc options page; opening Options → Misc and clicking OK silently persisted it as enabled. The dialog default now matches the runtime opt-in design. The setting also moved from per-Windows-user (HKCU) to database scope, so admins can manage it centrally and stale per-machine values from earlier 11.3 builds are ignored.

Settings lookup tolerates a missing database. GetSettingInherited previously threw when Application.Database wasn't available - typical during early startup or after a disconnect - instead of falling through to the application-scope value. Missing database now means “no value at the database scope” and the lookup continues.

Record.Copy / Record.CopyTo no longer moves or duplicates related records. Two distinct issues fixed: related entities reachable through any relation whose foreign-key column lives on the related side (virtual or not, single-link or multilink) were being reassigned to the new copy when saved, effectively moving them rather than copying — the source no longer loses its links. Separately, a 11.3-era deep clone branch for plain 1:1 link relations fabricated a phantom companion record on every copy; that branch is reverted to 11.2's no-op for the 1:1 case, so copying no longer creates extra related records the user didn't ask for.

Inspector bottom splitter no longer locks in transient view states. Earlier 11.3 builds persisted the “fields collapsed” and “fields maximised” view states using sentinel values that were meant to be transient, so the inspector could come back stuck in one of those states on next launch. The persistence layer now ignores the legacy sentinels and emits values that round-trip cleanly.

Lime CRM shows the correct icon in Windows Explorer. A new icon resource added during 11.3 shifted icon-resource ordering, causing Windows Explorer to pick a generic shape icon instead of the Lime logo for lime.exe. The original logo is restored. Users on machines where the icon cache had latched onto the wrong icon may need a one-time Explorer restart before the corrected icon shows up.

Dim-fields-when-null is now opt-in. Following customer feedback, the visual dimming applied to fields whose value is NULL no longer defaults to enabled for new users. Users who actively enabled it keep their setting; users who never opened Options → Misc no longer see dimmed fields out of the box. The toggle is still available under Options → Misc.

Update-field dialog targets the field you clicked, not a same-named system field. When a custom field's display name collided with a system field of the same label (e.g. a solution-defined Status alongside the built-in Status (System)), the dialog could open against the system field instead of the one the user picked from the column-header menu. The menu now passes the actual field reference instead of re-resolving by display name. The same fix applies to the explorer's view, filter, and Send-to menus, and to field pickers in the view-edit, filter-condition, and formula dialogs.

Explorer no longer leaves empty placeholder columns for missing fields. When a view referenced fields that don't exist in the data (renamed, removed, or otherwise not loaded), the explorer kept empty column slots for them. Those slots desynced the column index used by sort and cell-rect math. Missing fields are now skipped completely so column-indexed operations stay aligned.

Action Pane no longer blanks after hide-then-show. Hiding the inspector's Action Pane and showing it again could leave the pane visible but with the embedded browser blank. The host now explicitly re-attaches and repaints the browser when the pane becomes visible again.

Inspector bottom splitter no longer restores at a sub-row sliver. Some startup paths (particularly the first card opened from a solution, where settings can race with VBA-driven record loading) could leave the splitter a few pixels from the top — the controls area effectively unusable. The splitter now applies its standard default position when no settings are available, and any persisted value smaller than a single layout row is treated as corrupt and falls back to the default.

Maximize-tabs toolbar button reflects the effective state. The button's pressed-state and overlay glyph used to require the splitter to be exactly at its minimum position to register as “maximized”. Any controls area smaller than one layout row now counts — matching the user's perception that the controls area is gone.

Maximize-tabs toolbar button restores to the default position. Clicking the button while tabs are maximized used to expand to the splitter's last drag-saved position, or to the midpoint if no drag had been saved. It now expands to the standard default position (tabs at the auto-expand limit from the bottom). The last drag position is still available via double-click on the splitter bar itself.

Drag-drop save silently lost edits on the new record. Dropping a document onto an explorer item could create a record that the open path internally marked as a dummy placeholder. Subsequent saves silently no-op on dummy records — but BeforeSave and AfterSave events still fired, making the failure invisible. New records are no longer marked as dummies during the open path, attempted saves on a record that is a dummy now log as an error rather than silently no-opping, and any inspector that does end up bound to a dummy now opens read-only so accidental edits can't be lost.

First / last / previous / next record navigation works again. The toolbar's record-navigation buttons could fail with Index out of range or a generic Invalid parameter error, with the inspector refusing to move to the requested record. The inspector's current-record position resolution is more robust against the case where the active item's stored position hasn't been renumbered against the explorer's sorted view, and a related validation step that was rejecting otherwise valid navigation targets has been corrected.

Enter saves again when editing inline in the explorer. Earlier 11.3 builds inverted the Enter / Ctrl+Enter contract for inline cell editing — plain Enter moved to the next cell instead of saving the row, and customers reported it as the inline editor “essentially behaving like Tab”. 11.2 semantics are restored: Enter saves and closes, Ctrl+Enter moves to the next cell within the row, Ctrl+Shift+Enter moves backward. Multi-line text controls inside the cell continue to consume Enter and Shift+Enter for paragraph and soft-line breaks as before.

Record shortcuts pasted into Outlook or webmail clients open again. Copying a record put two clipboard formats on the system clipboard, one of them an HTML payload containing a limecrm-shortcut link. The link inside that payload was URL-encoded a second time before being embedded, so a space arrived in the recipient's mail as %2520 instead of %20 and the link no longer resolved. The redundant second encoding is removed; the plain-text clipboard format was never affected.

Scripts writing to mixed-case fields target the right field again. A regression caused by 11.3's case-insensitive Record.Value lookup let writes such as rec(“dealstatus”) = x fail with Status (System) is read-only on classes that had both a built-in status field and a user-defined dealstatus field — the lookup was crossing the two during cache resolution. The lookup now keys on each field's own local name, so writes go to the field the script names and read-only system fields no longer absorb the write.