Skip to content

Runic SDK 0.21.0

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 17 Nov 00:23
8493a7b

Runic SDK 0.21.0

Install matching 0.21.0 packages from NuGet and npm;
Runic.Application.Views.CsWebUi is 0.21.0-preview.1.
Tested with Runic Translations 0.13.0 and Runic Command Line 0.13.0.

0.21.0 brings your IDE's JavaScript debugger to the page on every operating
system. On Linux, dotnet runic dev serves the Window's WebKitGTK page to
JavaScript debuggers through a Chrome DevTools Protocol adapter, so VS Code
stops at breakpoints in the frontend's sources as it does with WebView2 on
Windows (#1029, preview). dotnet runic dev --browser serves the Window to
Chrome or Edge instead, so the page's JavaScript can be debugged in the IDE on
macOS too (#1053).

The browser's own developer tools learn about Runic: React DevTools labels the
hooks' values and Vue DevTools gets a Runic Views inspector (#1041), the
console shows View clients and states readably (#1042), WebView2 windows open
their DevTools window from code and load DevTools extensions in Development
(#1056), and dotnet-runic ships a Runic panel for the developer tools,
which dotnet runic dev loads into the Window's WebView2 on Windows and which
Chrome and Edge load unpacked (#1060). All of it is development-only.

Hosted application windows (experimental) give a GTK 4 window back to the user
after a menu-bar choice (#1045) and treat a Linux guest that holds capabilities
as elevated (#1047). The development endpoints are hardened: the Vite plugin's
/__runic/* endpoints and HMR events answer only admitted clients (#1052), and
WebView2's debugging endpoint opens only in Development (#1071), as WebKit's
remote inspector did in 0.20.

0.21.0 also carries the API review before 1.0: .NET members added since 0.12
are renamed so that one feature uses one word, trusted component mode moves to
the npm packages' ./experimental entries, two development formats take dotted
names, and internal MSBuild names start with _Runic. The 0.21 release train is
Runic Translations 0.13.0, runic-sdk 0.21.0 and the Runic editor extensions
0.21.0; Runic Command Line stays at 0.13.0. These changes need edits in an
application: Upgrading from 0.20 lists them, and the
migration guide
collects them.

Highlights

Upgrading from 0.20

Update every Runic NuGet and npm package to 0.21.0 together and rebuild, so that
the generated clients and Bridges are regenerated. The Views protocol and its
features are unchanged, so a 0.20 page and a 0.21 host still connect.

Most applications change only a few calls. Rename the .NET members of the
API review that the application uses; the compiler lists
each one, and saved navigation paths and every wire format load unchanged. A
hosted guest in trusted component mode imports it from ./experimental
(Experimental features). A tool or a
test that reads Runic's development endpoints from another machine, or reads
sources.json, checks the behaviour changes
and the format IDs. Runic's VS Code extension reads the
development source map's new format ID from the Runic editor extensions 0.21.0
on; update it with the SDK.

  • Runic Translations 0.13 (the 0.21 train candidate).
    Runic.Application.Views.Translations requires Runic Translations
    [0.13.0, 0.14.0), so an application that uses it moves every Translations
    package, NuGet and npm, to 0.13.0. The template pins Translations 0.13.0 three
    ways: the dotnet-runic-translations tool, Runic.Translations and
    .Build, and @runic-artifex/vite-plugin-runic-translations. Translations
    0.13 renames TranslationContextBuilder.Add to AddCatalog: replace .Add(
    with .AddCatalog( where a TranslationContext.CreateBuilder() chain
    registers a catalog, as the template's WorkspaceServices.cs now does. The
    in-page editing API reads only RUNIC_DEV_ALLOW, which vite-plugin-runic
    reads too; RUNIC_TRANSLATIONS_EDIT_ALLOW is ignored. Runic Command Line
    stays at 0.13. See the
    Translations 0.13.0 notes.

Breaking changes

  • .NET API names from the 0.21 API review. Members added since 0.12 are
    renamed so that one feature uses one word. Rename the calls; nothing else
    changes, and the wire formats stay: NavigationPath.ToJson and
    NavigationSelectionPath.ToJson still write a selection's index as
    "selected" (format version 1), so saved paths load unchanged.

    Package 0.20 0.21
    Runic.Desktop IDesktopWindowBoundsHost IDesktopBoundsWindowHost
    Runic.Desktop IDesktopWindowShowStateHost IDesktopShowStateWindowHost
    Runic.Desktop DesktopWindowCapabilities.WindowPlacement DesktopWindowCapabilities.Placement (same value)
    Runic.Desktop DesktopHost.NoteRecentDocumentAsync(path) DesktopHost.AddRecentDocumentAsync(path)
    Runic.Navigation NavigationSelectionPath.Selected NavigationSelectionPath.SelectedIndex
    Runic.Application.Testing RunicRegionCollectionState.Selected RunicRegionCollectionState.SelectedIndex
    Runic.Application.Views RunicWindowOptions.MaximumWindowUploadBytes, WindowContentSessionOptions.MaximumWindowUploadBytes MaximumPendingUploadBytes
    Runic.Application.Views RunicWindowsChangedEventArgs.Opened (bool) and its bool opened constructor parameter RunicWindowsChangedEventArgs.Change, an open enum RunicWindowsChange (Opened, Closed): args.Opened becomes args.Change == RunicWindowsChange.Opened
    Runic.Application.Views RunicUpload.SaveAsAsync(path, overwrite) RunicUpload.SaveToFileAsync(path, overwrite)
    Runic.Application.Testing RunicServeOnlyTestPlatform.EnqueueOpenFile, EnqueueSaveFile, EnqueueOpenDirectory, EnqueueFileDialogDismissed, EnqueueFileDialogUnavailable, EnqueueFileDialogFailed platform.FileDialogs.EnqueueOpen, EnqueueSave, EnqueueOpenDirectory, EnqueueDismissed, EnqueueUnavailable, EnqueueFailed
    Runic.Application.Testing RunicServeOnlyTestPlatform.EnqueueMessageBoxAnswer platform.MessageBoxes.EnqueueAnswer
    Runic.Application.Testing RunicServeOnlyTestPlatform.EnqueueContextMenuChoice, EnqueueContextMenuDismissed platform.ContextMenus.EnqueueChoice, EnqueueDismissed
    Runic.Application.Testing RunicServeOnlyTestPlatform.SetClipboard, SetClipboardText platform.Clipboard.SetContent, SetText

    The serve-only fakes now have the names of RunicTestPlatform's, so a test
    moves between the in-process host and serve-only unchanged. The host-wide
    default of the pending-upload limit is new: MaximumPendingUploadBytes on
    RunicDesktopHostOptions, RunicCsWebUiHostOptions and
    RunicWindowTestHostOptions, beside MaximumUploadBytes. Only a custom
    Runic Desktop window host implements the two renamed interfaces.

  • Two development file formats take dotted names, like every other Runic
    format identifier (runic.views.fields/2, runic.application.tool.dev-session/1):
    the Bridge generator's development source map (obj/…/runic-bridge/sources.json,
    which /__runic/sources serves and the session file's sourceMap names) is
    runic.views.bridge-sources/1 instead of runic-bridge-sources/1, and the
    handler analysis that /__runic/handlers answers (RunicHandlerAnalysis.format
    of @runic-artifex/vite-plugin-runic) is runic.vite.handlers/1 instead of
    runic-handlers/1. The content is unchanged. @runic-artifex/vite-plugin-runic
    still reads a map with the old name through 0.21 and serves it with the new
    one; a tool of its own that reads sources.json or /__runic/sources accepts
    the new name.

  • Internal MSBuild names start with _Runic. Twelve names that the packages
    use internally, but that looked like settings, now have the prefix of the other
    internal names: the targets _RunicDesktopValidateServer,
    _RunicDesktopValidateNativeServer, _RunicDesktopResolveNativeServer,
    _RunicDesktopLinkNativeServer, _RunicDesktopRemoveLinkedNativeServer,
    _RunicDesktopRequireRepositoryNativeServer,
    _RunicNativeServerRequireStaticLibrary and
    _RunicAssetsVerifyEmbeddedArchive, and the properties
    _RunicDesktopKestrelReferenced, _RunicDesktopNativeServerReferenced,
    _RunicNativeServerArtifacts and _RunicNativeServerRuntime (each formerly
    without the leading underscore). MSBuild properties and items
    now says that the targets of the Runic packages are not settings, apart from
    the three documented extension points RunicViewsGenerateBridge,
    RunicViewsBuildFrontend and RunicViewsCopyFrontend: a project that ran a
    target of its own with BeforeTargets or AfterTargets on one of the renamed
    targets hooks it onto an MSBuild target instead. No documented setting
    changed, and Runic.Desktop still reads the server packages' markers of 0.20
    through 0.21.

Behaviour and output changes

  • A Linux guest that holds capabilities runs elevated (hosted applications,
    experimental, RUNICDESK103). On Linux a guest that holds capabilities
    without running as root, a non-empty effective or
    permitted set (CapEff, CapPrm in /proc/self/status, such as from
    setcap or ambient capabilities), now runs elevated. It refuses hosted mode
    with guest-elevated, and with both opt-ins with
    guest-elevated-host-not-elevated, since the elevated pair needs a root
    parent. In a root elevated pair, the parent's capability sets must now hold
    every capability the guest holds
    (#868,
    #1047).

  • vite-plugin-runic's development endpoints admit fewer clients.
    In @runic-artifex/vite-plugin-runic, /__runic/state and
    /__runic/diagnostics now answer only loopback and the hosts and networks of runic({ allow }) /
    RUNIC_DEV_ALLOW, and /__runic/state refuses pages of another origin.
    Runic's HMR events are ignored from other clients, and the development state
    is sent only to admitted clients. With server.allowedHosts: true, Runic's
    endpoints and HMR connections check Host themselves (IP addresses,
    localhost, allow-listed names). On Linux, open-in-editor accepts a loopback
    client only when it belongs to the user running the dev server; macOS and
    Windows log that they cannot tell local users apart. A tool that read
    /__runic/state from another machine needs that machine in the allow list.

  • Kept View clients stay on their own Bridge. A client that a framework
    binding keeps for its keepAlive period is taken over only while its instance uses the Bridge it connected over. After a new
    __runicBridge (a new mock Bridge, or a page runtime replaced at runtime) the
    next binding connects to the new Bridge and the kept client is released;
    installMockBridge releases it at once
    (@runic-artifex/views README, "Client lifetime";
    #1058).

  • WebView2's debugging endpoint opens only in Development on Windows
    (#1071). WebView2
    opened a DevTools Protocol endpoint whenever
    WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS held --remote-debugging-port, also
    with developer tools off, so a release could be scripted through it. Now,
    unless DOTNET_ENVIRONMENT (or else ASPNETCORE_ENVIRONMENT) is
    Development, the WebView2 host removes the variable before it creates its
    WebView2 environment, also when DevTools is true. Its other switches no
    longer apply outside Development either, and processes the application starts
    after that no longer inherit it. Arguments the application passes in
    DesktopWindowOptions.BrowserArguments are not changed. To debug a build
    this way, run it with DOTNET_ENVIRONMENT=Development.

Experimental features and how to opt in

Nothing changes for an application that does not use them. Each .NET family is
a compile error until the project suppresses its ID
(experimental APIs),
and an npm API is exported only from its package's ./experimental entry.
Hosted applications (RUNICDESK103), the side panel (RUNICDESK104) and the
close drain (RUNICDESK105) stay experimental in 0.21, with these changes from
the API review:

  • Hosted applications, side panel and close drain: API review changes
    (RUNICDESK103, RUNICDESK104, RUNICDESK105). The host protocol's wire
    tokens, such as the dialog kinds folder and folder-multiple and the
    region-detach reasons, stay unchanged.

    ID 0.20 0.21
    RUNICDESK103 RunicHostedDialogKind.OpenFolder, OpenFolders; RunicTestDialogKind.OpenFolder, OpenFolders OpenDirectory, OpenDirectories, as IFileDialogs names them
    RUNICDESK103 RunicHostedWindow.Presentation RunicHostedWindow.DesktopWindow
    RUNICDESK103 RunicHostedRegion.DetachAsync, MoveToAsync return Task; SetAppearanceAsync returns Task<bool> ValueTask and ValueTask<bool>, as RequestCloseAsync. A caller that stores the task calls .AsTask()
    RUNICDESK103 RunicHostedRegionEventArgs.Reason is a string ("removed", "reload", "crashed", "host", "closed") An open enum RunicHostedRegionDetachReason (Removed, Reload, Crashed, Host, Closed)
    RUNICDESK103 RunicTestDialogRequest.Kind (the wire kind, a string) beside DialogKind Kind is the RunicTestDialogKind; DialogKind is removed
    RUNICDESK103 RunicTestPresentationRequest.Kind is the wire kind, a string ("set-full-screen") An open enum RunicTestPresentationKind (SetFullScreen)
    RUNICDESK104 No DesktopSidePanelRefusal.Closed; a window that closed while OpenSidePanelAsync ran threw ObjectDisposedException DesktopSidePanelRefusal.Closed, as RunicSidePanelRefusal.Closed: OpenSidePanelAsync, MoveToEdgeAsync and SetWidthAsync refuse with it when the window or the panel closes while they run. A window or panel closed before the call still throws ObjectDisposedException
    RUNICDESK105 RunicCloseDrain.KeepsWindow RunicCloseDrain.KeepWindow
  • Trusted component mode moved to ./experimental (RUNICDESK103). Its npm
    side was the stable-looking @runic-artifex/views/component entry and the
    component option of runic(), although the mode is experimental. Before 1.0
    an experimental npm API is exported only from ./experimental, so 0.21 removes
    the ./component entry without a deprecated alias:

    • Import defineRunicComponent, connectComponentBridge and the
      RunicComponent* types from @runic-artifex/views/experimental instead of
      @runic-artifex/views/component.
    • In vite.config.ts, import runic from
      @runic-artifex/vite-plugin-runic/experimental to use
      runic({ component: { entry, name } }); it takes the root entry's options
      too. The root entry's runic now throws for component, and no longer
      exports RunicComponentOptions, which the experimental entry exports with
      RunicExperimentalViteOptions.

JavaScript debuggers attach to the Window on Linux (#1029, preview)

On Linux, dotnet runic dev serves the Window's WebKitGTK page to JavaScript
debuggers on port 9222, as WebView2 does on Windows, through a Chrome DevTools
Protocol adapter for WebKit's remote inspector. VS Code's JavaScript debugger
attaches with the runic-app template's Attach to the page (JavaScript)
configuration, now one for Windows and Linux: breakpoints in the frontend's
sources through the development server's source maps, stepping, conditions,
logpoints, exceptions, the console and the page's variables, also after a
reload, an HMR update or a Window restart under dotnet watch, and in code that
runs while the page loads, as with Chromium.
Window + WebKitGTK (Linux) starts the Window under the .NET debugger with
dotnet runic dev --no-window and attaches it too. GTK 3 (WebKitGTK 4.1) and
GTK 4 (WebKitGTK 6.0), X11 and Wayland.
When another local client, such as GNOME Web's inspector:// page, takes
WebKit's inspector during a session, the debugger learns that its page detached,
as from Chrome when another DevTools takes over, dev names the cause, and
attaching again continues; the Window keeps running.

The endpoint listens on loopback only, refuses requests with an Origin or a
Host that is not an IP address or localhost, closes connections of other
local users, and runs only under dev. The adapter connects only to a WebKit
inspector port of the same user. WebKit's inspector:// port is open to other
local users, also while a debugger is attached: on a shared machine, use
--no-debug-endpoint.
[dev] Debugging: and the session file's debugEndpoints
("engine": "webkitgtk", "protocol": "cdp") name it, next to WebKit's
inspector:// server, which GNOME Web opens while no debugger is attached.
--no-debug-endpoint turns both off; --webkit-inspector opens WebKit's own
Web Inspector over HTTP instead, on WebKitGTK 2.54.3 or later within 2.54, or
2.56 or later (WebKit bug 330602). dev warns about a
WEBKIT_INSPECTOR_HTTP_SERVER of your own on an unfixed WebKitGTK, and about
inspector addresses that are not loopback. When 9222 is taken, dev moves the
adapter to a free port and names it, except under --no-window, whose IDE
attach configuration names 9222: there it stops with RAPPDEV1017.
RUNIC_DEV_CDP_TRACE leaves script sources and other long strings out unless
RUNIC_DEV_CDP_TRACE_SOURCES=1. The adapter is a preview until its CI job has
run through a release; Rider is not verified yet. See
Debug the page's JavaScript on Linux.

Debug the page in Chrome on every OS: dotnet runic dev --browser (#1053)

dotnet runic dev --browser serves the Window without a native window (its
serve-only mode, RUNIC_APPLICATION_SERVE_ONLY=1) and lets your IDE's
JavaScript debugger open its page in Chrome or Edge at http://127.0.0.1:9224/,
which dev redirects to the Window's own address. Breakpoints in the frontend's
sources then stop in the IDE on Linux and macOS too, where the Window's engine
is WebKit; on macOS it is the only IDE route. The runic-app template's new
Window in Chrome launch configuration (--editor vscode) runs it, with a
runic: dev --browser task. The page runs on Chromium, not the Window's engine,
and without native window features: file dialogs and menus report
OwnerUnavailable.

[dev] Browser: Window serves at <url> names the address, and the session
file's new browser property lists it and each served Window; [dev] Ready
follows the Window's first page. The Window's own address carries its
credential, so dev prints neither it nor the serve-only lines. The address
redirects only navigations the browser starts itself (no Origin, a
Sec-Fetch-Site of none or same-origin, an IP or localhost Host), and
on Linux only from the user who runs dev; macOS and Windows cannot tell a
loopback connection's user. Open it again after dotnet watch restarts the
Window. --browser cannot be combined with --no-window or
--webkit-inspector; without a free loopback port it fails with RAPPDEV1016. See
Debug the page in Chrome.

A Runic panel in the developer tools of Chrome, Edge and the Windows Window (#1060)

dotnet-runic ships an unpacked Chrome DevTools extension (Manifest V3, no
Chrome Web Store listing). Its Runic panel lists the page's Views with
their C# ViewModels, revisions and state, and the recent Bridge calls with
their kind, outcome, time, C# member and, from a .NET host in Development, the
C# handler's name and duration; C# locations open in the editor through the
development server. Its Runic pane in the Elements panel describes the
selected element as Runic Inspect does: component, bound members, commands
with their C# handlers, recent calls and texts. dotnet runic dev prints the
extension's folder ([dev] DevTools extension:) and writes it to the session
file as devtoolsExtension. On Windows, dotnet runic dev loads it into the
Window's WebView2 in Development by adding it to
RUNIC_DESKTOP_DEVTOOLS_EXTENSIONS after any folders you list there;
--no-devtools-extension leaves it out. In Chrome or Edge, including the
browser that dotnet runic dev --browser's launch opens, load it with Load
unpacked
on chrome://extensions, as dev prints; branded Chrome ignores
--load-extension, which Chromium and Chrome for Testing still take. It reads
the page through Runic Inspect's new snapshot() and describe($0), which exist only under the development
client, so production pages are unchanged. See
The Runic DevTools extension.

Runic state in React DevTools and Vue DevTools (#1041)

In development, the React hooks label their values in React DevTools' hooks
pane: useView shows the View (EditorViewModel · editor · rev 12),
useField the field's state (title = "Draft" · editing · 1 error),
useCommand, useOperation and useLatestOperation their status
(running 40%, failed: …). React computes a label only while DevTools shows
the component.

With Vue DevTools on the page, @runic-artifex/vue adds a Runic Views
inspector that lists the page's Views with their state and last calls, and a
Runic Bridge calls timeline layer. It loads @vue/devtools-api 8, a new
optional peer dependency, only when Vue DevTools is present.

@runic-artifex/react and @runic-artifex/vue now have a development build
like @runic-artifex/views (the development export condition): production
builds contain none of this. The state inspector channel's state event also
carries the View's contract. See
React DevTools and Vue DevTools.

Readable View clients and states in the console (#1042)

In development, @runic-artifex/views registers custom object formatters, so
Chromium's and Firefox's console and Sources panel show a View client as
EditorViewModel · editor · rev 12, its state as
EditorViewModel state · rev 12 {title: "Draft", …} and a field controller's
state as title = "Draft" · editing, each expanding into its parts. Turn on
Enable custom formatters in the DevTools settings once. The production
build has no formatter. See
Custom object formatters.

WebView2 DevTools window and DevTools extensions in Development (#1056)

DesktopWindow.OpenDevToolsAsync opens WebView2's DevTools window from code,
and a WebView2 window whose developer tools are on has an Open DevTools item
in its system menu (Alt+Space). The call returns false where the developer
tools are off, as in production, and on other engines.

DesktopHostOptions.DevToolsExtensions, and the
RUNIC_DESKTOP_DEVTOOLS_EXTENSIONS variable for one session, list unpacked
browser extensions, such as React Developer Tools or Vue.js devtools, that
WebView2 windows install into their profile before the first page loads. Only
in Development does the WebView2 environment enable extensions; outside it the
list is ignored. An extension Runic installed whose folder is no longer listed is
removed from the profile in Development. A folder WebView2 rejects is reported as
devtools-extension-failed. See
the debugging guide.

Selection paths, Angular text locale and field types (#1064)

  • NavigationSelectionPath.ToJson() and FromJson(string) save and read one
    selection, such as a tab strip, without the rest of the navigator, in the
    format of NavigationPath and NavigationRegionPath: the same version,
    bounds and FormatExceptions. Restore it with the selection's RestoreAsync.
  • @runic-artifex/angular has injectTextLocale({ injector }), the
    textLocaleSignal of the injection context's Runic instance, like its other
    inject* functions. textLocaleSignal stays for code outside one.
  • @runic-artifex/angular re-exports the field types its injectField and
    injectForm signatures use, as the React, Vue and Svelte adapters do:
    BridgeField, BridgeFieldConstraints, BridgeFieldKind, FieldBaseline,
    FieldDefinition, FieldError, FieldErrorKind and FieldState.
  • The dotnet runic dev IDE contract now includes the [dev] Evaluating and
    [dev] Reloading line prefixes, which the template's .vscode/tasks.json
    waits on. Environment variables
    lists the RUNIC_* variables.

Fixes

  • New SvelteKit apps from the runic-app template (with or without
    --translations) get @sveltejs/adapter-static 4.0.1, which fixes
    GHSA-jf9x-2fg2-hx4w.
    The advisory concerns route config generated for Vercel; an existing app can
    move to 4.0.1, which @runic-artifex/sveltekit's peer range already admits
    (#1040).
  • Hosted application windows (experimental, RUNICDESK103): on GTK 4, choosing
    an item of a window's native menu bar, by pointer or with the bar's own
    keyboard navigation, or of the desktop's global menu now gives a window the
    application activated back to the user, as on Windows, macOS and WebKitGTK 3.
    Before, the application's clipboard and launch requests from that window
    stayed refused until the user switched away and back or dropped files onto it
    (#855,
    #1045).
  • VS Code's JavaScript debugger no longer reports "Could not read source map"
    for @runic-artifex/vite-plugin-runic's dist/inspect-frameworks.js on
    every attach: a doc comment in it read as the file's source map comment.
    Package verification now rejects such comments in every Runic npm package
    (#1050).
  • A client that useView or injectView keeps after its component went away is
    no longer taken over by the next test's binding when each test installs a new
    mock Bridge: it kept talking to the previous test's mock, so the new test's
    commands reached the old handlers and its state never arrived. A kept client
    is now taken over only while its instance uses the Bridge it connected over,
    and installMockBridge releases the previous Bridge's kept clients at once.
    releaseKeptViews() from @runic-artifex/views/mock releases the kept
    clients for a suite that keeps one Bridge across tests
    (#798,
    #1058).
  • Runic Inspect no longer loses a click on a card link when the page's text
    changes during the click: the card now keeps its unchanged links and updates
    only what changed, instead of drawing all of its contents again
    (#1063).
  • New SvelteKit applications (dotnet new runic-app --frontend sveltekit)
    get @sveltejs/kit 3.1.1, which fixes a crash of adapter-node's server on a
    malformed URL with reroute
    (GHSA-mw6w-2fmv-pvw3).
    The template's static output never ran that code, so existing applications
    aren't affected; move to 3.1.1 to keep npm audit quiet
    (#1074).

CI and tests

  • A new WebKitGTK debugging / js-debug job attaches VS Code's JavaScript
    debugger (vscode-js-debug's DAP server) through dotnet runic dev's adapter
    to the runic-app template's Window, GTK 3 and GTK 4, and runs the same
    scenarios through the Window in Chrome configuration (#1033, #1053).
  • The train compatibility gate serves the Translations npm candidates to the
    template scenarios, and picks the newest successful main run from the
    unfiltered run list, which GitHub's filtered listing could omit for over an
    hour (#1036, #1075).
  • When a run builds only one runtime identifier's native server library and
    takes the others from the cache, the check that every runtime identifier has
    its libraries finds the one downloaded artifact, which download-artifact
    extracts without its directory (#1039).
  • A pull request that changes only Markdown, such as a package README, plans no
    Windows or macOS leg. It still runs the Linux jobs, because package READMEs are
    packed. The analyzers' AnalyzerReleases.*.md files are compiler inputs and
    keep their legs (#1048).
  • tests/native/Runic.Desktop.GlobalMenuCheck, a manual check app for the Linux
    global menu (#1049).
  • Runic Inspect's browser test no longer flakes when a card redraw splits the
    click that opens a message (#1054, #1061).
  • The windows-11-arm jobs close the runner's full-screen Microsoft account
    prompt, which broke the notification area and OLE drags, so the status icon
    check runs on win-arm64 too (#373, #391, #1066).
  • The template tests bind a train candidate's integrity in every lock format,
    not only package-lock.json: the pnpm and Bun variants no longer fail with a
    tarball integrity error when an upstream repository's candidate is rebuilt
    with the same version during a release train (#1076).

Known issues

  • WebKit's own inspector:// port is open to other local users. Under
    dotnet runic dev on Linux, WebKitGTK's remote inspector server, which the
    debugging adapter and GNOME Web connect to, cannot be filtered: another local
    user can connect to it, also while a debugger is attached, and a client that
    replaces another one can crash the Window on WebKitGTK 2.54. The adapter
    detaches its debugger when it notices a replaced client. On a shared machine,
    run dotnet runic dev --no-debug-endpoint. See
    Debug the page's JavaScript on Linux.
  • WebKitGTK's HTTP inspector accepts any website's Origin and Host before
    2.54.3 within 2.54, and before 2.56
    (WebKit bug 330602); the
    newest release, 2.54.2, is affected. Outside Development the variable is
    cleared (0.20); under dotnet runic dev, --webkit-inspector opens it only
    on a fixed WebKitGTK, and dev warns about a WEBKIT_INSPECTOR_HTTP_SERVER
    of your own on an unfixed one. Use the debugging adapter or
    WEBKIT_INSPECTOR_SERVER instead.
  • IDE JavaScript debugging is a preview on Linux and goes through Chrome on
    macOS.
    The Linux adapter stays a preview until its CI job has run through a
    release, and Rider's JavaScript debugger is not verified with it. WKWebView
    opens no DevTools Protocol endpoint, so on macOS the IDE debugs the page in
    Chrome with dotnet runic dev --browser, without native window features, or
    Safari's Web Inspector debugs the Window. On Windows, WebView2 ignores the
    endpoint's variable in an elevated Window: run dev and the IDE without
    elevation.
  • 0.20.0's known issues about the Angular CLI (no Vite plugins, so no dock and
    no in-place message updates), Go to Type Definition on the result of
    connect…() and CS-WebUI dropping the query of a request for /
    (cs-webui#33), and
    0.19.0's about the side panel, the close drain on an installed browser,
    serve-only mode and CS-WebUI, assistive technologies in hosted regions and a
    guest's prefers-color-scheme in a region, are unchanged; see
    0.20.0's known issues.

What's Changed

Full Changelog: v0.20.0...v0.21.0