dotnet-websharper/core

This system is a compiler and web framework that translates F\# and C\# code into JavaScript, enabling the development of client-side web applications and server-side APIs. It provides a comprehensive runtime library for browser interop, DOM manipulation, and JSON serialization, alongside a Sitelets framework for defining web routes and content. The architecture supports modern ASP.NET Core hosting, static site generation, and integrates with build tools like Vite and esbuild for asset management.

23 changes.

This period focused on stripping out legacy WebSharper 2.4 components, including old HTML, JavaScript, and WebForms integration modules, to reduce technical debt. The project simultaneously modernized its infrastructure by migrating the interface generator to Cecil, updating build systems, and targeting newer .NET versions.

28 changes.

The WebSharper compiler underwent a major architectural restructuring, introducing a formal JavaScript AST, modularizing core components, and adding a new C\# backend via Roslyn. This period also established foundational infrastructure for the Sitelets web framework, typed JSON serialization, and comprehensive TypeScript interop through the Interface Generator.

24 changes.

This period focused on integrating WebSharper with ASP.NET Core and modernizing the compilation infrastructure through a persistent F\# service and C\# Roslyn analyzer. Significant features included offline static site generation, MSBuild task enhancements, and improved assembly resolution for .NET Core environments. The work was heavily supported by extensive test coverage across C\#, F\#, and SPA scenarios to validate these new capabilities.

6 changes.

This period focused on expanding the WebSharper ecosystem by introducing a new standard library with remoting and JavaScript interop capabilities, alongside comprehensive proxies for core F\# types. Development also included creating an internal assembly inspection tool and establishing robust testing scaffolding for TypeScript integration and compiler validation.

The WebSharper.FSharp.Service now includes structured logging via NLog, writing detailed trace-level logs (including timestamps, log levels, and exceptions) to a file named websharper.log in the working directory. Additionally, the service is configured to enable the .NET GC server mode for improved performance during compilation tasks.

src/compiler/WebSharper.FSharp.Service · high confidence

This change introduces the \WebSharper.AspNetCore\ package, providing the core middleware and extension methods to host WebSharper applications on ASP.NET Core. It adds \UseWebSharper\ and \UseWebSharperRemoting\ for pipeline setup, \ContentExtensions\ to handle requests and convert WebSharper content to \IActionResult\, and a \ScriptRedirect\ middleware that proxies JavaScript requests to a Vite dev server for localhost debugging. The implementation includes DI service interfaces (\IWebSharperInitializationService\, \IWebSharperSiteletService\, etc.) and context handling to bridge WebSharper's request model with ASP.NET Core's \HttpContext\.

src/sitelets/WebSharper.AspNetCore · high confidence

The repository now includes foundational configuration and documentation files to support development and contribution. This adds \.gitattributes\ to enforce LF line endings for shell scripts, a comprehensive \.gitignore\ to exclude build artifacts and IDE files, and a \.gitpod.yml\ to configure the Gitpod cloud environment for .NET 6. It also introduces \AGENTS.md\ with detailed instructions for AI agent setup (Serena, MCP servers) and build workflows, \CONTRIBUTING.md\ with guidelines for building, testing, and contributing, \LICENSE.md\ for the Apache 2.0 license, \README.md\ with project overview and quick start instructions, and \WebSharper.Compiler.sln\ to define the compiler solution structure.

(repo-wide) · high confidence

WebSharper now includes a new C\# compiler backend located in src/compiler/WebSharper.Compiler.CSharp. This addition enables the compilation of C\# projects to JavaScript, extending the framework's language support beyond F\#. The implementation leverages the Roslyn API to parse C\# source code and translate it into WebSharper's internal AST for further processing.

src/compiler/WebSharper.Compiler.CSharp · high confidence

The WebSharper.FSharp compiler now supports a background compilation service (Booster) to improve build performance. This change introduces a client-server architecture where the compiler communicates with a persistent 'wsfscservice' process via named pipes. The implementation includes platform-specific handling for Windows and Linux/macOS, ensuring compatibility by adjusting pipe naming conventions and using appropriate launch scripts (wsfscservice\_start.cmd/sh). If the service is unavailable or fails to connect, the compiler gracefully falls back to standalone compilation. Additionally, an App.config file enables GC server mode for the compiler process.

