verso-v1.0.11

Release adding GitHub Copilot Chat integration, MIME type output renderers, cell drag-and-drop reordering, collapsible notebook sections, webview cache-busting, C# stderr capture, and NuGet source registry resolution.

New: GitHub Copilot Chat Integration

• Verso now integrates with GitHub Copilot Chat through a @verso chat participant with slash commands and language model tools
• Tools include list, add, update, remove, run, runAll, listVariables, inspect, and getLanguages for full notebook manipulation from Copilot
• A host registry maps open notebooks to their host process and bridge so Copilot tools can locate and communicate with the correct notebook
• Registration is guarded at runtime so the extension still loads on VS Code forks (e.g. VSCodium) that strip Copilot APIs

New: MIME Type Output Renderers

• Cell outputs now render image/* types as base64 <img> elements, application/json as a collapsible syntax-highlighted JSON tree (first two levels expanded), and text/csv as a styled scrollable HTML table with header detection
• A sample notebook (samples/Notebooks/mime-types.verso) demonstrates all supported output types including text/html, SVG, images, JSON, CSV, Mermaid, and error outputs

New: Cell Drag-and-Drop Reordering

• Cells can be reordered by clicking and dragging on the left gutter, matching the interaction pattern in Jupyter and Polyglot notebooks
• A ghost element follows the cursor during the drag and a blue drop indicator line shows the target position
• Auto-scrolling activates when the cursor approaches the top or bottom edge of the viewport
• Gutter buttons (run, collapse) are excluded from the drag handle so they continue to work normally

New: Collapsible Notebook Sections

• Markdown cells starting with headings (# syntax or <h1>-<h6> tags) now show a collapse chevron in the gutter
• Collapsing a heading cell hides all subordinate cells until the next heading of equal or higher level, following the same section folding pattern as Polyglot notebooks
• Run button and cell index were moved from the toolbar to the left gutter for a cleaner layout

Improved: Webview Cache-Busting

• The VS Code extension now appends ?v=<version> to all Blazor WASM resource URIs using the version from package.json
• The loadBootResource callback also appends the version to framework asset requests (blazor.boot.json, blazor.webassembly.js)
• This ensures extension updates are never served stale cached assets from the webview's Service Worker cache

Improved: C# Stderr Capture

• Console.Error output during C# cell execution is now captured and surfaced as an error output alongside stdout
• The original Console.Error stream is saved and restored after each execution

Improved: NuGet Source Resolution

• Package resolution now includes sources registered via #i "nuget: <url>" directives when resolving #r "nuget: ..." references
• Sources from the NuGetSourceRegistry are retrieved from the execution context and added to the resolver before package lookup

verso-v1.0.10

Release adding F# type provider support, NuGet source directives, per-notebook host process isolation in VS Code, imported notebook save safety, F# value formatting, editor font syncing, and broader Python runtime detection.

New: F# Type Provider Support

• NuGet package resolution now extracts type provider assemblies from typeproviders/fsharp41/{tfm}/ alongside lib/ DLLs so FCS can discover them
• An AppDomain.AssemblyResolve handler probes registered NuGet assembly directories for compile-time dependencies that type providers require
• Both the #r "nuget: ..." magic command and the NuGet reference processor register resolved package directories with the F# session
• Target framework selection is now derived from the running runtime (Environment.Version.Major) instead of a hardcoded list, applied to both the F# and C# NuGet resolvers

New: NuGet Source Directives (#i)

• #i "nuget: <url>" directives are now supported in C# code cells, adding session-scoped package sources for #r "nuget: ..." resolution
• Package resolution tries configured sources in priority order: session-scoped sources first, then sources from NuGet.Config, then nuget.org as a fallback
• The Monaco tokenizer highlights #i directives with the same styling as #r

New: Per-Notebook Host Process (VS Code)

• The VS Code extension now spawns a dedicated Verso.Host process for each open notebook instead of sharing a single global process
• Each host receives the notebook's directory as a working directory at open time, so __SOURCE_DIRECTORY__ and relative file paths in F# resolve correctly against the notebook location
• Host processes are started when a notebook opens and disposed when its editor closes
• This also eliminates cross-notebook notification routing conflicts when multiple notebooks are open

New: Imported Notebook Save Safety

• Saving a notebook that was imported from a non-.verso source (.dib, .ipynb) now writes to a .verso file instead of overwriting the original
• The VS Code extension creates the .verso file, updates the host with the new path, opens the new file, and closes the imported editor
• Save As also adjusts the destination to use the .verso extension

Improved: F# Value Formatting

• Newly bound values after cell evaluation are now formatted via TryFormatAsync for richer presentation of collections, records, and custom types
• Existing names and the implicit it binding are excluded from formatting
• Falls back to raw FSI output when no formatted bindings are produced

Improved: VS Code Editor Font Syncing

• Monaco editors in the webview now inherit font family, font size, and font ligature settings from VS Code
• Initial settings are injected at webview creation, and configuration changes are pushed to all open webviews in real time
• Ligature-capable fonts are prepended to the font stack by default

Improved: Python Runtime Detection

• PythonEngineManager now searches Anaconda and Miniconda installation paths on macOS, Linux, and Windows
• Windows Store Python installations are detected by scanning LocalCache/local-packages directories under the user's package folder

verso-v1.0.9

Release adding placeholder variable support in connections, Firebird database schema support, cell execution status UI, extension loading improvements, layout capability controls, and a sample Perl kernel.

New: Variable Placeholders in Connection Strings

• $var:VariableName tokens are now supported in connection strings and provider parameters (thanks to @alansbraga for contributing provider placeholder support in #12)
• Variables are resolved from the notebook's IVariableStore at connect time
• $var: tokens expand before $env: tokens, and both can be mixed in the same string
• Clear error messages when the variable store is missing, or a variable is undefined or empty
• Renamed CredentialResolver to PlaceholderResolver to reflect the broader scope

New: Cell Execution Status UI

• Cells now display execution status below the editor, showing a status icon, elapsed time, and execution count
• Execution metadata (ExecutionCount, LastElapsed, LastStatus) is tracked transiently on CellModel and excluded from serialization
• Status fields clear when cell outputs are cleared

New: Firebird Database Schema Support

• SchemaCache detects Firebird connections and routes schema loading to Firebird-specific queries against RDB$ system tables
• Discovers tables (RDB$RELATIONS), columns (RDB$RELATION_FIELDS, RDB$FIELDS, RDB$TYPES), and foreign keys (RDB$RELATION_CONSTRAINTS, RDB$REF_CONSTRAINTS, RDB$INDEX_SEGMENTS, RDB$INDICES)
• Identifies primary keys, nullability, defaults, and data type names
• Schema detection priority: SQLite, then Firebird, then INFORMATION_SCHEMA

New: Layout Capability Flags

• Layouts can now advertise supported actions via LayoutCapabilities flags
• Capabilities are threaded through INotebookService, LayoutInfo, and the layout DTO/handler
• The UI disables or hides cell-insert controls (toolbar and add-cell buttons) when the active layout lacks CellInsert

New: Sample Perl Kernel

• Added Verso.Sample.Perl project demonstrating how to build a language kernel extension
• Implements ILanguageKernel by invoking the system perl executable with temporary .pl files
• Supports execution with stdout/stderr capture, cancellation, diagnostics via perl -c, basic completions, and hover info (including detected Perl version)

Improvements: Extension Loading

• Built-in (co-deployed) extensions now load into the default AssemblyLoadContext via Assembly.LoadFrom, skipping the overhead of creating isolated load contexts
• A metadata-only PE check (System.Reflection.Metadata) detects references to Verso.Abstractions on disk before loading, avoiding unnecessary assembly loads
• Third-party extensions still load through dedicated ExtensionLoadContext instances for isolation
• Added HostAbstractionsVersion and version compatibility checks; incompatible extensions are unloaded and skipped during auto-discovery, or throw ExtensionLoadException when loaded by path
• ExtensionLoadContext returns the host's Verso.Abstractions assembly directly so interface types match regardless of the extension's compiled version

Misc

• Removed .devcontainer configuration (the extension requires desktop VS Code and is not compatible with browser-based environments such as GitHub Codespaces)
• Added THIRD-PARTY-NOTICES.md with component inventory and full license texts (MIT, Apache-2.0, BSD-2-Clause) for Roslyn, NuGet.Protocol, ASP.NET Core Components, PowerShell SDK, FSharp.Compiler.Service, pythonnet, and Markdig

verso-v1.0.8

Feature release adding an HTTP cell type for sending REST API requests in notebooks, an object tree renderer for rich data display, user preferences persistence, and fixes for extension toggling, layout cycling, and editor scroll behavior.

New: HTTP Extension (Verso.Http)

A new HTTP cell type lets you send REST API requests directly in notebook cells using .http file syntax, the same format supported by VS Code's REST Client and JetBrains HTTP Client.

• All HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
• Variable interpolation with @name = value declarations and {{name}} references
• Dynamic variables ({{$guid}}, {{$timestamp}}, {{$randomInt}}, {{$datetime}}, {{$processEnv}})
• Named request chaining via # @name and response references ({{name.response.body.$.path}})
• Multiple requests per cell separated by ###
• Request directives (# @no-redirect, # @no-cookie-jar)
• Query continuation (lines starting with ? or & append to the URL)
• Magic commands: #!http-set-base, #!http-set-header, #!http-set-timeout
• IntelliSense with HTTP method and header completions, diagnostics for unresolved variables, and hover info
• Cross-kernel integration where response data (httpResponse, httpStatus) is shared to C#, F#, and other cells
• Formatted response output with status badges, timing, collapsible headers, and pretty-printed JSON
• Sample notebook included at samples/Notebooks/sample-http.verso

New: Object Formatter and Tree Renderer

• Added ObjectFormatter for rendering arbitrary non-primitive objects as HTML property tables (public properties and fields)
• Added ObjectTreeRenderer, a shared expandable tree renderer used by both ObjectFormatter and CollectionFormatter
• Tree rendering enforces depth and collection limits with a 512KB max output cap to prevent oversized output for complex types
• CollectionFormatter now includes public instance fields alongside properties in table columns

New: User Preferences Persistence

• Disabled extension state and theme CSS snapshot are now saved and restored across sessions
• Blazor Server persists preferences via localStorage; VS Code extension uses globalState
• Theme CSS is injected early on page load for faster initial theme application, eliminating flash of unstyled content

Bug Fixes

• Extension disable/enable no longer leaves stale layouts in the toggle cycle. Scaffold.RefreshSubsystems() is now triggered by OnExtensionStatusChanged (previously only fired on OnExtensionLoaded), so the LayoutManager, ThemeEngine, and SettingsManager reflect the current enabled set at runtime.
• LayoutManager falls back gracefully. When the active layout is disabled, the manager automatically selects the first non-custom-renderer layout (e.g. Notebook) instead of leaving the active layout as null.
• VS Code host notifies on extension status changes. HostSession now fires extension/changed notifications on OnExtensionStatusChanged, so the WASM client refreshes its cached extension, layout, and theme lists.
• LayoutHandler returns enabled-only layouts. HandleGetLayouts now queries ExtensionHost.GetLayouts() instead of the stale LayoutManager.AvailableLayouts snapshot.
• EnsureDefaults uses enabled layouts. Both NotebookService and ServerNotebookService now query ExtensionHost.GetLayouts() when selecting a default layout at startup.
• Monaco editors no longer eat scroll events. Added alwaysConsumeMouseWheel: false to the Monaco scrollbar options in both Blazor Shared and Blazor Server interop files, so wheel events propagate to the notebook scroll container when the editor has nothing to scroll.
• Improved error messages for disabled magic commands. The execution pipeline now reports a clear error when a magic command belongs to a disabled extension rather than showing a generic "unknown command" message.

Layout and UI

• Removed the fixed max-width: 960px and auto horizontal margin from .verso-cell-list, allowing the cell list to use full available width for improved responsiveness

verso-v1.0.7

Feature release adding a PowerShell kernel, a Presentation layout for distraction-free output viewing, .NET 10 multi-targeting, and several editor and execution improvements.

PowerShell Kernel

• Full PowerShell kernel with code execution, tab completions, diagnostics, and hover info
• Runspace management with automatic cleanup and configurable execution policies
• Variable sharing between PowerShell and other kernels via VariableBridge
• Completion type mapping from PowerShell CommandCompletion to Verso completion kinds
• Sample notebook (sample-powershell.verso) included
• Packaged as a separate NuGet (Verso.PowerShell) with CI build and release workflow support

Presentation Layout

• New built-in layout for viewing notebook output without editing UI
• Shows only cell outputs in a clean linear flow with no toolbar, editor, gutter, or cell selection mechanics
• Interactive outputs (paginated tables, buttons, links) work naturally because no click handler intercepts for cell selection
• Cells with no outputs are hidden automatically
• Switching to Presentation layout triggers "Run All" so outputs are up to date
• Follows the same ILayoutEngine pattern as Notebook and Dashboard, with RequiresCustomRenderer = true routing to a dedicated PresentationView.razor component

.NET 10 Support

• All projects multi-target net9.0 and net10.0
• CI and release workflows updated to install .NET 10 preview SDK alongside .NET 9
• VS Code extension README updated to reflect supported frameworks

Editor Improvements

• Using directives now persist across C# cell executions, so adding using System.Linq; in one cell makes it available in subsequent cells without repeating the directive
• Insert-cell buttons between cells now have a 500ms hover delay to prevent accidental reveals when moving the mouse through the notebook
• Cell toolbar z-index simplified to a single CSS rule, fixing IntelliSense popups rendering behind the toolbar

VS Code Extension

• Blazor editor provider registers .verso file association on activation
• PowerShell language ID wired into the custom editor for syntax detection

verso-v1.0.6

Feature release adding a Python kernel, per-cell language selection, eager kernel warm-up for instant IntelliSense, a cell interaction API, and several execution and tooling improvements.

Python Kernel

• Full Python kernel powered by pythonnet, with code execution, completions, diagnostics, and hover info via Jedi
• Virtual environment support with automatic venv overlay, #!pip magic command, and package installation that skips already-installed packages
• Matplotlib plot capture renders inline as HTML images
• Cross-platform Python discovery with enhanced Windows detection (registry, py launcher, common install paths)
• Sample notebook (sample-python.verso) included

Per-Cell Language Selector

• Code cells now show a language dropdown in the toolbar, allowing you to switch a cell's kernel language without deleting and re-creating the cell
• Hover-reveal design: at rest the label looks the same as before; on hover it reveals a background highlight and chevron; clicking opens a popup with all registered kernels
• Works in both Blazor Server and the VS Code extension
• Language changes in VS Code correctly mark the document as dirty
• Changing the default kernel in the Metadata panel now propagates to the host, so new cells use the updated default in both Blazor Server and VS Code

Eager Kernel Warm-Up

• Kernels are now initialized in the background as soon as a notebook is opened, based on the languages present in its cells and the default kernel
• Switching a cell to a new language also triggers background initialization of that kernel
• IntelliSense handlers ensure the kernel is initialized before returning results, so completions, hover, and diagnostics work immediately rather than requiring a cell execution first
• Initialization is thread-safe and deduplicated using a concurrent task cache

Cell Interaction API

• New ICellInteractionHandler interface lets extensions respond to user interactions originating from rendered cell output (button clicks, link navigation, etc.)
• CellInteractionContext carries the cell ID, region, interaction type, and payload
• IVersoContext.UpdateOutputAsync enables extensions to patch cell output in place without re-executing the cell
• Full wiring across Blazor Server, WASM, and the VS Code host

Execution and Toolbar Improvements

• "Run All" now executes all cell types, not just code cells
• Toolbar gains an OnInterceptAction hook so page-level logic can intercept and customize toolbar actions before they execute
• F# kernel adds --multiemit+ to default options for better incremental compilation

verso-v1.0.5

Feature release adding a cell interaction API for bidirectional communication between rendered output and extensions, .dib (Polyglot Notebook) import support, session recovery with autosave, smarter extension assembly scanning, and variable/event handling improvements.

Cell Interaction API

• New ICellInteractionHandler interface lets extensions respond to user interactions originating from rendered cell output (e.g. button clicks, link navigation)
• CellInteractionContext model carries the cell ID, CellRegion, interaction type, and payload so handlers have full context
• IVersoContext.UpdateOutputAsync enables extensions to patch cell output in place without re-executing the cell
• Host-to-client wiring via InteractionHandler, protocol method names, and DTOs; Blazor services (Server and WASM) raise OnOutputUpdated events and apply output patches
• ExtensionHost registers and resolves interaction handlers by extension
• Full test coverage including FakeCellInteractionHandler, handler tests, and interface contract tests

.dib (Polyglot Notebook) Import

• Import-only support for Polyglot Notebook (.dib) files via the new DibSerializer
• Parses #!meta blocks and magic directives, maps languages and directives to Verso cell types, and produces a NotebookModel
• .dib registered as a recognized notebook file type in the VS Code extension
• Jupyter import post-processors updated to accept formatId/filePath for .dib compatibility

Session Recovery and Autosave

• Notebooks are auto-saved to sessionStorage every 30 seconds so unsaved work survives disconnects and browser reloads
• On reconnect or page load, the recover query parameter triggers automatic restoration from the saved file path or stored content
• Blazor reconnection UX improved: tuned retry timing, reconnect overlay, and visibility-change reload when disconnected
• Recovery state is cleared on normal new/open/save operations to prevent stale restores

Extension Assembly Scanning

• Auto-discovery now filters co-located assemblies by checking for a Verso.Abstractions reference instead of globbing Verso.*.dll
• Skips already-scanned, test, and resource assemblies to avoid redundant loading
• Invalid extension types are silently skipped during discovery instead of throwing, improving resilience when third-party DLLs are present

Variable Explorer and Event Handling

• New INotebookService.RefreshVariablesAsync API lets the UI request an explicit variable refresh from the host
• Variable Explorer Refresh button wired to trigger a host round-trip; errors are surfaced in the panel
• Variables and extension status changes now use event subscriptions (OnVariablesChanged, OnExtensionStatusChanged) with proper IDisposable cleanup
• Safe refresh wrapper (RefreshVariablesSafeAsync) called automatically after executions, cell actions, initialization, and notification handling

verso-v1.0.4

Feature release adding the #!extension magic command for dynamic extension loading, a user-consent flow for remote extension packages, support for multiple magic commands per cell, and several VS Code stability fixes.

#!extension Magic Command

• New #!extension magic command for loading Verso extensions at runtime
• NuGet packages: #!extension PackageId [Version] resolves the package, prompts for user consent, loads all [VersoExtension] types, and stores assembly paths for kernel references
• Local DLLs: #!extension ./path/to/MyExtension.dll loads extensions directly from a local assembly file without a consent dialog, with paths resolved relative to the notebook directory
• Cross-platform path normalization: backslash paths authored on Windows resolve correctly on macOS/Linux
• Idempotent: re-running a cell that already loaded an extension skips with a message instead of failing
• Developer-friendly error messages for file not found, invalid assemblies, and zero-extension DLLs

Extension Consent Flow

• User-consent dialog shown before loading remote NuGet extension packages
• ExtensionConsentDialog Blazor component with styled modal (shared across Server and WASM)
• Pre-scan on notebook open: #!extension directives are detected and consent is requested proactively so packages are pre-approved before cell execution
• Pre-scan on Jupyter import: imported notebooks containing #!extension directives trigger consent during the import flow
• Approved packages are tracked per session so subsequent cells referencing the same package skip the consent prompt
• ExtensionHost.ConsentHandler delegate enables host-agnostic consent routing (Blazor Server shows inline, VS Code WASM routes through JSON-RPC)

Multiple Magic Commands per Cell

• Cells can now contain multiple consecutive magic commands (e.g. two #!extension lines, or #!nuget followed by #!time)
• Execution pipeline loops through magic commands until the first non-magic line, then hands remaining code to the kernel
• Each command executes in order with its own context; SuppressExecution from any command stops the cell immediately

Dynamic Extension Registration

• Subsystems (LayoutManager, ThemeEngine, SettingsManager) now refresh when extensions are loaded at runtime via ExtensionHost.OnExtensionLoaded
• Dynamically loaded layouts, themes, and settings appear in the UI immediately without a restart or reload
• Scaffold.RefreshSubsystems() preserves the active layout and theme selection during refresh

VS Code Extension Fixes

• Deadlock fix: Concurrent stdin reading via Channel<T> prevents the host process from locking up when extension consent requests block the main loop
• Extension change notifications: Host sends extension/changed notification to the webview when extensions load dynamically; WASM client refreshes cached extension, layout, and theme lists
• Modal styling: Extension consent dialog CSS included in the shared Blazor project so it renders correctly in both Server and WASM
• Content Security Policy: Relaxed CSP to allow https: sources in script, style, font, image, and connect directives, enabling HTML cells to load external libraries (e.g. charting, visualization)
• UTF-8 console encoding: Force Console.InputEncoding and Console.OutputEncoding to UTF-8 to prevent corruption of non-ASCII JSON-RPC messages on Windows

verso-v1.0.3

Feature release adding built-in HTML and Mermaid cell types, a formatter pipeline for kernel return values, native Save As, multi-session host support, and a streamlined VS Code extension that uses Blazor WebAssembly as the sole editor.

HTML and Mermaid Cell Types

• Built-in HTML and Mermaid cell types with dedicated kernels, renderers, and cell type registrations
• @variable substitution in both cell types with IntelliSense completions, diagnostics for unresolved references, and hover info
• @@ escape syntax for literal @ characters
• Mermaid diagrams render natively across Blazor Server, Blazor WASM in VS Code, and dashboard layouts via mermaid-interop.js
• Shared VariableSubstitution utility used by both kernels

Formatter Pipeline

• C# and F# kernels now route return values through the extension host's IDataFormatter pipeline (ordered by priority) before falling back to ToString() or FSharpValueFormatter
• Direct CellOutput instances are detected and passed through; duck-typed CellOutput objects from other assembly contexts are extracted via reflection

Save As Dialog

• Native OS file picker via the File System Access API with a modal fallback for unsupported browsers
• GetSerializedContentAsync added to INotebookService so the UI can serialize and write to a chosen file handle

Multi-Session Host

• HostSession refactored into NotebookSession with NotebookId tracking
• All host handlers updated to accept NotebookSession for multi-notebook support
• notebook/open returns a NotebookId; notebook/close added for session cleanup

Dashboard Layout Fix

• Saved grid positions from the .verso file are now restored when opening a notebook in VS Code, fixing a bug where dashboard cells ignored their saved positions in the WASM path

Cell Collapse Behavior

• Empty-source cells are no longer shown in preview mode
• Collapse logic now recognizes HTML and Mermaid as rendering cell types alongside Markdown
• Server-side collapse checks directly-registered renderers and falls back to cell-type renderer settings

VS Code Extension

• Removed native notebook controller, serializer, mermaid renderer, language providers, tree view providers, dashboard panel, toolbar actions, and theme mapper (14 files)
• Blazor WebAssembly is now the default and only editor
• extension.ts reduced from ~420 lines to ~95 lines
• Removed all notebooks, notebookRenderer, viewsContainers, views, commands, menus, and keybindings contributions from package.json

Project

• README rewritten with story-driven structure and architecture overview
• NuGet, GitHub Release, and CI status badges added to README
• GitHub bug report issue template with structured fields for reproduction, component, front-end, versions, and severity
• Blank issues disabled in favor of Discussions for questions

verso-v1.0.2

Bug-fix release addressing new-file workflows and Blazor WebAssembly editor parity.

New File Handling

• Empty or new .verso files now initialize default metadata (defaultKernel, activeLayout) on the host so the engine, metadata panel, and new cells work correctly from the start
• Default code cell created for blank files is registered with the host and receives a versoId, enabling immediate execution
• Scaffold.AddCell and InsertCell resolve the notebook's default kernel when no language is specified, so cells added via the UI always receive a language

VS Code Extension

• Cells added via the native "+" button are automatically registered with the host and assigned a versoId
• Supported languages on the notebook controller are populated dynamically from the host via notebook/getLanguages instead of being undefined
• Blazor WebAssembly custom editor upgraded from read-only to editable provider, the tab now shows a dirty indicator on unsaved changes and Ctrl/Cmd+S saves correctly

Blazor WebAssembly Editor

• Cell source is now flushed to the host before execution, fixing a debounce timing issue where newly typed code could be missed
• Host now emits variable/changed notifications after cell execution and kernel restart, so the Variables panel updates in real time
• Mutation tracking wired through the bridge, edits made in the WASM editor mark the document as modified in VS Code