VisuaLeaf v1.0.2234 Release Notes

Release Date: August 23, 2026

Headline: Rebuilt Data Sync, 32 SQL Engines, and AI That Designs Your Schema

Data Sync, rebuilt — continuous replication between any pair of MongoDB and SQL connections, in any direction, with live change capture, a cutover checklist that refuses to say "ready" when it isn't, and reconciliation reports that prove the target still matches the source.
32 SQL engines you can actually pick. Ten are new — TimescaleDB, Neon, Supabase, Azure Database for PostgreSQL, Citus, Azure SQL Database, CrateDB, QuestDB, RisingWave and Materialize — but the bigger win is that twelve engines you already had were invisible from the screen most people start on. Every picker in the app now shows the same list.
AI that designs your database and builds your charts — describe what you're building and get a real ERD on the canvas, or describe a chart in words and get it built, query and all.

Alongside those: customisable keyboard shortcuts across roughly 180 commands, a rebuilt mock-data generator, folders in every saved-items library, a dockable Data Viewer, in-place row filtering in every grid, multi-line MongoDB queries with Shift+Enter, a much faster export pipeline, a smoother connection tree that now shows Supabase, Neon, Aurora and the other managed services by their own logo, and a 70 MB smaller app.

There's also a set of fixes for numbers the app used to report that were simply not true, and the Notes at the end matter this time — every saved diagram is rewritten on first launch, and SQLite now enforces foreign keys.

Data Sync, Rebuilt

Continuous replication between any pair of MongoDB and SQL connections — PostgreSQL, MySQL/MariaDB, SQL Server and Oracle — in any direction.

What you can see

Reconciliation reports that prove the target still matches the source, at three depths: count only, sampled content checksums, or a full document diff naming the exact mismatched ids. A count on its own can't tell a lost write from a spurious one; the checksum tier can.
A cutover readiness checklist — initial copy, change capture, replication lag, dead letters and verification, each pass or blocked, with the remedy printed on every blocker. It is deliberately pessimistic: one pending dead letter blocks cutover, and that isn't configurable.
Schema drift raised distinctly — a dropped, renamed or recreated source collection, a dropped database, a missing target collection, a changed field type are each reported as themselves, with the choices available (re-seed, repoint, accept).
A dead-letter queue listing records that couldn't be written, inspectable and replayable.
Alerting and health for replication lag, dead-letter growth and clock skew.

What you can do

See the exact statements VisuaLeaf would run against your server before you consent to them — log-based change capture for SQL sources shows you every statement with its current value and its undo, one checkbox per consequence, and tells you afterwards what actually happened.
Confirm a clean drain before cutover. After you stop your own writers, VisuaLeaf watches the source, confirms the silence, freezes the job and verifies. Every response says explicitly what it is not claiming.
Re-copy a single collection of a running job without resetting the whole thing — previously that meant hours of re-copying collections that were never wrong.
Prepare a reverse sync for rollback after cutover. It's created stopped, and never guesses at an inverse transformation.

Speed, measured on one machine before and after: transformation scripts went from 1,993 to 17,326 documents/second, and with a 5,000-row lookup from 46 to 14,233 documents/second. Target writes went from 1,134 to 26,051 documents/second. The initial copy is now split across threads rather than running down one cursor. Refreshing a list of 50 sync jobs went from 601 server round-trips to 4.

Job limits are now checked when you save the job, so an unworkable configuration is refused while you're still looking at the form.

SQL: More Engines, and Controls That Know What Your Engine Can Do

The engine list