src/compiler/WebSharper.FSharp · high confidence

Adds a new Roslyn-based analyzer for C\# projects that integrates WebSharper compilation directly into the IDE. The analyzer detects WebSharper-specific errors and warnings during coding, leveraging cached metadata and assembly resolution to provide immediate feedback without triggering full compilations unless necessary.

src/compiler/WebSharper.CSharp.Analyzer · high confidence

Added the HtmlCommand and Output modules in the WebSharper.Sitelets.Offline library to enable generating static offline pages from sitelets. The HtmlCommand acts as an executable plugin that loads the sitelet assembly, optionally downloads external resources, and invokes the Output module to write the rendered site content, JavaScript, CSS, and source maps to a specified output directory. This change also introduces a dependency on Mono.Cecil for reading embedded resources from assemblies.

src/sitelets/WebSharper.Sitelets.Offline · high confidence

The WebSharper compiler now includes a formal definition for the JavaScript Abstract Syntax Tree (AST) within the \WebSharper.Core.JavaScript.Syntax\ module. This change introduces specific type representations for JavaScript language constructs, including unary, binary, and postfix operators, source position tracking, literals, identifiers with support for generics and type annotations, and expression nodes such as arrow functions (\Lambda\ with \isArrow\ flag), class expressions, and verbatim JavaScript injection. This provides the foundational data structures required for the compiler to parse and generate JavaScript code accurately.

WebSharper.Core.JavaScript · high confidence

This change introduces the new WebSharper.Web library, providing the core runtime infrastructure for web applications. It includes a comprehensive client-side JSON serialization and deserialization engine (ClientSideJson) supporting records, unions, collections, and optional fields, alongside a TypedJson proxy for seamless F\#-to-JavaScript data exchange. The module also establishes the web request Context, manages user sessions via IUserSession, and implements secure Remote Procedure Call (RPC) handling with configurable CORS origins and CSRF protection in RpcModule.

src/sitelets/WebSharper.Web · high confidence

This change introduces the foundational types for the WebSharper Sitelets framework, including the \Application\ module for creating single-page and multi-page applications, the \Content\<'Endpoint\>\ type for representing server responses, and the \Context\<'Action\>\ type for providing runtime services like linking and request data. It also adds the \Router\ and \InferredRouter\ modules for handling URL routing, the \Controller\ type for mapping actions to content, and the \Page\ type for defining HTML page structures. Additionally, it includes the \Http\ module for HTTP request/response abstractions and the \Loading\ module for discovering sitelets via attributes.

src/sitelets/WebSharper.Sitelets · high confidence

A new standalone service executable (WebSharper.FSharp.Service) is introduced to handle F\# compilation via named pipes, enabling detached server operation and improved cross-platform compatibility on Linux/macOS. This change shifts compilation from a local process model to a persistent service architecture, where the service serializes requests using a MailboxProcessor, caches metadata in memory, and communicates with clients through JSON-serialized messages over named pipes.

wsfscservice · high confidence

A new C\# compiler tool (wscsc) is introduced, providing both Windows (wscsc.cmd) and Unix (wscsc.sh) entry points that invoke the compiler via dotnet. The tool includes a .NET Framework configuration (App.config) enabling server GC and batch latency mode, a PowerShell script (runngen.ps1) for native image generation, and references to FSharp.Core.

src/compiler/WebSharper.CSharp · high confidence

The WebSharper.MSBuild.CSharp package now includes a new WebSharperTask class that handles the compilation process by generating command-line arguments for the wscsc.exe tool. This task supports various configuration options including dead code elimination, JavaScript output settings, source maps, TypeScript declarations, and resource embedding, allowing users to control the build behavior through MSBuild properties.

src/compiler/WebSharper.MSBuild.CSharp · high confidence

