Skip to content

Verbinal for Linux 1.4.2

Choose a tag to compare

@github-actions github-actions released this 02 Sep 00:49
· 21 commits to main since this release

A release about being told the truth. An agent asking for something impossible
was answered "done"; the ADQL checker shipped last week had never once run,
because its schema fetch panicked the main thread on the way in; the About
window's Runtime Info named the app's own version as the Rust version and gave
no version at all for GTK. Underneath, three pieces of code that existed twice
now exist once — including a whole streaming download whose copy had quietly
missed out on cancellation.

The compiler is pinned, so the gates mean what they say

  • The README promised that cargo clippy --all-targets -- -D warnings is "the
    exact command CI runs, so a green local run means a green CI run". The command
    was exact; the compiler was not. CI took dtolnay/rust-toolchain@stable — the
    day's stable — and a developer had whatever stable they last updated to.
  • Rust 1.98 added clippy::chunks_exact_to_as_chunks, and three call sites that
    had been in the tree for months went red in CI while staying green on a 1.97
    desktop. No amount of care locally would have found it: a lint that does not
    exist on your machine cannot fire on your machine.
  • rust-toolchain.toml now pins the version, both workflows install that
    version, and a test fails if the three copies drift. The three sites use
    as_chunks::<4>(), and rust-version records the 1.88 floor the code needs.

What the app does, described as it actually is

  • The feature list was written when there were seven of them. It ran the
    Portal's own minutiae (Auto-Refresh, Recent Launches) alongside whole
    applications (FITS Viewer, Archive Search) as thirteen equal bullets, and left
    out Research, Workflows, the AI Guide, finding an image by package, figure
    export and the ADQL editor entirely. It is now written by area, the way the
    app presents itself on its Home page.
  • The AppStream description — what a software centre shows — gained the same
    areas. It had described two viewers and an agent, which was a third of the app.
  • Counts that came from one screenshot ("368 images", "17106 entries") are
    described by their scale instead, because the numbers change and the README
    does not.

The ADQL checker had never run

  • The schema fetch that feeds it was awaited on the GLib main context, where
    there is no tokio reactor, so it panicked the main thread the moment the
    Search page was built
    — "there is no reactor running". The schema therefore
    never arrived, cached() stayed empty, and the checker, which says nothing
    when it has nothing to check against, said nothing. A check that silently
    never runs is the worst way for one to fail: from the outside it is
    indistinguishable from a query with no problems.
  • The fetch now goes through the tokio runtime like every other request. The
    editor underlines the offending words, and Execute greys out, from a cold
    start — which is what the previous release said it did.
  • validate_adql_query and execute_adql_query were unaffected: they fetch the
    schema themselves, on the runtime, which is why the tool worked while the
    editor did not.

About points at the project, and says what it is running on

  • About and Help open verbinal.com, the project's own
    page, rather than canfar.net — that is the SERVICE this app talks to, and the
    two answer different questions. About also carries a "Report an Issue" link to
    the tracker and a support address, so a report arrives with a version beside it
    instead of "the latest one".
  • Runtime Info names the versions a bug report needs. It said "Rust
    {app version}" — the app's own version wearing the toolchain's label — and
    "GTK4 + libadwaita" with no version at all, so the one section meant to help
    someone report a bug named nothing that varies between the machines where a bug
    appears. It now reads the real GTK and libadwaita versions at run time.
  • The project's addresses live in one place with a test that the packaging, the
    metainfo and the README all name the same ones; nothing compiles those three,
    so a moved page would otherwise be found by a person landing on a 404.

One implementation of a download, and of a sky coordinate

No behaviour was meant to change here, but one did, for the better.

  • The Search page had its own private copy of the whole streaming download —
    191 lines, doc comments and all, forked from services::transfer and since
    drifted: the original grew cancellation support and the copy did not. Saving an
    observation to Research now runs the same code every other transfer does.
  • Four sky-coordinate formatters existed twice, in cube_axes and again in
    cube_export, whose copy was justified in a comment as being there "so the
    footer ranges match the live axis captions verbatim" — the one guarantee that
    copying them cannot give. They now live once, in helpers::sexagesimal beside
    their long-form siblings, with a test that no file grows a private copy again.
  • The two readers that decide what counts as a number now share one definition,
    so a tool that validates with one and applies with the other cannot disagree.

