deps: Bump Verso.Abstractions from 1.1.0 to 1.2.2

[dependabot]

Updated Verso.Abstractions from 1.1.0 to 1.2.2.

Release notes

Sourced from Verso.Abstractions's releases.

1.2.2

Release letting Markdown cells typeset TeX math and draw Mermaid diagrams in place, rendering a DataFrame as a typed, scrollable table through a new formatter built into every host, putting Verso's notebook tools in front of Copilot agent mode for the first time and only while a notebook is open, documenting the five showcase layouts, and adding two PowerShell sample notebooks that build Vega-Lite charts over DataFrames, with notice that a coming release will require .NET 10.

Upgrade Notes

• A coming release will drop .NET 8 and require .NET 10 or newer. .NET 8 leaves Microsoft support on November 10, 2026, and .NET 9 ends the same day, so the host, the command line tool and the VS Code extension will move to .NET 10 ahead of that date. Nothing changes in this release: .NET 8, 9 and 10 all still run Verso. Installing the .NET 10 runtime now, or accepting the extension's offer to install one, means the switch will pass unnoticed when it comes. Verso's library packages already ship .NET 10 builds beside .NET 8, so an extension can move ahead of the host, and one built for .NET 8 keeps loading on a .NET 10 host
• A DataFrame now renders as a table before any other formatter sees it. A Microsoft.Data.Analysis.DataFrame used to fall through to the expandable object graph and run into the wide-type output budget. If you wrote a formatter extension of your own for DataFrames, give it a priority above 50 to keep it in front

New: Math and Diagrams in Markdown Cells