The WebSharper MSBuild integration now includes two new tasks: \ReorderCompileItemsTask\, which reorders compilation items to ensure generated files follow their dependencies, and \WebSharperTask\, which invokes the WebSharper compiler (\wsfsc.exe\) with support for configuration options such as dead code elimination, source maps, TypeScript output, and standalone builds. These tasks enable automatic handling of compile item ordering and direct integration of WebSharper-specific compiler flags during the build process.

src/compiler/WebSharper.MSBuild.FSharp · high confidence

A new project, WebSharper.TypeScriptParser, has been added to the compiler suite. It provides a command-line utility that takes a TypeScript declaration file (.d.ts) as input and outputs a structured JSON representation of its types, interfaces, modules, and exports. This tool enables the consumption of TypeScript type definitions in a format suitable for further processing or integration within the WebSharper ecosystem.

src/compiler/WebSharper.TypeScriptParser · high confidence

The WebSharper.JavaScript package now includes a comprehensive set of type definitions for JavaScript APIs, enabling strongly-typed access to the language and browser environment. The library introduces bindings for ECMA-262 core objects (such as Object, String, RegExp, and BigInt), the Document Object Model (DOM) including element manipulation and event handling, and HTML5 features like TypedArrays, MediaStream, and Canvas. These definitions are exposed via the WebSharper.InterfaceGenerator to allow seamless interop with JavaScript from F\# code.

src/stdlib/WebSharper.JavaScript · high confidence

The WebSharper compiler now exposes a structured command-line interface for managing build tasks. This change introduces dedicated commands for unpacking assemblies (UnpackCommand) and generating HTML output (HtmlCommand), along with support for downloading remote resources (DownloadResources). Users can now control specific behaviors via command-line flags, such as enabling source map unpacking (-sm), TypeScript/TypeScript Declaration unpacking (-ts, -dts), and resource downloading (-download). The interface also supports configuration for build modes (Debug/Release), output directories, and reference assembly paths, providing a more granular and scriptable build experience.

src/compiler/WebSharper.Compiler/commands · high confidence

The compiler now exposes a new public API in the \WebSharper.Compiler\ namespace to handle assembly inspection and loading. This includes an \Assembly\ type that allows users to retrieve embedded JavaScript, TypeScript, source maps, and source files, as well as non-script content. A \Loader\ type has been added to load assemblies from files or raw bytes, with support for reading debug symbols (\.pdb\ and \.mdb\) and caching loaded assemblies. Additionally, \EmbeddedFile\ and \Symbols\ types provide structured access to resource content and symbol data.

src/compiler/WebSharper.Compiler/api · high confidence

An internal desktop application (WebSharper.DllBrowser) has been added to the compiler source tree, providing a WPF interface for developers to inspect .NET assemblies used by WebSharper. Users can drag and drop DLL files into the window to view a hierarchical tree of metadata, including classes, interfaces, dependency graphs, macros, quotations, and prebundles. The tool highlights nodes matching a text filter and displays detailed implementation information (such as base classes, methods, and compiled forms) in a read-only pane, aiding in debugging and understanding compiler internals.

src/compiler/WebSharper.DllBrowser · high confidence

A new internal module, WebSharper.Sitelets.Offline.Output, has been introduced to handle the generation of HTML for offline sitelets. This module exposes a configuration record (Config) that allows users to specify actions, HTML generation options, the sitelet itself, and flags to unpack source maps, TypeScript, and TypeScript declarations. It also provides a WriteSite function that takes this configuration and an assembly resolver to asynchronously produce the site's HTML content.

WebSharper.Sitelets.Offline · high confidence

The WebSharper.StdLib.Proxies module now includes comprehensive JavaScript proxies for core F\# types and modules, including Array, Array2D, Async, BigInt, Char, Console, and Concurrency primitives. This adds support for standard operations such as array sorting, binary search, and blitting; two-dimensional array manipulation; asynchronous workflow execution and cancellation; arbitrary-precision integer arithmetic; character classification; and console output, enabling these F\# constructs to compile and run correctly in JavaScript environments.

src/stdlib/WebSharper.StdLib.Proxies · high confidence