An agent can see what a dropdown offers, and a bad value is refused

  • rowsPerPageOptions reports the Rows/page menu — 25, 50, 100, 250, 500 —
    beside the size in force. Any whole number from 1 to 1000 is still accepted;
    the menu is the menu, not the limit.
  • Each column reports its own display units, so a caller picks one instead
    of guessing and reading the refusal. RA offers hms/degrees, Int. Time offers
    seconds through days, the spectral columns offer fourteen.
  • A value that is not a whole number is refused rather than ignored.
    {"rowsPerPage": "abc"} used to report success and change nothing, because
    the reader answered "absent" for both missing and unreadable. "42" is still
    accepted — agents send that routinely — but 12.5, null and "abc" are
    now refused, saying what was wanted and what arrived.

A hand-written query keeps the columns it selected

  • SELECT target_name, collection came back as collection alone — the
    target silently dropped — while SELECT target_name, type came back with
    both. Adding a recognised column to a query made the others disappear. The
    column-visibility preference is about the SEARCH FORM's own result shape, and
    applying it to an arbitrary query filtered out every column it had never
    heard of. A result that is not the form's shape now shows everything it
    returned.
  • set_search_results_view reports rowColumns. It answers without rows —
    a hundred of them on every column toggle is a lot of wire for a confirmation —
    and it used to drop the header list with them, so revealing a column and then
    checking the reply looked like nothing had happened.

validate_adql_query — check a query without spending one

  • The same check the editor and execute_adql_query run, offered on its own, so
    an agent composing a query can ask whether it is acceptable instead of finding
    out by running it. It returns each problem with the text it objects to and,
    where there is one obvious answer, what to write instead. It does not touch
    the ADQL editor: checking a draft should not replace what someone has open.

An ADQL query is checked against the service's own schema before it is sent

  • The mistake that prompted it: FROM caom2.Observation JOIN caom2.Plane ON Plane.obsID=Observation.obsID is refused by CADC with "Column [obsID] is
    ambiguous", because a bare table name is only a valid qualifier while the
    column it names belongs to one of the joined tables. Writing AS p or
    caom2.Plane.obsID both work.
  • The offending words are underlined in the editor, the reason and the fix are
    shown beside the title, and Execute is greyed until the query is one the
    service would accept. The same check runs on execute_adql_query, so an
    agent's query is refused with the reason instead of spending a round trip.
  • It only reports what it is sure of. A subquery, a function, a table the
    schema has not been fetched for — each is left alone, because a false positive
    here disables Execute on a query that would have worked.

Several rows at once, and a metadata sheet you can read

  • Multiple selection. Click picks one row, Ctrl-click adds or removes one,
    Shift-click takes the range — and neither modifier opens the dialog, because
    adding a fourth row to a comparison should not put a window over the three
    being read. selectRow takes one index, an array of them, or null, and
    get_search_results reports selectedRows.
  • The row dialog's metadata is in two columns, with one heading above both
    so they start at the same height. A row has 41 columns and the dialog shows
    every non-empty one, which was a list to scroll rather than a sheet to read.

A results row can be highlighted, and its dialog opened, from MCP

  • selectRow highlights one row of the filtered results and pages to it, so
    "this one" means something to the person looking at the window. Clicking a row
    highlights it too, and get_search_results reports selectedRow.
  • show_search_row_detail opens the detail dialog for the highlighted row —
    every column of it, the same window a click gives.
  • The Rows/page dropdown follows the model. Setting the page size over MCP
    changed the model and not the control, so it read "Rows/page: 100" above a bar
    counting "31-40 of 60". The size is set in one place now, and that place moves
    the dropdown.

A stack buffer overflow in the FITS error path

  • Opening a FITS file that produced a long cfitsio error crashed the app.
    ffgmsg writes up to 81 bytes into the buffer it is handed, and both call
    sites gave it a 31-byte stack array — so any message longer than thirty
    characters wrote up to fifty bytes past the end of it. "failed to find or open
    the following file: (ffopen)" is one, which is why opening a path that did not
    exist ended in double free or corruption (out).
  • Two cfitsio decodes at once read each other's errors. cfitsio keeps its
    messages in a process-global stack and the cube loader decodes on a worker
    thread, so opening four cubes in a row reported the missing file's message for
    the malformed one and vice versa. One lock now lets one caller in at a time.
  • A failure left messages behind for the next one to find. cfitsio queues
    several per failure and only one was read, so opening a text file left cards of
    it on the stack and the next error reported them: Cannot open FITS file: [package] name = "verbinal". The stack is cleared when the lock is taken.
  • open_cube reports the load, not the request. It answered opened: true
    the moment the decode was handed to a worker, so a file that was not a cube was
    reported as open while a toast said otherwise. The same bug open_fits_file
    had, and the same fix.

open_cube takes an observation id, like open_fits_file

  • open_fits_file accepted a path OR the id of a downloaded observation;
    open_cube took a path and nothing else. So an agent could open a download as
    an image but had to resolve the id itself to open the same file as a cube —
    and the observation detail page offers "Open in Cube Viewer" to a person. Both
    now go through one resolver, so "open this thing" means the same in either
    viewer, down to the two failure messages.