Ten new engines — TimescaleDB, Neon, Supabase, Azure Database for PostgreSQL, Citus, Azure SQL Database, CrateDB, QuestDB, RisingWave, Materialize. All ten reuse a driver you already have, so there's nothing new to download.
Twelve engines became reachable. The main New Connection screen offered ten SQL engines while an older dialog offered twenty-two. YugabyteDB, Redshift, both Aurora flavours, both RDS flavours, Percona, H2, DB2, Firebird, HSQLDB and Derby were fully supported and invisible from the screen most people start on. All six pickers in the app now show the same list — 32 engines.
A searchable, grouped picker with a live count. Typing "postgres" surfaces Neon, Supabase, Timescale and CrateDB. Cards lead with the product and demote the vendor, so "Amazon Aurora (PostgreSQL)" and "Amazon Aurora (MySQL)" are no longer two identical-looking truncated cards.
Nine new brand logos; engines with no official mark get a distinct shape rather than a generic cylinder.
A connection shows the mark of the service it actually talks to. A Supabase, Neon, Aurora, Redshift, Timescale, ClickHouse Cloud, TiDB Cloud, CockroachDB Cloud, YugabyteDB or Azure database is picked out from its address and gets its own logo in the sidebar, the connection lists, the tabs and the profiling screen — instead of the plain elephant or dolphin you got for choosing "PostgreSQL" or "MySQL" in the form, which is what those services tell you to pick. Hover the icon and it names both: "Supabase (PostgreSQL)". A self-hosted server is unaffected, and picking a branded engine yourself always wins over the address.
Pasting a connection string recognises the host, not just the scheme — a .neon.tech URL lands on Neon rather than generic PostgreSQL. SQL Server, Oracle and DuckDB URL shapes that the product's own output used to reject now parse correctly.

Controls that are honest about your engine

Every create, drop, alter and truncate used to be composed without consulting what the engine could actually do. Now:

Menu entries an engine can't perform are disabled before you click, and the description under the entry becomes the reason. On SQLite, Create New Database reads "An SQLite database is a single file — create a new connection pointing at a new file path instead." No tooltip to hunt for.
A brand-new Create Table tab used to be refused on 8 of 32 engines before you touched anything, because it opened with options those engines don't accept. Fixed.
Foreign Keys, Indexes and Auto-increment tabs explain themselves where unsupported, instead of silently vanishing.
Redshift foreign keys are now offered — they were being falsely refused — with the honest warning that Redshift stores and trusts them but never enforces them, so queries can silently return wrong results.
Every drawback is listed while you're choosing the engine, not discovered after a failure, and everything an engine can't do is reported at once rather than one failure at a time.
Sidebar folders that could only ever be empty on a given engine no longer appear at all.

Connection settings and sharing

Custom connection settings for SQL databases. Two concrete wins: Azure MySQL and PlanetScale could not be connected to at all before, and a default modern MySQL server would fail with an opaque key-retrieval error. The settings editor suggests the right options for your actual driver.
Choosing a driver version now takes effect on reconnect instead of silently requiring a full app restart.
Sharing a SQL connection works. The Share menu had never once succeeded. A read-only share is genuinely read-only — schema changes, table alterations, row edits, database create/drop and all user management require write access — and it says READ-ONLY on the screen with Run, Save and Drop greyed out, instead of letting you type a query and handing back a bare permission error.

Keyboard Shortcuts, Now Yours

One Keyboard Shortcuts window listing roughly 180 commands across the whole app with their real key combinations, grouped by area and searchable — matching the command name, the group, and the rendered combination, so you can search for the keys you remember pressing.
Rebind almost anything. Pencil, press your keys, Set, Save. Your bindings persist and come back on every window, popout and launch. Live preview as you go, closing without saving rolls back, and there's Reset to defaults per row and globally.
Conflicts are explained, not just blocked. A clash in the same context warns you and unbinds the other one; an overlap across different contexts is shown as neutral information — "Both keep working — the focused view wins."
While you're recording, every shortcut goes dead, so pressing Ctrl+W to assign it doesn't close your tab.
Keys that can't be reassigned carry a padlock and the reason — structural navigation and combinations owned by your OS or the editor.
Menu labels now tell the truth. They render your own rebound keys, and several were simply wrong before: Redo was advertised as Ctrl+Y when it is Ctrl+Shift+Z, Batch update was mislabelled, and Refresh literally displayed the text "TODO ACTION".
Three separate cheat-sheets (global, Shell, GridFS) are now one window; the Shell and GridFS buttons open it pre-filtered.

AI That Designs Schemas and Builds Charts