The WebSharper Interface Generator (WIG) now includes a foundational code model and TypeScript import infrastructure. The new CodeModel module defines the internal representation for interfaces, classes, methods, and properties, introducing support for abstract, virtual, and override method kinds, as well as obsolete status and warning attributes. The Pattern module provides helper functions for generating configuration objects with required, optional, and obsolete fields. Additionally, the TypeScriptImport module introduces a structured model for TypeScript types (including unions, intersections, and generics) and statements, enabling the generation of .d.ts files. These changes establish the internal DSL and output capabilities for WIG.

WebSharper.InterfaceGenerator · high confidence

The \WebSharper.StdLib\ package has been introduced, consolidating core runtime support. It provides JavaScript interop utilities (including operators, type conversions, and the \JS\ module), a \Promise\ module for async/await patterns, and a new \Remoting\ module that exposes an \IAjaxProvider\ and \AjaxRemotingProvider\ for client-server RPC. The remoting API now includes a \UseHttps\ helper and supports \Task\-based remote calls, while the library also adds concurrency primitives and HTML control interfaces.

src/stdlib/WebSharper.StdLib · high confidence

The entire IntelliFactory.JavaScript library source code has been removed from the repository. This includes the project file, core modules (Core, Syntax, Packager, Writer, Identifier, Preferences, Annotations), and the embedded JavaScript runtime (Runtime.js). This change eliminates the ability to build or use this specific JavaScript code-generation component.

IntelliFactory.JavaScript · high confidence

The entire IntelliFactory.WebSharper.Html module has been removed from the product. This deletion eliminates the legacy client-side HTML abstraction layer, including the jQuery-based DOM manipulation provider, HTML5 and deprecated tag builders, attribute helpers, event handling interfaces, and the control activation system that previously managed pagelet rendering and DOM replacement.

IntelliFactory.WebSharper.Html · high confidence

The IntelliFactory.WebSharper.JQuery package no longer bundles the jQuery 1.6.1 library files (jquery-1.6.1.js and jquery-1.6.1.min.js) or the associated C\# resource markers and F\# type definitions. Users relying on this package to provide the jQuery script will need to supply their own version of the library, as the internal resource provider has been removed.

IntelliFactory.WebSharper.JQuery · high confidence

The \IntelliFactory.WebSharper.Web\ library has removed its legacy ASP.NET WebForms integration layer, specifically deleting the \Control\, \RpcModule\, \ScriptManager\, and \Shared\ modules. This eliminates the ability to use WebSharper as a server-side ASP.NET control or HTTP module, requiring users to adopt the modern client-side rendering approach instead.

IntelliFactory.WebSharper.Web · high confidence

The WebSharperTests project has removed its legacy ASP.NET WebForms test harness, including Global.asax, Web.config, and the Tests.aspx and WebTests.aspx pages. This eliminates the old HttpApplication initialization, QUnit-based client-side test runner, and WebSharper-specific HTTP modules (RpcModule) that previously hosted these tests, indicating a shift away from the traditional ASP.NET WebForms hosting model for this test suite.

WebSharperTests · high confidence

The \IntelliFactory.WebSharper/Proxy\ directory has been cleared of obsolete proxy files (including \Array.fs\, \Async.fs\, \DateTime.fs\, \List.fs\, and others) that were explicitly targeting \FSharp.Core, Version=2.0.0.0\. This cleanup removes the legacy JavaScript bindings for these types, aligning the library with newer F\# core versions and reducing the codebase footprint.

IntelliFactory.WebSharper/Proxy · high confidence

The \IntelliFactory.Html\ library has been removed from the product. This deletion eliminates the previous HTML generation API, including the \Attributes\, \Control\, \Html\, and \Tags\ modules that provided HTML5 support, deprecated HTML4 elements, and server-side control integration.

IntelliFactory.Html · high confidence

The \IntelliFactory.WebSharper\ namespace has been cleaned up by removing several internal and legacy implementation files, including \Concurrency.fs\, \Enumerable.fs\, \Enumerator.fs\, \JavaScript.fs\, \Json.fs\, \Macro.fs\, \Pervasives.fs\, \Remoting.fs\, and \Resources.fs\. This change eliminates the custom concurrency scheduler, JSON parsing/serialization, macro definitions, and remoting providers that were previously bundled in this location, likely shifting these responsibilities to the \IntelliFactory.WebSharper.Core\ library or a newer architecture.