View, Save and More are the first three columns

  • The three things you can DO to a search result were the LAST three cells in
    the row, past a dozen data columns — 41 with every column shown — so they were
    off the right-hand edge of the table and only reachable by scrolling there.
    They are first now, with their headings, which is where a table puts what a
    row is for.

Two things in the results table an agent could not reach

  • show_observation_detail opens one observation's CAOM2 detail page in the
    window, the way a results row's Details button does. Every other control in
    that table already had a tool, and each row's three buttons had one for the
    DATA behind them — so an agent could read an observation's metadata but not
    put it in front of the person it was explaining it to.
  • get_search_results takes allColumns. It returned the dozen columns the
    grid is showing; a row has 41. The only way to see the rest was to change the
    grid's column visibility, which is a change the person watching would see.
    This is the same data the row-detail dialog shows when a row is clicked.

Steering the results table is about three times faster

  • Every cell in the results grid stored its own tooltip, plus three action
    buttons a row — roughly 1,800 of them on a hundred-row page, rebuilt on every
    column toggle, sort and page turn. set_tooltip_text costs about 1.2 ms a
    widget, which was most of the time each of those took. The grid answers for
    its own cells through one handler now: hiding a column went from 0.90 s to
    0.35 s, and the main thread is blocked for a third of what it was. The full
    value of an elided cell is still on hover.

Two ways the results tools made an agent guess

  • A column key is matched whatever case it is written in. The keys are
    cleaned lower-case names, but an agent reads "Filter" and "Instrument" off the
    heading strip, and being refused for the case taught it nothing it could not
    have guessed. The canonical key is what gets stored, so a filter written as
    TargetName matches the same rows as targetname instead of matching none.
  • A rejected display unit names the units that column takes. It used to say
    only that the unit was wrong, so deg, then sexagesimal, then giving up was
    three round trips to learn something the app already knew. It now reads:
    "deg" is not a display unit for column "ra(j20000)"; it takes ["hms", "degrees"] (or "" to reset).
  • get_search_results now names its pagination fields in its own description —
    currentPage (0-based), totalPages, rowsPerPage, pageStatus — because
    looking for page and pageCount and finding neither reads as a bug.

Execute in the ADQL Editor looked like it did nothing

  • The spinner and the status line were in the Search Form's action bar, and
    the Search Form is the one tab you are not on when it matters. Pressing
    Execute in the ADQL Editor set "Searching…" and started a spinner on a tab you
    could not see, then sat silent for however long CADC took — indistinguishable
    from a button that does nothing. They are in the page header now, beside the
    title, visible from all three tabs.
  • Both buttons that start a query grey out while one is running, so a second
    press cannot queue a second query against a service that answers in tens of
    seconds.
  • A failed query's message is now visible from whichever tab you ran it on.

The agent's arrival and departure, heard and seen

  • Two short sounds, one when an agent starts calling tools and a different
    one when it goes quiet — rising for a start, falling for a finish, about a
    third of a second each. On by default, with a switch in Preferences under
    Appearance. Nothing else in the application makes a sound.
  • The three dots travel while an agent is working and sit still when it is
    not, so a glance answers the question without reading the words. They follow
    the desktop's animation setting, and the frame clock rather than a timer, so
    they cost nothing while idle.

The agent says what it is doing, and a reset stopped taking fourteen seconds

  • reset_search_form timed out. It took about fourteen seconds and grew
    from there, because clearing the form tore down and rebuilt every row in all
    seven Additional Constraints columns. The values in those columns are
    computed once, when the data train loads, and never change — only which are
    available and which are ticked. Updated in place, the same call takes 0.0 to
    0.2 seconds and stays there.
  • That also fixes the jump: with nothing torn down, a click no longer sends
    every column back to its first row.
  • The agent indicator is always on screen, beside the service health, as
    agent idle or agent working… with the same robot icon the AI Guide uses.
    It used to appear only while an agent was working, which is indistinguishable
    from its not existing: nothing told you it was a thing to look at, so a tool
    call that did nothing visible looked like nothing had happened.
  • The Search panel's collapse threshold had 17 px of margin, and the app
    logged AdwOverlaySplitView exceeds AdwBreakpointBin width: requested 933 px, 920 available when a resize landed in the gap. It has about 70 now, and the
    probe fails below 40.