Describe an application, get a database design. With a diagram open, describe what you're building and the assistant draws real tables — it reads your current canvas first, including existing tables, column types, keys and the engine. Ten domain templates (e-commerce, B2B SaaS, blog/CMS, CRM, booking, LMS, project tracking, inventory, social, HR) and six cross-cutting patterns (multi-tenancy, soft deletes, audit trail, roles and permissions, versioning, localisation) back it up.
Merge is the default — new tables are drawn and existing tables gain columns without losing anything. Replace never happens silently; it warns and waits.
It reports what it actually did — "added 3 tables, added 5 fields to 2 existing tables, drew 4 relations", or "Everything suggested is already on the canvas — nothing changed."
Describe a chart and get it built. Works for both MongoDB and SQL: it picks the chart type, writes the query or pipeline, maps fields to axes and series, sets titles and axis labels, and can modify a chart you already have.
Nothing touches a live database — materialising a design is a separate, deliberate step.
The model picker is honest again. Claude Opus 5 was added, five withdrawn models removed, and every entry now shows a readable name with its provider model id. One was outright wrong — it said Haiku 3.5 while actually addressing Haiku 4.5.

Mock Data Generator, Rebuilt

An empty blueprint now opens on a chooser with three routes:

Ready-made datasets, with entity and row counts shown up front.
Realistic values — a searchable catalogue showing each generator's label, its path, and a live example.
Read from tables you already have — pick which ones to import, rather than importing a whole database and deleting thirty entities by hand.

Plus links between collections, written as a sentence: "Each orders row stores a key from [customers ▾] [its primary key ▾]". You choose the distribution — evenly, clustered, or a few get most, which is what makes a group-by look believable — along with one-each relationships, self-referencing hierarchies that can't loop, two-pass mutual references, and a blank percentage.

A live sample preview updates in a bottom panel while you edit, so a cycle or an impossible unique column surfaces before a million rows are written. Every run finishes with a copyable seed that reproduces exactly the same data. Generating for a whole database now works when you don't pick any collections, instead of silently producing nothing.

Reading Your Data

A Data Viewer you can dock. Open any cell, row, document or multi-row selection in a floating panel — right-click, or Ctrl/Cmd+Shift+V. In the SQL grid, double-clicking a truncated read-only cell opens it too. MongoDB values render in shell syntax and SQL JSON columns are pretty-printed, with a wrap toggle, Copy, and its own Ctrl+F. It's modeless, so the table behind it stays scrollable and clickable — and if you drag it to the edge of a panel, or use the four pop-out arrows, it becomes a real Data Viewer tab in its own split.

Filter rows in place, in every grid. "Show/Hide Columns" is now "Columns & Filters". Every column gets a condition (=, ≠, >, ≥, <, ≤, contains, starts with, regex, in, exists, is null) and a value box, filtering what's already loaded with no round-trip and no query rewrite. The footer says exactly that: "Showing X of Y loaded rows · this page only, query unchanged." Matching mirrors what the cell actually shows — ObjectIds as hex, dates matching both the displayed and ISO forms, SQL NULL cells matching "NULL" — and 64-bit ids compare exactly, so neighbouring Snowflake ids stay distinguishable. Your filters survive a restart with the tab.

Multi-line queries in MongoDB. Press Shift+Enter in the query field to add a line, the same way Compass does — Enter still runs the query, so the muscle memory you already have is untouched. As soon as there's a second line the query bar reflows: the editor gets its own full-width row with the Run cluster and actions moving up into a header strip above it, and it grows as you type. Delete the newline and it slides back to the single-line bar. Formatting a long $or or a nested $elemMatch across several lines no longer means squinting at one long strip.

Oversized results warn instead of freezing. A raw view over too many documents now says "Too large for the BSON view — this result holds 12,500 documents, past the 500 this view renders at once" with a Display anyway button. It used to freeze the app with no warning.

One Saved-Items Library, Six Screens

Queries, Scripts, Charts, Dashboards, JSON Schemas and Visual Schemas now look and behave identically. Every capability below is on all six, where each previously had a different subset:

Folders and subfolders anywhere, with drag-and-drop for a single item or a whole multi-selection, and a "Drop here" chip. Folders are genuinely new for Dashboards, JSON Schemas and Visual Schemas.
Inline rename — the row label becomes a text box. New for scripts, dashboards, JSON schemas and visual schemas.
Duplicate, new for JSON schemas and visual schemas.
Multi-select with Ctrl/Shift and bulk delete behind a single confirmation.
Search, Name/Date sort, keyboard navigation, and smooth scrolling in large libraries.
A live connected/disconnected dot on every row, with a deleted connection marked in red — a query whose connection is gone has Run greyed out and tells you why.

Export & Import

The whole export pipeline was measured and reworked.

Exports start immediately. A 146-collection export used to write nothing at all for its first 18 seconds.
Progress is honest. The screen used to show 0 B / 5.23 MB at 0% — document counts were being formatted as bytes — and then reach 100% while three collections were still running. It now counts the right thing and shows real bytes written and observed MB/s.
One big collection no longer holds up the run. On a measured 10.36 GB export, a single collection took 93% of the wall-clock with three of four workers sitting idle. Large collections are now split across threads.
Thread count is automatic, scaled to your machine instead of a flat four, and the badge reads "auto threads" rather than "0 threads".
Export traffic is compressed for non-local connections — dump data typically compresses 3–5× — and compression itself is about 2.5–3× faster for files 10–15% larger.
Restores are faster, writing in much larger batches and reading while inserting.
Re-export just the failures. "57 collections failed on the last run" now comes with a button that narrows the job to exactly those; re-running all 146 used to be the only option.
A failed job no longer claims progress — the fake "100 / 100 documents" is gone — and resume is no longer offered when there's nothing to resume from.
The export form scrolls, so the lower half is reachable.
Restore can select a dump folder. The picker only accepted files, which made restoring a BSON dump impossible.
A restore into a database that doesn't exist yet is checked up front — VisuaLeaf tells you while you're configuring the job whether your database user is even allowed to create it.
The duration estimate accounts for chunking, so a database with one dominant collection is no longer predicted at that collection's full duration no matter how many threads you give it.

Numbers You Can Trust

A recurring theme this release: several readouts were confidently wrong, and are now either correct or honest about not knowing.

"Not available" instead of a zero nobody could justify. Views, Sequences, Events, Packages, Triggers and Constraints folders now say when the engine can't be asked — this is not an empty list; nobody could look.
Active connections. The monitoring panel was showing the server's connection ceiling under a label reading current, so an idle server reported hundreds of connections that did not exist. It now shows the real number, "Not reported", or "Not available on this engine".
Replication lag never invents a number — you get a duration, "Unknown", or "Clock skew", each explained.
Live sync totals. A sampled stream now says "covers 12,043 of 8,300,000 events — roughly 1 in 689 shown". A 50,000/second job was previously reported off by three orders of magnitude.
Dead letter counts are the real total, not how many fit on the page.
Index analysis works on sharded clusters. A query that scanned every document on both shards previously produced no recommendation at all, and the index a shard actually used was reported as "No Index Used".
Explain results are real. A plan you ran yourself reported 0 examined, 0 returned and 100% efficiency on a plan that scanned 5,000 documents — and, worse, silently recommended the wrong index direction. It now reads 5,000 / 1,667 / 33%.
New index health badges — UNUSED and REDUNDANT, with hover reasons and the caveat that usage counters are per-server and reset on restart. They're advisory by design: a unique index with no reads is a caution, not a suggestion, because dropping it changes which writes are accepted.
Slow pages name their phase. Jumping to the last page now says "Counting documents" or "Loading documents", with a live timer, a Cancel that works, and a note that large collections can take a while to count. Impatient clicking no longer stacks a full scan each time, and if the server can't kill the operation the app says so rather than dropping it.
The web widget no longer reports "Schema saved successfully!" for a save that never happened.

Improvements

Scrolling through your data

Shared by the MongoDB collection view, SQL query and table results, aggregation results and the Redis key browser.