IntelliFactory.WebSharper · high confidence

The \IntelliFactory.WebSharper.Compiler\ module has removed a significant set of internal implementation files, including \Adapter\, \Analyzer\, \Assembler\, \Compiler\, \Corrector\, \FrontEnd\, \Graphs\, and \Inlining\ (along with their corresponding \.fsi\ interface files). This deletion indicates a structural refactoring or migration away from the previous compiler architecture within this component, removing the code responsible for adapting Mono.Cecil representations, analyzing assembly dependencies, assembling JavaScript packages, and handling inline definitions.

IntelliFactory.WebSharper.Compiler, IntelliFactory.WebSharper.Core · high confidence

The legacy \Definition.fs\ and \Main.fs\ files, which contained the initial WebSharper 2.4 code for generating DOM interfaces (such as \EventTarget\, \Document\, and various enumerations) via the old Interface Generator, have been removed. This change eliminates the old compilation pipeline and interface definitions in favor of the updated implementation.

IntelliFactory.WebSharper.Dom · high confidence

The \IntelliFactory.WebSharper.Testing\ module has been removed, eliminating legacy testing utilities that were part of the WebSharper 2.4 codebase. This includes the deletion of assertion helpers (\Assert.fs\), common testing utilities and syntactic sugar like \Test\ and \Section\ (\Pervasives.fs\), and random test case generators (\Random.fs\). Users relying on these specific client-side testing constructs will need to migrate to the current testing framework.

IntelliFactory.WebSharper.Testing · high confidence

The WebSharper command-line compiler and its associated utility modules have been removed. This change deletes the \Arguments.fs\ (command-line option parser), \Options.fs\ (CLI argument definitions), \Loader.fs\ (assembly loading), \DependencyReporter.fs\ (dependency graph reporting), \ProxyReporter.fs\ (proxy report generation), and \Program.fs\ (main entry point) files. It also removes the \WebSharper.exe.config\ file, which previously configured the .NET runtime for the compiler executable. Users relying on the standalone \WebSharper.exe\ tool for compiling F\# assemblies to JavaScript or managing resources will no longer have access to these legacy command-line capabilities.

WebSharper · high confidence

The \build/vs11/WebSharper.sln\ file has been deleted, removing the Visual Studio 11 solution configuration that previously defined the build structure for the WebSharper projects. This change affects the development workflow by eliminating the specific VS11 solution setup, requiring users to rely on alternative build methods or other solution files for project management.

build/vs11 · high confidence

The \IntelliFactory.WebSharper.Tests\ project has been removed. This change deletes the entire test suite, including test modules for core F\# types and operations such as Array, List, Seq, DateTime, Math, Option, and various operators, effectively eliminating the automated verification of these client-side behaviors.

IntelliFactory.WebSharper.Tests · high confidence

The WebSharper compiler has been restructured by introducing several new internal modules to handle core infrastructure tasks. Abbreviations.fs provides type aliases for standard .NET types to simplify imports. Breaker.fs introduces a monadic structure for managing intermediate code generation, separating pure expressions from imperative statements. Optimizations.fs contains the logic for simplifying generated JavaScript, such as inlining runtime calls and reducing function overhead. Merging.fs implements three-way file merging using DiffPlex to support source control integration. Additionally, new modules for file system operations (FileSystem.fs), path and pattern handling (PathUtility.fs), extra file copying (Extra.fs), error message normalization (ErrorPrinting.fs), and configurable logging (LoggerBase.fs) have been added to support these compilation and build processes.

src/compiler/WebSharper.Compiler · high confidence

The IntelliFactory.WebSharper.InterfaceGenerator tool has replaced its underlying code generation engine. The previous implementation, which relied on \System.CodeDom\ (evidenced by the removal of \CodeDom.fs\ and \Compiler.fs\), has been removed in favor of a new backend using the Cecil library. This architectural change alters how the generator produces interface bindings, moving away from the CodeDom-based compilation pipeline to Cecil for more robust assembly manipulation.

