MagnusOpera/FScript

FScript is a scripting language and runtime environment that provides a type-safe, interactive engine for parsing, type-checking, and executing code. It supports multiple host platforms, including .NET and JavaScript, and offers robust IDE integration via a Language Server Protocol implementation. The system enables deep interoperability with host applications through a strict type provider and a structured API for invoking exported functions.

The F\# script language server now provides a default \Env\ binding during editor analysis, enabling better type inference and autocompletion for scripts. This is achieved by introducing a new \InteropServices\ module that resolves root directories from source paths and injects a prelude defining \Env\ as an \Environment\ record. The module also exposes functions to infer program types using external functions (externs) registered for the resolved context, laying the groundwork for C\# interop support.

src/FScript.CSharpInterop · high confidence

This change introduces a new JavaScript runtime implementation for FScript, built using Fable. It provides the core library functions necessary to parse, type-check, and evaluate FScript programs within a JavaScript environment, including handling of data type conversions (such as int64, floats, and strings) and structured error reporting that maps FScript exceptions to JavaScript objects.

FScript.JavaScript · high confidence

This change introduces a new JavaScript package for the FScript language engine, exposing parser, type inference, and evaluation capabilities for Node and browser-compatible ESM hosts. The package supports exported-function invocation, REPL-like sessions, virtual imports, and JS-provided externs. A test suite has been added to verify core functionality including primitive value handling, function loading and invocation, virtual imports, parsing and type inference, session state management, structured error reporting, and JavaScript extern integration.

src/FScript.JavaScript · high confidence

A new sample file (common.fss) has been added to the includes directory, providing reusable F\# code snippets such as type definitions, pattern matching examples, and string manipulation functions to demonstrate include functionality.

samples/includes · high confidence

The FScript CLI has been updated to allow loading external functions from user-provided assemblies via the new --extern-assembly flag, enabling custom runtime extensions. It also introduces a --root flag to override the sandbox root directory for filesystem operations and supports passing script-specific arguments using the -- separator. Additionally, users can disable default runtime externs with the --no-default-externs flag.

src/FScript · high confidence

The samples directory now includes a comprehensive set of new scripts demonstrating core language features and runtime capabilities. A new BASIC interpreter sample (\samples/basic/\) showcases the language's ability to parse and execute vintage BASIC programs, including support for line-numbered control flow, variables, and I/O. Additional samples illustrate structural record types and pattern matching (\annotations-and-matching\, \types-showcase\), map literal syntax and pattern matching (\map-matching\, \layout-styles\), and native task concurrency via \Task.spawn\ and \Task.await\ in the parallel quicksort example (\parallel-quicksort\). Other new samples cover basic arithmetic (\add\), recursion (\fibonacci\, \mutual-recursion\), file system enumeration (\fs-root-listing\), and standard algorithm implementations like FizzBuzz and quicksort.

samples · high confidence

The FScript language implementation has been reorganized under the FScript.Language namespace, introducing a comprehensive set of standard library functions (including Int, Float, Bool, String, List, Option, and Map operations) and type definitions (Environment, FsKind). The engine now supports file inclusion via a new IncludeResolver that handles path normalization and sandboxing, and adds Fable JavaScript compilation support alongside existing .NET runtime capabilities. Syntax features have been expanded to include the 'nameof' keyword, interpolated string placeholders, and match guards with 'when'. The public API in Library.fs has been extended with new parsing entry points for files and sources with includes, and the typed AST now supports match guards and source-name tracking.

src/FScript.Language · high confidence

The website now provides a complete Docusaurus-powered documentation site, including a quickstart guide, language fundamentals, standard library reference, and detailed embedding guides for .NET and JavaScript hosts.

website · high confidence

The VS Code FScript extension is now available, providing .fss language registration, TextMate syntax highlighting, and LSP client wiring to the FScript.LanguageServer. Users can enable or disable LSP features and inlay hints via settings, and access new commands to open an FScript REPL terminal, send code selections to it, or execute the current script. The extension manages the .NET runtime dependency through the VS Code .NET Install Tool integration and includes a status bar item to monitor server lifecycle.

vscode-fscript · high confidence

The \src/FScript.CSharpInterop/LanguageServer\ directory now contains the core implementation of the FScript Language Server, enabling IDE integration via the Language Server Protocol. This includes protocol handling for initialization, semantic tokenization, and symbol resolution, along with virtual stdlib documentation for built-in modules like List, Map, and Console. The server exposes capabilities such as go-to-definition, hover hints, inlay hints, and completion, allowing editors to provide rich code intelligence for FScript projects.

src/FScript.CSharpInterop/LanguageServer · high confidence

Added a new F\# Type Provider in \src/FScript.TypeProvider\ that allows F\# projects to consume FScript files as strongly-typed .NET types. The provider parses FScript scripts at compile time, infers types, and generates static methods corresponding to exported functions, ensuring strict runtime signature checks. It supports configuring script paths, root directories, and external providers via static parameters, and exposes methods to set and clear runtime resolvers for dynamic function binding.

src/FScript.TypeProvider · high confidence

The FScript runtime now exposes a structured host API that allows host applications to load scripts, inspect exported function signatures and values, and invoke exported functions with type-safe argument passing. This includes new \ExportSignatures\ and \ScriptHost\ modules that track exported bindings and enforce strict runtime signature checks. Additionally, the \XmlExterns\ module introduces \Xml.queryValues\, replacing the previous \Xml.deserialize\ extern to provide XPath-like querying capabilities for XML documents, while \Xml.serialize\ has been removed.

FScript.Runtime · high confidence

The core implementation files for the FScript language engine—including the lexer, parser, type inference engine, evaluator, and value definitions—have been deleted from the project. This removes the ability to parse, type-check, and execute FScript source code, effectively stripping the library of its runtime capabilities.