Rows no longer go blank during a fast scroll. Fling the list and you used to get an empty band where rows should be until it settled. Rows are now redrawn every frame, so the list stays populated the whole way down — only a scrollbar yanked across the track pauses at all, and only until it stops.
Scrolling is smoother, most noticeably on wide documents and while the query builder is open. Each visible row used to be rebuilt from scratch on every scroll movement; now only the row you're hovering and the row you've selected do that work.
Expanding or collapsing a large selection is immediate. With many rows selected this used to stall noticeably before anything moved, and so did jumping to a search result in a long document.

Connections & the sidebar

A SQL table row opens immediately. Its columns, indexes, foreign keys and constraints are fetched the first time you expand it, rather than as part of loading the tree around it.
PostgreSQL connections stopped dropping after about half an hour. A single slow health check used to close the pool and end your whole session; the routine trigger was the connection pool's own recycling. A genuinely unreachable server is still reported within about fifteen seconds.
"Reveal in Sidebar" on tab right-click, plus clickable breadcrumbs on eight screens that highlight the connection, database or collection in the tree.
A disconnected screen is actionable. It used to read "SQL connection e76d2829-… is not connected. Please connect first." with nothing to click. Now: a plug icon, a plain sentence, a Connect button — and it retries whatever failed once you're connected.
Advanced driver properties are editable. This setting existed, was applied by the driver, and no screen referenced it — the only way to set one was to edit stored data by hand, and the next Save wiped it.

Redis

Undo on every edit, with a visible Undo button on the toast, faithful down to per-field expiry and sorted-set scores — and deliberately withheld where undoing would damage data you never touched.
A New Key dialog, multi-select with bulk delete, rename with a collision check, and per-field TTL for hashes.
The ACL page now matches the standard user-management design, with stat tiles, status/commands/selectors columns and Allow all / Deny all.

Editors & the shell

SQL autocomplete offers the current statement's own columns. Typing a WHERE clause used to offer table names and not one column of the table being read.
Query history feeds autocomplete in the MongoDB query field, tagged history and showing "Last run · N runs · starred". Picking one stays undoable.
Run fires the statement you're actually on. With the cursor on a comment line nothing ran at all, and when two statements shared a line it always ran the first.
Large scripts paste instantly — 200 KB of SQL used to take 11.6 seconds.
Shell sessions no longer leak. Idle sessions were never being cleaned up, and enough of them made the shell unusable.
if (count) behaves correctly on an empty collection. Counts arrived in JavaScript as objects, which are truthy even at zero, so a script checking "did I find anything?" took the wrong branch. sleep() works, autocompletion no longer blocks on a slow cluster, and two errors logged on every shell open are gone.

Diagrams & schemas

Export a diagram as PNG, black-and-white PNG or SVG. The SVG is interactive when opened in a browser — hover a field to highlight its relations — and embeds its fonts so it opens anywhere.
Materialize lists every problem at once, catching blank table and column names with row numbers and nested paths before any statement is generated.

Compare

A "Simple" mode, now the default — pick source and target from a picker instead of the drag canvas. Visual mode gains click-to-link, and naming is optional until you save.
Compare stopped reporting differences that don't exist. Keys were compared as text while the server sorted them as data, so numeric keys desynchronised immediately and everything after the first numeric key was mis-reported.
"Repair" no longer reports success when it did nothing, and re-running a repair no longer duplicates documents.
When a sort exceeds the server's memory limit, Compare now tells you to create an index on the match keys instead of failing opaquely.

Charts & maps

Map charts load dramatically faster — map data is 89% smaller, taking about 41 MB off the download. Japan keeps all 1,158 prefecture parts. Asia and India were genuinely over-detailed and do lose some small islands at this resolution.

Elsewhere