IntelliFactory.WebSharper.InterfaceGenerator · high confidence

The JavaScript compiler implementation has been moved from the IntelliFactory.JavaScript namespace to WebSharper.Core.JavaScript. This change includes renaming the module and namespace across the lexer, parser, writer, and identifier utilities, updating the license header from AGPLv3 to Apache 2.0, and introducing new runtime support files (Runtime.js and Runtime.ts) alongside annotation and preference definitions to support the new WebSharper branding and structure.

src/compiler/WebSharper.Core.JavaScript · high confidence

The WebSharper.Compiler project has been reorganized into a new set of modular source files, including AttributeReader, Bundle, Closures, CommandTools, Compilation, CompilationHelpers, CompilationTypes, and FrontEnd. This restructuring introduces dedicated modules for handling WebSharper-specific attributes (such as Proxy, Inline, and Remote), bundling logic with dead-code elimination and source map support, closure analysis for variable scoping, and command-line configuration parsing via WsConfig. The changes also establish new compilation types for tracking not-resolved members and classes, helper functions for purity analysis, and a front-end interface for reading assembly metadata, laying the groundwork for improved compiler modularity and maintainability.

WebSharper.Compiler · high confidence

The WebSharper.Core compiler library has been reorganized under the src/compiler directory and its namespaces and assemblies have been renamed from IntelliFactory.WebSharper.\* to WebSharper.\*. This change includes the introduction of a new Abstract Syntax Tree (AST) module (AST.fs, ASTTypes.fs) defining core types like Literal, Expression, and Id, alongside updated modules for dependency graph management (Graph.fs), interop helpers (Interop.fs), macro and generator interfaces (Macro.fs, Interfaces.fs), and metadata handling (Metadata.fs). The JSON module (Json.fsi) has also been updated with a new Apache 2.0 license and refreshed copyright year.

WebSharper.Core · high confidence

The WebSharper.Core compiler assembly has been restructured into a set of distinct, new source files (ASTHelpers, ASTReflection, AssemblyConventions, Attributes, Constants, FastInvoke, Json, Macros, PathConventions). This change introduces dedicated modules for AST manipulation helpers, .NET type reflection, assembly naming conventions, custom attribute definitions, runtime constants, high-performance reflection invocation, JSON parsing, macro definitions, and resource path handling, laying the groundwork for a more modular compiler architecture.

src/compiler/WebSharper.Core · high confidence

The library now uses a centralized \tags.csv\ file to define HTML tags and attributes, replacing previous ad-hoc or generated definitions. This change introduces consistent metadata for each element, including status (normal, deprecated, or colliding) and keyword classification, ensuring that the generated HTML bindings accurately reflect the current specification and internal naming conventions.

src/htmllib · high confidence

The WebSharper.InterfaceGenerator module has been restructured, moving core reflection logic (Reflection.fs/fsi) from the IntelliFactory.WebSharper.Core namespace into the new WebSharper.InterfaceGenerator namespace. This change includes the addition of a new Util module for code generation helpers and a test script (testTypeScriptImport.fsx) that demonstrates the generator's capability to parse TypeScript definition files (.d.ts) and map them to F\# types, laying the groundwork for improved TypeScript interop.

src/compiler/WebSharper.InterfaceGenerator · medium confidence

The WebSharper.Testing library has been rewritten to integrate with the QUnit testing framework, replacing the previous imperative testing model. This change introduces a new, composable test runner API defined in Pervasives.fs and CSharp.fs, allowing tests to be written using a fluent style with support for synchronous and asynchronous execution. The update includes a new property-based testing module (Random.fs) for generating random test cases, a dedicated C\# test category builder (CSharp.fs) with specific assertion methods like DeepEqual and JsEqual, and an updated resource loader (Resources.fs) that now pulls QUnit version 2.9.2 from the CDN.

src/stdlib/WebSharper.Testing · high confidence

