The profile page reloaded its route after every write and only noticed
edits from other devices on navigation. Now writes and the node's
updates refetch the actor in place, like the rest of the cache.
Issues and patches written without announcing them, such as with
`rad issue comment --no-announce` or by another instance of the app,
never reached the open views. The cache also changes with every fetch and
write the app already heard of, and doesn't say which repo changed, so
right after those it refreshes once things are quiet instead of with each
one. The watchers now also notice a database that appears or comes back
after an error, and one locked database no longer holds up the others.
An update that arrived while a route was still loading was lost, since the
loader's result then counted as fresh, so the events now invalidate through
the shared helper that marks such fetches stale. A repo arriving or renamed
without the update naming its refs left the sidebar list as it was, and
updates that changed nothing still dropped the hover caches.
A test now checks the frontend's ref update type against the generated
one.
The repo list had its own TTL cache, a counter bumped by seeding and a
listener of its own, and release counts were fetched separately by the
sidebar and the releases page. Now they're queries like the rest, and
seeding invalidates the list like any other write. The head a loader
resolved is marked through `markLoading` too, so it needs no key of its
own.
A node that ends every subscription right away made the frontend refetch
everything every two seconds. Updates naming more than 256 refs, such as
a first clone, are sent as repo-wide instead of in one huge event. The
event's type is now generated from Rust.
Seeding or unseeding with the `rad` CLI or another instance of the app
writes the policies database without a node event, so the backend now
watches it like the notifications database.
When the branch moves on, its new commits are added at the top of the
list, without moving the rows in view, instead of the list going stale
until the next visit. Rewritten history offers to reload the list.
Hover cards, references and mention candidates keep their own short-lived
caches, which went on showing an issue's or patch's old state for up to a
minute after the views around them had updated.
Releases were the one COB with keys of their own that nothing listened
on: the release list, a release and the sidebar count now refresh when a
release changes, and the user's own release writes refresh them too.
Publishing a review was the only patch write that didn't announce, so
other instances of the app on the same node never learned of it. A
review's summary now also stays as it is while someone else edits it,
showing that a newer one is available, as an issue's description does.
Changes to a board, or to its issues and patches, made by other people,
the `rad` CLI or another instance of the app now show without leaving
the board. The reload waits while the user is moving cards, so they don't
jump back before their moves are saved.
The backend now tells the frontend whenever the notifications database
changes, which covers notifications the node writes as it fetches as well
as clears by another instance of the app or the `rad` CLI, which have no
node event. The inbox reloads in place, keeping the rows in view where
they are.
Reviews and writes with announcing off or the node stopped never reach the
node's events, so each write command now invalidates the data it changes,
also when it fails partway. Views that pin data join that refetch instead
of starting another.
The node announces the user's own writes, and those of the `rad` CLI,
without saying which refs changed, so each one refetched the whole repo,
including a scan of every CI job. Comparing the announced signed refs
with the previous ones names them. Releases and boards get keys of their
own instead of falling back to the whole repo.
Every status chip of a repository shares one list of its jobs, which
refreshes when a job changes, at most every few seconds, since listing
them scans every job of the repository.
The backend forwards the node's ref updates, and the cache refetches what
they affect while it is shown. Issues, patches, their lists, the repo's
counts and the notification count update in place, and without the node's
events they refetch on window focus. An issue's description stays as it is
until the user asks for the latest.
Core holds the keys of the data both apps read and maps a node's ref
updates to the keys they affect. The query cache wraps TanStack Query for
runes, as decided in ADRs 4 and 5.
Right-clicking a revision in the Changes tab picker offers the same
comparisons as the activity tab's compare menu, so you don't have to
leave the Changes tab to compare revisions.
The sidebar numbers flashed on every ⌘Tab and showed up in ⌘⇧5
screenshots, then stuck until ⌘ was pressed again because the
screenshot overlay swallows the keyups. Now they wait for ⌘ to be
held on its own for a moment and hide on any sign it was let go.
Drafts are kept in local storage and publish only their bodies, so a
file attached while editing one never reached the COB and peers saw a
broken link. The draft composer already disallowed attaching; editing
didn't.
The summary editor allowed attaching files but never sent them, so the
link ended up in the summary while the file never reached the COB.
Verdict changes and task toggles also sent no embeds, which would drop
them again once a summary has some.
- Add a register phase after tag, like httpd's build/register
- Record the DMG, deb and AppImage in the release of the tag, with
their files.radicle.dev URLs and sha256
- Move the Zulip announcement into its own announce phase
- Document how to install rad-artifact in README.md
- Sign the release tag with the Radicle key, like the httpd tag
- Check that the signing key matches the Radicle identity first
- Document the Git signing setup in README.md
- Write "desktop: Release <version>" as the release commit subject and
the tag message, like httpd
- Drop the v before the version everywhere else too: changelog
headings, the releases/ folders and the apt branch
- Still find older release commits, which lack the prefix and have a v
Heartwood doesn't cache custom COBs, so every board read replayed the
board's whole history, about 2.5 s for 3,000 ops. Evaluated boards are
now kept in `boards.db` next to radicle-artifact's cache, keyed by the
board's ref tips, so a read with nothing new takes a few milliseconds and
an op fetched from any peer still triggers a fresh evaluation.
Every issue and patch of a repository shows on its board, in a column
derived from its state until someone moves it. Cards move by drag and
drop or from their menu, closing columns close and reopen issues for
those allowed to, and a drop that isn't allowed says why. Changes wait
2.5 seconds and are written as one op. Patches link to issues with a
keyword and a full reference. Boards stay hidden until turned on under
Settings → Labs.
Co-authored-by: Rūdolfs Ošiņš <rudolfs@osins.org>
The port lists, creates and renames boards, edits their columns, and
applies a batch of card moves and removals as one op, so a burst of
changes costs one update of the signed refs. Changes the board would
ignore are refused before writing and reported back, and boards are only
written on the test network or in private repositories for now.
Co-authored-by: Rūdolfs Ošiņš <rudolfs@osins.org>
A board arranges a repository's issues and patches in columns and stores
only where each card sits, as `works.monadic.board` in its own crate so
other clients can reuse it. Moves follow the issue and patch access
rules, ops that fail them are ignored rather than rejected, and positions
are fractional keys so concurrent moves converge. ADR 0005 records the
decisions.
Co-authored-by: Rūdolfs Ošiņš <rudolfs@osins.org>
Board cards show assignees the way the repository header shows
delegates, overlapping and fanning out on hover, so the stack moves
into its own component.
Views can hold back writes to batch them, which would be lost if the
window closed in the meantime. The first close is held until registered
views have flushed, writing locally without announcing, with a 5 second
fallback. On macOS, Quit goes through the same path instead of
terminating the app directly.
`Checkbox` reports changes, `SegmentedSwitch` options can show an icon and
a label together, `TextInput` takes a `maxlength`, and a new `Select` is a
styled dropdown that also works inside a popover, where a nested `Popover`
would close its parent.
Co-authored-by: Brandon Oxendine <brandon.oxendine@gmail.com>