src/FScript.Core · high confidence

The repository has been restructured into distinct projects (FScript.Language, FScript.Runtime, FScript.CSharpInterop, FScript.LanguageServer, FScript.TypeProvider, and FScript.JavaScript) with corresponding test suites, replacing the previous monolithic layout. A new AGENTS.md file establishes mandatory contributor policies, including strict changelog gates, test coverage requirements, and release processes. The solution file and build configuration have been updated to reflect the new project hierarchy and target .NET 10.0.

(repo-wide) · high confidence

The FScript.Language module has been restructured and significantly expanded, moving core files (Ast, Types, Token, Error) from FScript.Core to this namespace. The language now supports a richer type system including Tasks, Maps, Unions, and structural records, alongside new syntax features like map literals, interpolated strings, and match guards. The runtime engine now handles concurrent task execution with thread-safe state management, and the interactive session mode has been enhanced to support incremental evaluation and retained program state.

FScript.Language · high confidence

The FScript.TypeProvider now enforces strict runtime checks on exported function signatures via a new contract system. This ensures that exported functions adhere to supported types (unit, int64, float, bool, string, lists, options, tuples, and string maps) and rejects unsupported constructs like task types or tuples with invalid arity, providing immediate feedback on signature mismatches during compilation.

FScript.TypeProvider · high confidence

The FScript Language Server executable has been rewritten in C\# (namespace FScript.LanguageServer.CSharp), replacing the previous F\# implementation. This change introduces new C\# source files for JSON-RPC wire handling, LSP protocol logic, and server lifecycle management, while retaining the underlying F\# language engine via interop. Users will continue to receive the same LSP capabilities (such as hover, diagnostics, and completion) but the server process is now a C\# application.

src/FScript.LanguageServer · high confidence

The standard library has been migrated from external definitions to embedded source files, introducing explicit implementations for List, Map, and Option types alongside a new Environment type. Users now have access to a comprehensive set of list operations including map, filter, fold, and optional index access (tryItem), as well as map utilities like add, remove, and pattern matching support. The Environment type exposes script metadata such as name and arguments, and introduces a FsKind union type to replace previous file/directory checks with a unified API for file system status.

src/FScript.Language/Stdlib · high confidence

The F\# script C\# interop language server now includes a dedicated LSP model module that defines the internal data structures for managing document state, including symbol resolution, local bindings, and type hints. This change introduces support for navigating local and pattern-bound symbols to their declarations, stabilizes definition navigation in records and string interpolation, and fixes cross-file inlay hint leakage in type declarations. Users will experience more accurate symbol resolution and improved reliability when navigating code within F\# scripts that interact with C\# components.

FScript.CSharpInterop · high confidence

The FScript runtime now provides a comprehensive set of new external functions and significantly hardened filesystem security. Users gain access to new capabilities including JSON serialization/deserialization, MD5 hashing, GUID generation, regular expression matching, and asynchronous task spawning. Filesystem operations have been refactored to use a unified \Fs.kind\ API instead of separate \isFile\/\isDirectory\ checks, and the sandbox is now stricter: it enforces root confinement, blocks access to denied path globs, and prevents symlink/reparse-point traversal attacks. Additionally, console input/output and XML querying are now available as externs.

src/FScript.Runtime · high confidence

Added FScript type-inference benchmark suite; Added comprehensive test coverage for FScript CLI, language engine, and language server.

This release restructures the FScript codebase into distinct, packable NuGet packages (Language, Runtime, TypeProvider, CLI, and C\# Interop) and introduces a new JavaScript build target via Fable. The Language engine is now a standalone \netstandard2.1\ library, while the CLI and Language Server are built on \net10.0\. The project also adds a VS Code extension for syntax highlighting and REPL integration, a public npm package for the JavaScript engine, and a Docusaurus-based documentation website. Under the hood, test dependencies have been updated to NUnit 4.4.0 and Microsoft.NET.Test.Sdk 18.0.1.

(dependencies) · high confidence

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

• CAI 65 → 66 (+0.7)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 76 → 76 (-0.0)
• Architecture 96 → 99 (+2.9)
• Maturity 65 → 65 (-0.3)
• Readiness 61 → 62 (+1.4)
• Security 64 → 64 (+0.0)

• Documentation: no architecture or design documentation (docs/guides/getting-started-tutorial.md)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (11–16 lines × 2) (src/FScript.JavaScript/Library.fs)
• Duplicated block (6–7 lines × 2) (src/FScript.JavaScript/Library.fs)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• Hotspot: src/FScript.JavaScript/Library.fs (src/FScript.JavaScript/Library.fs)
• Medium CVE: [GHSA redacted] (vscode-fscript/package-lock.json)

• Coverage not measured — JavaScript/TypeScript suite
• Duplicated block (6 lines × 2) (src/FScript.JavaScript/Library.fs)
• Duplicated block (9–10 lines × 2) (src/FScript.JavaScript/Library.fs)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• High CVE: [GHSA redacted] (vscode-fscript/package-lock.json)
• Medium vulnerability: [GHSA redacted] (vscode-fscript/package-lock.json)
• Outdated (npm): @types/ws
• Outdated (npm): bundle-name
• Outdated (npm): mdast-util-gfm-strikethrough
• Outdated (npm): mdast-util-to-markdown
• Outdated (npm): micromark
• Outdated (npm): micromark-core-commonmark
• Outdated (npm): micromark-factory-space
• Outdated (npm): micromark-util-types
• Outdated (npm): regenerate-unicode-properties
• Outdated (npm): regexpu-core
• Outdated (npm): source-map-js
• Outdated: Fable.Core
• …and 1 more

• Unchanged — 1 containers · 6 contexts · 5 edges

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

MagnusOpera/FScript 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.