The F\# compiler module has been replaced with a new implementation that introduces a dedicated argument currying optimization pass. This change allows the compiler to detect function-typed arguments that are consistently called with a fixed number of arguments and optimize them into flat function calls, improving runtime performance. The new compiler also includes a comprehensive tail-call analyzer to correctly identify and optimize recursive functions, ensuring that tail-recursive code is translated efficiently to JavaScript without stack overflow risks.

src/compiler/WebSharper.Compiler.FSharp · high confidence

The project has removed its legacy MSBuild-based build system, including the \IntelliFactory.FSharp.targets\, \IntelliFactory.WebSharper.targets\, \IntelliFactory.WebSharper.Web.targets\, and \IntelliFactory.WebSharper.InterfaceGenerator.targets\ files, as well as the \AssemblyInfo.fs\ and \UpdateLicense.fsx\ scripts. This change eliminates the previous mechanism for handling F\# imports, WebSharper compilation, and license updates via MSBuild, indicating a shift to a different build automation approach.

build · high confidence

The tools directory now includes updated paket templates that reflect the migration of the F\# and C\# compilers to .NET 10 (net10.0) and the WebSharper.AspNetCore package to .NET 5.0. The WebSharper.FSharp and WebSharper.CSharp templates now bundle compiler binaries for Windows, Linux (x64 and musl), and macOS (osx-x64) targeting net10.0, replacing previous .NET Core versions. Additionally, the WebSharper.AspNetCore template specifies a net5.0 framework dependency, and the WebSharper.Tests template targets net10.0, ensuring the tooling aligns with the updated runtime requirements.

tools · high confidence

The compiler's assembly resolution logic has been updated to explicitly detect and reject reference assemblies, providing a clear error message when they are encountered instead of failing silently or with a generic error. Additionally, the resolver now supports .NET Core environments by implementing a dedicated resolution strategy for \AssemblyLoadContext\, ensuring assemblies are loaded correctly in both .NET Framework and .NET Core runtimes.

src/compiler/WebSharper.Compiler/assemblyResolution · high confidence

Add F\# WebSharper test project with Vite integration; Added C\# Sitelets and Interop test suites; Added C\# test suite for arithmetic, collections, delegates, and interop; Added F\# and C\# interactive tester scripts for compiler validation; Added F\# compiler integration tests; Added FsEye test infrastructure and assets; Added HTML5 DOM binding tests; Added Sitelets JSON API and integration tests; Added TypeScript test project scaffolding; Added Web test project with ASP.NET Core and esbuild bundling support; Added WebSharper SPA test project; Added WebSharper test website and client-side type serialization tests; Added comprehensive test suite for WebSharper Interface Generator; Added comprehensive test suite for WebSharper.Collections; Added stress testing suite for sitelet endpoints; Added test assembly metadata; Added test assets for WebSharper resource handling; Added test project for wsfscservice; Added test suite for InterfaceGenerator with F\# 5 compatibility; Added test suite for Proxy project generation and configuration; Added tests for C\# static HTML sitelets; Added tests for DCE-enabled library projects; Added tests for JS.Import, StubInterfaces, and CSS module bundling; Added tests for the AppendList data structure; Added unit tests for the C\# analyzer; Expanded test coverage for WebSharper core modules; Initial test suite for WebSharper.Web; Removal of legacy test files; Removal of legacy test suite files; Revived WebSharper.Core.JavaScript.Tests with NUnit and updated licensing.

The WebSharper compiler suite has been updated to target .NET 10.0 for its main executable projects (wscsc, wsfsc, wsfscservice), while core libraries remain on netstandard2.0. A new WebSharper.CSharp.Analyzer project has been added to support C\# analysis, and the F\# compiler service now references FSharp.Compiler.Service 43.12.204. Additionally, the DllBrowser internal tool targets net9.0-windows, and the TypeScript parser dependency is set to version 4.9.4.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 44 → 45 (+1.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 24 → 32 (+7.6)
• Architecture 57 → 57 (+0.4)
• Maturity 59 → 60 (+0.3)
• Readiness 58 → 56 (-2.2)
• Security 86 → 71 (-15.5)