A "What's new" panel after an update — on a genuine version increase, never on a fresh install, and it waits for a clear screen rather than stacking on another dialog.
A 14-day free trial at signup, replacing the anonymous 7-plus-7 arrangement. "Upgrade" is now "Activate License", so people who already bought one have somewhere to enter the key, and a machine that has already used its trial is offered Sign In rather than a promise the server will refuse.
The app is 70 MB smaller — 675 MB to 605 MB on macOS, with the installer down from 408 MB to 354 MB.
GridFS filename and metadata save together. They were separate operations that clobbered each other, so either order lost data. Errors now name the actual problem — duplicate name, invalid name, missing file — and the dialog stays open on failure.
Light-mode fixes — autofilled login fields were white-on-white, drag previews carried colours that broke theme switching, and the Redis connection dialog, the Materialize preview pane and the Import Script modal were all dark-only. Two further passes caught the rest: the Create Table screen (its form, tabs, SQL preview and error bar all rendered dark on a light page), the Delete Connection dialog, the right-click menus and environment colour picker in the connection sidebar, the failed-query panel in the SQL editor, the stored-procedures list, the Create/Drop Database dialogs, Table Info, and the row hovers and paging buttons across the SQL grid, Edit Row, Batch Update and foreign-key preview.
Long foreign-key error messages wrap instead of stretching into one unreadable line.

Fixes Worth Naming

Dropping a table could drop the wrong table. An unqualified drop resolved through the session's search path, so dropping reporting.orders silently and successfully dropped public.orders instead. This is the most serious fix in the release.
Materialising a diagram failed on columns that looked fine. Any nullable text, JSON, boolean, date or timestamp column produced a syntax error and rolled back the whole operation. Integer columns always worked, which is why it hid for so long.
Shell aggregations ignored the types you typed. An aggregate() run from the shell had every ISODate(...), ObjectId(...) and regular expression in its pipeline flattened to plain text before it reached the server — so {$gt: ISODate("2026-01-01")} compared text against a date field and came back with zero rows and no error, and a $not: /…/ was rejected outright. The shell now sends exactly what the aggregation builder sends, and the pipeline keeps its types through paging and through closing and reopening the workspace.
Saved aggregations quietly returned the wrong rows. A date in any stage other than $match was flattened to plain text, so the restored pipeline compared text against a date field — which MongoDB answers with wrong rows rather than an error. Browser caching masked it, so it only appeared when you opened the same saved workspace on another machine.
Opening one tab wiped every other tab's saved state. Opening Generate Mock Data or Redis Security made the entire workspace fail to save, and every open tab lost its state.
Imported JSON schemas lost every field name — every property read "New Entity", and saving collapsed them onto one entry.
Dialogs in the embedded schema widget opened behind the canvas. Import from Script and every other dialog appeared centred and looked perfectly normal, but no click reached them — the diagram was painted over the top. They also had no route back in: the Import from Script button vanished as soon as the table list had anything in it, which is every sample session and every session after your first import. Both fixed, and a closing dialog can no longer swallow a click on its way out.
Pasting the wrong JSON into Schema Import produced a table called "undefined". A file whose columns don't carry a table and a name — the usual result of exporting from a different tool — built one nameless phantom table and then crashed relationship detection. It now stops and tells you what shape it expected.
Renaming a diagram card broke its connector lines permanently, and pressing Escape during a rename silently kept the typed name anyway.
A column added minutes ago stayed invisible through any number of refreshes, for up to five minutes.
A 146-collection export reported 57 failures when none had failed. One GridFS bucket poisoned every collection processed after it; the files on disk were correct the whole time.
A dump that died mid-write left a truncated file behind — and a truncated dump is indistinguishable from a complete one, restoring without complaint and quietly missing its tail.
Copying between two SQL databases built the wrong column types. PostgreSQL's type names were being sent to MariaDB, HSQLDB and QuestDB — an outright failure on the first two, and on QuestDB accepted and then silently wrong.
Engine picker cards were unclickable — they were rebuilt mid-click, so the browser never registered it. They looked alive and did nothing.
Saving a connection could permanently break it — switching engines kept the previous engine's pinned driver, so a MySQL connection could be saved with a PostgreSQL driver that fails at connect time.
"Disconnect all 0 connections?" — with two SQL connections open and no MongoDB one, the confirmation said exactly that and then disconnected nothing.
A modal's backdrop covered the title bar, and because the bar was still clickable underneath, the Workspace Manager could stack duplicate copies of itself.
Redis database nodes always opened database 0, and Redis rows opened the MongoDB connection dialog.
A diagram offered you every schema's tables. Opening an ERD on one PostgreSQL or SQL Server schema listed the tables of every other schema in the database alongside it, so public.orders and audit.orders sat in the same picker with nothing to tell them apart. The list is now the schema you opened. Engines that have no schemas, and diagrams saved before this, are unchanged.
Two diagrams could overwrite each other, expanding one schema's Tables fold re-opened it on another's row, and Tables Info listed every schema's tables while refusing to open a second tab.
Deleting a rule in the sync wizard made the rule below it inherit the deleted one's filter.
Initial-sync progress bars never moved — the progress stream listened for the wrong signal for the entire life of the feature.
Dead-letter replay reported success without replaying anything.
Cancelling an aggregation now tells you truthfully whether it stopped.
Server errors are readable. They used to render as a single word — "IllegalArgumentException", "ResourceAccessDenied" — and streaming failures reported a bare HTTP error! status: 400 instead of the server's actual reason.
AI providers that never worked, now do. Gemini failed before a request was even sent, GPT-5.6 failed outright, and newer Claude models returned their reasoning text to the parser instead of the answer. All 36 models were tested against the live APIs.
Per-engine fixes: CrateDB showed empty columns and reported 0 rows for all 63 tables; QuestDB couldn't browse at all; PostgreSQL silently rewrote JSON-looking text written into a plain text column; SQLite emitted definitions it then rejected; Oracle returned no column statistics for tables VisuaLeaf itself created; MariaDB silently truncated long text at insert; DuckDB couldn't be seeded; ClickHouse failed exporting MongoDB into a JSON column.