Additional Constraints jerked sideways, and Home kept asking a signed-in user to sign in

  • Clicking a facet checkbox scrolled its column to the right. A value like
    Infrared|Optical|UV|EUV|X-ray|Gamma-ray gave a row a 257 px MINIMUM in a
    100 px column — CheckButton::with_label has no label to ellipsize, so the
    row could not shrink. The column scrolled horizontally, and clicking a
    checkbox focused it, so GTK scrolled sideways to reveal the rest of the row.
    The rows ellipsize now, with the full value on a tooltip, and the columns
    scroll vertically only.
  • And every column jumped back to its first row on each click, because
    toggling one facet rebuilds all seven. The scroll positions are kept across
    the rebuild.
  • "Log in with your CADC credentials to get started" stayed on the landing
    page after signing in.
    It was a plain label that nothing told about the
    sign-in state, sitting under the tiles while the sidebar above it showed the
    account name. It is driven by the same lockers that unlock the tiles now.

Five things that were cut off, blank, or silently refused

  • The window drew 267 px past its own bottom edge. AdwViewStack is
    homogeneous by default, so every page was allocated the size of the tallest
    one: content 945 px tall inside a 678 px window. The visible results were on
    pages that had nothing to do with the tall one — the Search form's Search
    button was off the bottom at any window under about 1000 logical px, the last
    navigation rows were unreachable, and the CANFAR Images card ran past the
    frame. Pages size themselves now.
  • A tool description containing <user> rendered as nothing. Rows treat
    their title and subtitle as Pango markup, so vos:<user>/workflows/ was an
    unclosed element: GTK logged a warning per row per rebuild and drew no text.
    Every row that shows a name, a path, a URL or an error — thirteen of them, in
    six files — says it is text now, and so does the Search page's error banner,
    which shows whatever a TAP service sent back.
  • The AI Guide lost its icon in the sidebar and on the home page. The icon
    search path for a source tree had been put behind debug_assertions, which
    silently dropped it from cargo build --release. It is derived from the
    running executable now, so it works in either profile and embeds nothing in a
    shipped binary.
  • The AI Guide's tiles were one per row at a quarter-screen window while
    the home page's were three. Both build their grid from one place now, and a
    tile states a width so the grid stays a grid.
  • navigate_to("portal") answered "navigated" and showed Home. The alias
    outlived the split that gave the Portal a page of its own.

Panels keep their width, and the account is where you look first

  • The Search page was clipping its own right panel. At the window the app
    opens at it needed 844 px and had 797, so GTK drew Recent Searches 47 px past
    the window edge: every row's edit and delete buttons were outside the window,
    "Clear All" was cut mid-word, and a saved coordinate wrapped mid-token across
    three lines. Widen the window and the same panel took half of every extra
    pixel instead — 175 px at 1200 and 618 at 2000 — because one label inside it
    set hexpand, which GTK propagates upward. It is a panel now: it states its
    width, holds it, and steps aside into an overlay rather than off the edge.
  • Both viewers' controls were absent at the window the app opens at.
    Colormap, stretch, cut levels, the channel scrubber and the marks panel were
    reachable only through a toggle, and then only as an overlay over the picture.
    Two causes: a collapse threshold measured for a different machine, and a
    picture that claimed an 800 px minimum it did not need. They dock now, and the
    picture takes the squeeze.
  • The Research and Workflows lists were truncating the names they exist to
    show — 110.9 …, Archival imaging reconnaissance (CFHT Mega… — beside a
    pane displaying an empty "select something" placeholder. The list keeps its
    width; the pane gives it up.
  • The account moved to the top of the sidebar, under the header, with
    service health and agent activity beside it. It was the last thing in the
    sidebar and the first thing anyone checks. The display name is no longer
    printed twice.

Marks can be styled, and they survive being exported

  • Colour, size, weight and thickness for a mark, from a Style row in the
    Marks section that both viewers already mount. The controls act on the
    selected mark when there is one, and on what the next mark will look like
    otherwise. The default is remembered, read when a mark is CREATED and copied
    into it — never at draw time, so changing it leaves every mark already drawn
    alone. An agent's marks keep their own green: the setting means "what I
    draw".
  • Marks kept their screen size in an export. At 4x the picture was
    re-rendered at four times the resolution and the plate's own title, caption
    and colorbar scaled with it, while a 2px ring stayed 2px and a 12px label
    stayed a 15x10px smudge — so the annotations were the one thing in the figure
    that shrank, and they became unreadable at exactly the resolution someone
    chose for publication. Stroke, label, leader and rule now follow the
    rendering, in both directions: an agent's downscaled capture thins them to
    match too.
  • The two inks are written from their 8-bit channels now. A colour is stored,
    shown and sent as #rrggbb, so a constant with more precision than that could
    not come back from its own storage. Same colour on screen, to the byte.

Install

sudo apt install ./verbinal_1.4.2-1_amd64.deb

Full changelog: CHANGELOG.md · Project page: verbinal.com