• Markdown cells typeset TeX math with KaTeX. Wrap an inline formula in single dollars, $E = mc^2$, or a display equation in double dollars on lines of its own; the \(...\) and \[...\] delimiters work too. A dollar amount such as $5 stays ordinary text, and a dollar sign inside inline code or a fenced block stays code
• A fenced code block tagged mermaid renders as a diagram in place, so prose and diagrams can share a cell, and @​variable substitution applies inside the fence as it does to the rest of the cell. Asked for by @​sheng-jie (#​101)
• Both carry through to HTML export. An exported notebook loads KaTeX and Mermaid only when a cell needs them, and a formula that fails to typeset leaves its source text in place
• The dedicated Mermaid cell type remains the one that offers diagram keyword completions and reports an unresolved variable as a diagnostic, and the guides say which to reach for

New: DataFrame Tables

• A Microsoft.Data.Analysis.DataFrame returned from a PowerShell or .NET cell renders as a scrollable table with column names and types, sticky headers and visible nulls, through a new Verso.DataFrame formatter that is built into the VS Code extension, verso serve and verso run and is also published as its own NuGet package. An explicit Display call renders the same way, including one made from PowerShell that still carries its PSObject wrapper. Contributed by @​eosfor (#​94)
• The table is a bounded preview: the first 100 rows and 50 columns, with the frame's total row and column counts in the footer, and any cell value longer than 200 characters shortened, so a wide or long frame cannot swamp the output
• The formatter reads a frame through reflection and takes no dependency on Microsoft.Data.Analysis, so the PowerShell module or kernel that created the frame keeps ownership of the assembly and there is no second copy to conflict with
• Table text, including the empty-frame message and the footer counts, is translated into German, Spanish, Japanese and Simplified Chinese alongside English

Improved: Copilot Agent Mode

• Copilot agent mode can now see Verso's twenty notebook tools. They had been registered in a way that kept them out of the agent tool picker, so only the @​verso participant could reach them and the README's promise of agent mode without typing @​verso did not hold. Diagnosed and fixed by @​4D-Bird in #​102, recreated here with their agreement
• The tools are offered only while a notebook is open, so a chat session about something else does not carry twenty notebook tools it cannot use, and each one can be pulled into a prompt by name, #verso_runAll for instance
• Each tool carries a short description in the tools picker, translated into the five interface languages, in place of the long model-facing text that used to show there

Improved: Documentation and Samples

• A new Showcase Extensions section documents the five sample layouts, DAG Notebook, Slide Studio, Grid Studio, Form Studio and Image Studio, with a page and screenshots for each, how inline and isolated layouts differ, and how to install or build one. The layouts guide lists all five and links to it
• A Palmer Penguins sample notebook loads a public CSV into a typed DataFrame from PowerShell, inspects and groups it with every frame drawn by the new formatter, and builds three interactive Vega-Lite charts from PowerShell hashtables. Contributed by @​eosfor (#​95)
• A Deneb Showcase sample notebook adapts ten Vega and Vega-Lite visualizations from David Bacci's Deneb Showcase to refreshable public datasets, from a calendar heatmap of daily weather to a bar chart race of World Bank population, with the download and display steps split so a chart can be pointed at a different year or selection without fetching again. Contributed by @​eosfor (#​103)
• The Interactive Widgets and Python Packages guides now say when a #!pip line is needed and when it is not. In the editor the default install policy offers to install whatever a cell imports and cannot find, while verso run --auto-install installs only distributions Verso keeps a mapping for, so a package that installs under its import name, ipywidgets among them, still needs the line on the command line
• The README describes DataFrame tables and math and diagrams in Markdown and links the showcase section, the architecture pages list Verso.DataFrame and the KaTeX interop, and the known issue about wide framework types no longer cites DataFrame as its example (VERSO-007)

Improved: Contributing

• The DCO check now rejects a commit authored or signed off with a GitHub noreply address, since nobody can be reached through one, and CONTRIBUTING.md says so

Fixed

• A Mermaid cell no longer fails silently when the code editor's module loader was already on the page, which in a real notebook it usually is. Mermaid's bundle registered itself with that loader and threw, and the failed load then left the library dead for the rest of the page. Both the VS Code extension and the browser now load Mermaid in a way the editor's loader cannot see, and several diagrams rendering at once share a single load

1.2.1

Release making Python widgets live rather than pictures of themselves, so a slider drawn in a cell keeps talking to the interpreter that made it and can drive a computation written in another language, translating the interface into four more languages, opening the space beside the notebook to panels contributed by extensions, giving language kernels a formatter extension point so a package can teach Verso to render its own types, and preferring the native libraries a NuGet package ships over whatever the system offers first.

Upgrade Notes

• Code written after #!import in the same cell now runs. Everything below the directive used to be discarded without a word. A cell that carries boilerplate under an import, on the assumption it was inert, will execute that code for the first time on this release
• An extension built against Verso.Abstractions 1.2.0 needs a 1.2.0 or newer host. The host accepts an extension whose referenced minor version is at or below its own, so a 1.1 host declines a 1.2.0 extension and asks for a newer host. Patch versions are never compared, which is why extensions kept loading across the whole 1.1 series
• Formatter extensions should check context.MimeType in CanFormat. Both new interface members have default implementations, so nothing fails to compile, but a formatter that claims a value it cannot render in the MIME type actually requested is now stepped over rather than allowed to answer

New: Live Python Widgets

• A rendered ipywidgets or anywidget control now stays connected to the Python interpreter that made it for as long as the session runs. Dragging a slider fires the author's Python callback, and Python changing the value moves the control back, both within a cell and across cells
• ipywidgets Output areas capture prints, displays and clear_output the way a Jupyter kernel does, so interact and interactive_output behave as documented instead of showing nothing
• A widget with no interpreter behind it, because the file was just opened, was run from the command line, or its kernel restarted, draws visibly inert with a note to run the cell rather than looking like a control that is simply broken
• Saving a notebook asks each live widget for its current on-screen state, so the file records what you were looking at rather than whatever the cell first drew
• A new verso.widgets.assetSource setting chooses where a widget's front end JavaScript loads from. Only cdn works today; bundled is reserved for a copy shipped alongside the notebook
• A new Interactive Widgets guide covers what separates a live widget from a static one, what a saved file holds, how widgets behave with no network, anywidget support, and the size limits that apply

New: Cross-Language Widget Binding

• #!bind projects a widget's trait into the notebook's shared variables under a name you choose, in both directions, so a slider built in a Python cell can drive a computation written in C# or F#, and writing that variable moves the slider back
• #!bind --list shows every trait currently projected as a variable, and #!bind --remove <name> stops one from following its widget without deleting the variable
• A new DAG Notebook showcase layout makes the notebook dependency-aware: running a cell re-runs the cells that read the variables it defines, in dependency order, so a bound control at the top of the graph cascades a run with nothing else clicked

New: Interface Language

• Verso's interface ships in German, Spanish, Japanese and Simplified Chinese alongside English, covering the notebook UI, the toolbar and panels, kernel messages that land in cell output, and the command line tool
• Choose a language with --language or the verso.language setting. With neither, Verso follows VERSO_LANGUAGE, then the operating system's own language, then falls back to English
• verso serve negotiates a language per browser from its Accept-Language header, or pins one for every visitor with verso serve --language
• Regional tags resolve sensibly, so de-AT reaches German and zh-CN reaches Simplified Chinese, and a tag Verso does not recognize falls through to the next source instead of failing
• Numbers, dates and currency keep the machine's own formatting whichever interface language is chosen, so a language never changes what a cell computes or what gets written into a notebook
• Database connection diagnostics, including provider not found and multiple providers registered, are translated along with everything else
• Translations are checked on every build for missing keys, orphaned keys, mismatched placeholders and empty strings, and a pseudo-locale flags any string still hardcoded in English

New: Notebook Panels

• An extension can contribute a panel that sits beside the notebook body and toggles from the toolbar, alongside Verso's own Metadata, Extensions, Variables, Settings and Cell Properties panels, by implementing INotebookPanel
• A panel describes its content as one or more representations ordered richest first, rather than drawing it directly, so the same panel works on every host including one that never touches a browser. Offering a text/plain alternative beside text/html is what keeps a panel useful everywhere
• A panel can implement IPanelInteractionHandler to respond to clicks and other actions raised inside it, and call RequestRefresh to have the host ask for its content again after something changes

New: Compare Panel

• A Compare panel picks a baseline and steps through a notebook's changes one at a time while the notebook itself stays visible. Changed cells carry a colored stripe and a badge reading Added, Removed, Modified or Moved, and selecting an entry scrolls to the cell it describes

New: Formatter Extensions

• Language kernels can hand a runtime value to registered formatter extensions before applying their own rendering, through a new IExecutionContext.TryFormatAsync. PowerShell is the first kernel wired to it, contributed by @​eosfor (#​93)
• A formatter extension can declare itself a fallback, so it runs only for an explicit Display call and steps aside when a specialized formatter is present. PowerShell output that no extension claims renders exactly as it did before, through the same table and list formatting, contributed by @​eosfor (#​93)

Improved: Native Library Resolution

... (truncated)

1.1.3

Release replacing the in-process Python integration with a supervised host process that runs the CPython installation already on your machine, adding plain Markdown (.md) as a first-class notebook format, drawing ipywidgets-based visualizations inside Python cells, introducing an output model that distinguishes standard error and progress from ordinary output, and bounding object-graph rendering so framework internals can no longer exhaust the output budget.

Upgrade Notes

• Python cells now need CPython 3.8 or newer installed on the machine. Verso no longer carries a Python runtime. Where no interpreter is found, a Python cell reports what was searched instead of failing silently
• PythonKernelOptions.PythonDll is ignored. The property remains, so nothing fails to compile, and a session that sets it says once that it has no effect now that Python runs as a separate process. There is no other public API change: the types removed from Verso.Python were all internal

New: Python Runs on Your Own Interpreter

• Python cells execute in a separate host process that Verso supervises over a loopback connection, replacing the previous in-process integration. The embedded Python runtime is gone; cells run a CPython installation on your machine, 3.8 or newer
• Each spawn is authenticated with its own token handshake and framed with NDJSON. The accept loop keeps listening until a valid handshake arrives, applies a per-connection greeting timeout, and reports refusals and authentication failures instead of hanging
• A crashed or wedged interpreter no longer takes the notebook with it: the connection recovers, and a peer reset is treated as end of stream rather than a transport error
• Interrupting a running cell escalates per platform, SIGINT on Unix and CTRL_BREAK on Windows, respecting console ownership. Windows children are assigned to a job object, so terminating the host takes the whole process tree with it
• On POSIX the host watches the process that launched it and exits on its own if that process goes away, so an orphaned interpreter cannot linger

New: Interpreter Discovery and Selection

• Interpreters resolve in a defined precedence order: explicit configuration, VERSO_PYTHON, the interpreter selected for the session, VIRTUAL_ENV, CONDA_PREFIX, workspace virtual environments, PATH, then well-known install locations
• Candidates are probed with an introspection script and cached by modification time. A probe distinguishes runnable, abandoned, and not-runnable outcomes, and only a probe that finished successfully is cached
• Validation enforces CPython and the minimum version, and detects PEP 668 externally managed installations so package operations can explain themselves rather than failing obscurely
• Where the chosen interpreter is not writable, a derived virtual environment is created or reused, using uv when it is available and stdlib venv otherwise
• #!python inspects, lists, and selects interpreters for the session, reporting the path, version, how it was discovered, and whether the environment is externally managed
• --python <path> pins the interpreter for verso repl, verso run, and verso serve
• Discovery is hardened on Windows: the py launcher is resolved by full path, WindowsApps stubs are skipped, launcher and output-drain steps are bounded by timeouts, an overrunning probe is killed instead of left to hang, and installs under %LOCALAPPDATA%\Python are found

New: Python IntelliSense

• Completions, hover, and diagnostics are computed in the host process against the live session, on a dedicated thread with timeouts, replacing the in-process completion provider
• The analysis package is provisioned in the background into a per-version tools directory, installed to a staging directory and published atomically so a reader never observes a partial tree

New: Python Package Handling

• A cell's imports are scanned before it runs; a package the environment lacks is offered for installation, installed, and the cell retried, with a ModuleNotFoundError backstop for imports that scanning cannot see
• --auto-install on verso run, and a matching environment variable, enables this without prompting
• Consent prompts distinguish package installs from extension installs and name the environment being modified
• Notebook-declared requirements refuse installer options and external sources
• Installer output is summarized by default and can be switched to full detail per kernel, for pip/uv and npm alike. A failed install always prints in full

New: Cross-Process Variable Sharing

• Values cross to and from Python as data, with wire tagging for shapes JSON cannot carry natively: dates and times, exact decimals, big integers, GUIDs, byte arrays, NaN and infinity, and a DataTable as rows
• A value with no meaning outside the process that made it (a delegate, a task in flight, an open resource, an F# union case) is still bound to its name, and printing or using it explains which variable it was and why it could not cross
• Canonical fingerprinting makes identical numbers hash the same under Python's JSON writer and System.Text.Json, which stops unchanged values from being re-injected on every execution
• Per-variable size budgets, oversize notices, and status tracking. A name beginning with a double underscore is never injected, since Python reserves that prefix for the interpreter's own

New: Python Widget Rendering

• Libraries that render only as ipywidgets models, among them k3d, ipyleaflet, pythreejs, bqplot, and ipyvolume, now draw in Python cells. Widget state is packaged into a self-contained document (text/x-verso-widget) and given its own auto-resized frame
• Framed widgets follow the host theme: theme tokens are resolved to concrete colors and injected into the widget document, then re-injected when the theme changes
• A widget that exports a file, such as a chart snapshot, hands the bytes to the host, which offers a save dialog and writes them. Both a direct click() and a synthetic click dispatched through dispatchEvent are intercepted
  ... (truncated)

1.1.2

Release adding a cell-level notebook comparison view, a Slide Studio slide-deck showcase layout, markdown that renders as soon as a notebook opens, per-output error isolation with coalesced rendering for output-heavy notebooks, a runtime-partitioned extension store, TypeScript 7 detection with a pinned 6.x toolchain, and fixes across layout resolution, mermaid rendering, imports, and Blazor Server prerendering.

New: Notebook Comparison

• Compare the open notebook, including unsaved edits, against the last saved file, git HEAD, any branch, tag, or commit, or another notebook file (.verso, .ipynb, or .dib)
• The view shows added, removed, edited, and moved cells with side-by-side source comparison, and when a cell's outputs changed, the old and new rendered outputs appear next to each other
• Cells are matched by Verso's stable cell identity, so an edited cell is distinguished from a deleted-plus-added pair; formats without cell identity (.ipynb, .dib) match by content and are labeled as approximate matches
• Notebook-level changes (title, default kernel, layout, theme, extension requirements, parameters, and saved layout state) are listed at the top, with save-time noise such as the modified timestamp excluded
• The comparison is read-only and never marks the notebook dirty; on very large change sets, source comparisons load as you expand them
• In VS Code: a Compare toolbar button, a diff icon in the editor title bar, and the Verso: Compare Notebook with... command

New: Slide Studio Showcase Layout

• A fourth showcase layout extension, Verso.Showcase.SlideStudio, turns a notebook into a slide deck with a filmstrip of cell previews, an editor and output split view, and a full-screen presenter mode
• Per-cell presenter flags (include, show source, show output) persist in cell metadata and are editable from the filmstrip, the pane headers, or the properties panel
• Presenter slides show live outputs, so interactive charts and widgets keep working while presenting
• The CI and release workflows pack the sample so it ships as a NuGet package alongside the other showcase extensions

New: Markdown Renders on Open

• A built-in Markdown cell type pre-renders its markup when a notebook opens, so prose arrives already rendered instead of showing raw source until run
• Rendered markdown is transient: it is stripped on save, does not increment execution counts, and does not mark the notebook dirty
• The initially selected cell is chosen so a rendered markdown cell does not immediately flip into its editor

Improved: Output Rendering and Resiliency

• Each cell output renders inside its own error boundary, so a faulty output degrades to an inline error with a Retry action instead of blanking the rest of the notebook
• Output update notifications are coalesced, reducing whole-page re-renders during output bursts
• Cell toolbar enabled-state queries are cached and coalesced, and re-query when variables, extensions, or kernel state change, cutting host traffic during re-renders
• The Monaco editor only receives a language change when the language actually changed, reducing webview main-thread traffic
• Non-editable cells auto-execute once instead of repeatedly before their first output arrives
• The F# Interactive session initializes on a thread-pool thread, avoiding deadlocks on context-bound threads during startup and kernel restart

Improved: Extension Store Runtime Partitioning

• Managed extension installs are stored under a per-target-framework subfolder (for example net8.0), so hosts running different .NET runtimes keep compatible copies side by side instead of overwriting each other's assemblies
• Loading selects the newest compatible runtime folder, and an assembly's required runtime is inferred from its metadata without loading it

Improved: TypeScript 7 Detection

• Auto-installed TypeScript is pinned to the 6.x line; TypeScript 7 removed the JS compiler API the kernel depends on
• An existing unsupported 7+ install is detected and replaced with the pinned version automatically, with clearer error messages when installation fails

Improved: Copilot Participant Guidance

• The @​verso participant's system prompt now covers package installation, Display() and rich outputs, and clarifies that Verso is not built on .NET Interactive

Fixed: Layout and Required-Extension Resolution

• The missing-layout notification is deferred while required extensions are still resolving and only appears if the layout remains missing after they load
  ... (truncated)

1.1.1

Release introducing custom layout extensibility with inline and isolated renderers, an in-app extension marketplace with per-notebook required extensions and persisted trust, three showcase layout extensions published as NuGet packages, a redesigned notebook toolbar with icon-only actions and export, smarter .NET runtime detection in the VS Code extension, hardened Python variable publishing, GitHub Codespaces support, and a major documentation expansion alongside a reworked extension project template with a new layout scaffold.

Thanks to @​fluentfoundation and @​fiVISION for sponsoring and supporting this project.

New: Custom Layout Extensibility

• Extensions can now ship complete notebook layouts through ILayoutEngine, with ILayoutInteractionHandler for routing UI interactions and ILayoutLifecycleHandler for cell lifecycle notifications
• Inline layouts render in the host page: the layout emits a slot per cell and the host mounts live, fully interactive cell components into the layout's own HTML
• Isolated layouts render in a sandboxed iframe with their own renderer package, a bridge API for host communication, and a strict content security policy
• Layouts declare capabilities (insert, delete, reorder, edit, execute) and hosts adapt: display-only layouts skip mounting the editor, ignore command-mode keys, and keep outputs visible when clicked
• Layout styling follows the active theme through --verso-* CSS variables that cascade across the web and VS Code hosts, and themes gain coarse background and foreground tokens for layouts to consume
• Layouts persist their state in notebook metadata and can provide scoped static assets such as stylesheets
• The built-in layouts run on the same public API, and everything works across Blazor Server, WebAssembly, and the VS Code extension

New: Extension Marketplace

• A marketplace pane searches NuGet and installs or uninstalls extension packages without leaving the notebook
• Notebooks can declare required extensions, which are resolved and loaded before the notebook initializes
• Trust prompts pin to the resolved package version and re-prompt if it drifts; trust decisions persist per notebook
• Installed extensions that fail to load are flagged in the extension panel with a warning and the reason
• Package extraction guards against path traversal, and extension load failures degrade to a banner instead of blocking the notebook

New: Showcase Layout Extensions

• Three sample extensions demonstrate the layout API end to end and are published as Verso.Showcase.* NuGet packages: Image Studio (an isolated-layout image compositor), Form Studio (form-driven notebooks with charts), and Grid Studio (data grid editing)
• Form Studio charts and Grid Studio grids bind System.Data.DataTable variables in addition to DataBlock, so SQL cell results display directly; DataTable sources are shown read-only

Improved: Notebook Toolbar

• The toolbar was redesigned with icon-only actions, and extension toolbar actions can declare IconOnly, IsPrimary, and ConfirmationPrompt
• Notebook export is available from the toolbar, backed by a per-host file download mechanism that also works from isolated layouts
• Extension health is tracked and surfaced in the UI

Improved: Notebook Reliability

• Transient outputs, such as the parameters form, no longer mark the notebook edited when they auto-render; cell types declare whether their outputs persist, and interaction handlers can signal persisted-state changes
• Cell type and language menus render in the browser top layer using the Popover API, so they no longer paint beneath neighbouring cells
• Publishing Python variables with self-referential or deeply nested structures no longer crashes the host; conversion guards against cycles and depth

New: .NET Runtime Detection and Install Guidance in VS Code

• The extension resolves which dotnet to use (an explicit verso.dotnetPath setting, a previously acquired runtime, or PATH) and checks it against the host's required runtime
• Missing or incompatible runtimes produce actionable errors, including an offer to install the runtime on demand through the .NET Install Tool
• Host start failures are classified (dotnet not found, incompatible runtime, timeout, crash) so the guidance matches the actual problem

Improved: GitHub Codespaces Support

• The notebook editor now works in GitHub Codespaces from Chromium-based browsers such as Chrome and Edge; a remaining Safari limitation is documented in the known issues

Improved: Extension Project Template

... (truncated)

Commits viewable in compare view.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

---

Dependabot commands and options

You can trigger Dependabot actions by commenting on this PR:

• @dependabot rebase will rebase this PR
• @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
• @dependabot show <dependency name> ignore conditions will show all of the ignore conditions of the specified dependency
• @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
• @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
• @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

[dependabot]

Looks like these dependencies are no longer being updated by Dependabot, so this is no longer needed.

[xkqg]

Closing: the notebook package is compiled against Verso.Abstractions 1.1.0 on purpose, because Verso refuses an extension compiled against a newer minor than the one it runs, so raising the floor decides which Verso still loads the package. Dependabot now leaves this package alone (.github/dependabot.yml, 063540e), and PackageTests holds that.