• Dependency hygiene not measured — no packages were read
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High vulnerability: [GHSA redacted] (package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No direct assertions: Exception (tests/WebSharper.CSharp.Tests/Object.cs)
• No direct assertions: Try (tests/WebSharper.CSharp.Tests/Syntax.cs)
• No exposed public API
• NoWarnInCsproj (.paket/Paket.Restore.targets)
• NoWarnInCsproj (.paket/Paket.Restore.targets)
• NoWarnInCsproj (.paket/Paket.Restore.targets)
• NoWarnInCsproj (.paket/Paket.Restore.targets)
• Off-boarding risk: anonymized user #1
• Test reliability not measured — analyzer environment
• complexity unreadable for .cs, .fs — churn × complexity hotspots could not be measured
• redundant comment (tests/Web.TypeScript/Startup.cs)
• redundant comment (tests/WebSharper.CSharp.Interop.Tests/Properties/AssemblyInfo.cs)
• redundant comment (tests/WebSharper.CSharp.Tests/Tests.cs)

• Documentation: no architecture or design documentation (docs/WebApi.md)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (src/compiler/WebSharper.Compiler/Compilation.fs)
• Duplicated block (10 lines × 2) (src/compiler/WebSharper.Compiler/CompilationHelpers.fs)
• Duplicated block (10 lines × 2) (src/compiler/WebSharper.Compiler/CompilationTypes.fs)
• Duplicated block (10 lines × 2) (src/compiler/WebSharper.Compiler/Translator.fs)
• Duplicated block (10 lines × 2) (src/compiler/WebSharper.Core/Binary.fs)
• Duplicated block (10 lines × 2) (src/compiler/WebSharper.Core/Macros.fs)
• Duplicated block (11 lines × 2) (src/compiler/WebSharper.Compiler/Translator.fs)
• Duplicated block (11 lines × 2) (src/compiler/WebSharper.Compiler/Verifier.fs)
• Duplicated block (11 lines × 2) (src/compiler/WebSharper.Core/Macros.fs)
• Duplicated block (11 lines × 2) (src/compiler/WebSharper.Core/Macros.fs)
• Duplicated block (11–12 lines × 2) (src/compiler/WebSharper.Compiler/WIGCompile.fs)
• Duplicated block (12 lines × 2) (src/compiler/WebSharper.Compiler/Verifier.fs)
• Duplicated block (12 lines × 2) (src/compiler/WebSharper.Core/Graph.fs)
• Duplicated block (12 lines × 2) (src/compiler/WebSharper.Core/Macros.fs)
• Duplicated block (12 lines × 2) (src/compiler/WebSharper.InterfaceGenerator/CodeModel.fs)
• Duplicated block (12–13 lines × 3) (src/compiler/WebSharper.Compiler/JavaScriptPackager.fs)
• Duplicated block (13 lines × 2) (src/compiler/WebSharper.Compiler/JavaScriptPackager.fs)
• Duplicated block (14 lines × 2) (src/compiler/WebSharper.Core/Json.fs)
• …and 73 more

• 2 commits — 1 feature/other, 1 fixes

• (repo) — 1 commit
• src/compiler — 1 commit

• fix: Fix #1597 - Generate ws.metadata.runtime for microservice project type
• change: Version 10.1.6.677

• Containers 0 added · 0 removed · contexts 6 added · 0 removed · edges 6 added · 0 removed

• WebSharper.Compiler
• WebSharper.Core
• WebSharper.Core.JavaScript
• WebSharper.InterfaceGenerator
• WebSharper.Sitelets.Offline
• wsfscservice

• WebSharper.Compiler → WebSharper.Core (coupling)
• WebSharper.Compiler → WebSharper.Core.JavaScript (coupling)
• WebSharper.Compiler → WebSharper.InterfaceGenerator (coupling)
• WebSharper.Core → WebSharper.Core.JavaScript
• WebSharper.Sitelets.Offline → WebSharper.Compiler (coupling)
• WebSharper.Sitelets.Offline → WebSharper.Core

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

dotnet-websharper/core was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.