Infrastructure

The legacy split NoSQL/SQL connection sidebars were removed; the unified list is the only path now.
A single engine catalogue is the source of truth for which engines are selectable, contract-tested across both the app and the server in each direction.
The frontend test suite was running 38 of its 490 tests; that's fixed, and roughly 4,000 lines of new tests were added. Backend unit tests grew from 1,505 to 2,546, and container-backed suites from 27 to 40. Test runners now fail when a pattern matches nothing, so a package that quietly stopped being covered can't pass as green.

Notes

Every saved ERD diagram is rewritten on first launch after upgrade. Nullability moves out of the type text into a real field. The visible consequence: SQL diagrams now generate NOT NULL on columns that previously produced none, which makes materialising match what the diagram's own DDL export was already showing you. MongoDB diagrams are unchanged. The migration is safe to repeat and retries on the next launch if it fails.
Startup now reads your saved diagrams to check for the old format. If you have many or very large diagrams, expect slightly longer startup on the first run.
SQLite foreign keys are now enforced. ON DELETE CASCADE and similar rules were previously inert and now fire, so a delete or a drop can empty a table you did not name. Nothing about your existing data is altered or checked on upgrade — but the next time you write, some things will be refused and some will do more than they used to.
If you already have sync jobs: stop any SQL change-capture job with "release source resources" before upgrading. An upgraded job re-anchors rather than resuming, and the old capture resources on your source server need releasing. Dead letters recorded before the upgrade can't be replayed and are marked as such.
Deploy MongoDB is temporarily hidden. The command-palette entry for provisioning a replica set is off in this build while it's finished. Managing clusters you already have is untouched.
Known issue: Explain on a shell aggregation shows an empty plan. Run an aggregate() in the shell, switch the results to Explain, and the plan describes no stages rather than the ones you ran. The results themselves are correct, and explaining the same pipeline from the aggregation builder is correct — only the shell's Explain tab is affected. A fix is queued.
Silent default changes. Export thread count is now automatic rather than a flat four; compression is lighter and faster, so dump files are 10–15% larger; network compression is on for non-local exports; and restores insert in much larger batches. All are performance-positive, but they change file sizes and your machine's CPU and network profile.