feat(scripting): .NET file-based apps, .csx and .fsx support (#188) + CI pipeline split

[MelbourneDeveloper]

TLDR

Adds first-class editor support for project-less .NET code — .NET 10 file-based apps (.cs with #: directives), C# scripts (.csx) and F# scripts (.fsx) — and splits the monolithic CI workflow into five reusable, independently-gating pipelines.

Builds on #188 by @ashar-builds, who first identified that SharpLsp hard-failed on a .cs file with no .csproj. That diagnosis was correct; this PR redesigns the fix around the SDK's actual closure semantics and extends it to .csx and .fsx.

Details

Scripting and file-based apps — docs/specs/SCRIPTING-FILEBASED-SPEC.md (new, 363 lines)

Full spec derived from the .NET file-based apps documentation, with hierarchical IDs ([FILEBASED-*], [CSX-*], [FSX-*], [SCRIPT-*]) cross-referenced from every implementing file. Paired plan at docs/plans/SCRIPTING-FILEBASED-PLAN.md tracks what shipped vs. what is phase 2/3.

FileLevelDirectives.cs (new) — parses all five #: directives (sdk, package, project, property, include) off the Roslyn CST, never by scanning text: Roslyn lexes #: as IgnoredDirectiveTriviaSyntax and #! as ShebangDirectiveTriviaSyntax. No regex, no string matching against source. [FILEBASED-DIRECTIVES]

DocumentClosure.cs (new) — the closure of a file-based app is the root file plus its #:include graph, not every .cs in the directory. [SCRIPT-ANTIPATTERN] documents why the directory-scan approach is wrong: two independent apps in one folder would fight over Main. Supports literal, glob (*.cs) and recursive-glob (**/*.cs) includes, resolves .csx #load graphs, and terminates on cycles. Bounded at 64 files / 8 include levels, degrading with a logged issue rather than failing the load.

WorkspaceManager.SingleFile.cs (new) — builds an AdhocWorkspace per model:

• File-based apps parse as SourceCodeKind.Regular with the FileBasedProgram feature flag — without it Roslyn reports CS9314/CS9313 for the shebang and directives. Implicit usings are emitted as a synthetic generated document because CSharpCompilationOptions.Usings is honoured only for SourceCodeKind.Script.
• .csx parses as SourceCodeKind.Script per-document (kind does not inherit from project parse options), with Roslyn's ten default script imports and a SourceFileResolver rooted at the script directory, without which every #load reports CS8099.
• The previous AdhocWorkspace is now disposed on reopen (was leaked).

FSharpWorkspace.fs — .fsx/.fsscript load through FSharpChecker.GetProjectOptionsFromScript instead of hard-failing with "No .fsproj found". FCS computes the #load closure itself and defines INTERACTIVE/EDITING but not COMPILED, so #if INTERACTIVE code is live rather than greyed out.

src/main.rs — fixes a latch bug where opening any unsupported document (a .md, a .json) set workspace_initialized, permanently suppressing workspace init for the real code that followed. Adds sidecar_for_path so a document routes to the sidecar owning its language, plus health-check ordering for lazily-started sidecars. [SCRIPT-ROUTE-LAZY], [SCRIPT-ROUTE-TARGET], [SCRIPT-ROUTE-HEALTH]

SolutionLoader.cs — gated on project extensions so a directory containing only a file-based app no longer reports a bogus "no project found" failure, and genuinely ambiguous multi-solution directories now error instead of picking arbitrarily.

Known limit, documented in the plan: references are BCL-only (Basic.Reference.Assemblies.Net100). #:package symbols do not bind until the synthesized-project + restore path lands. [FILEBASED-REFERENCES-FALLBACK]

CI pipeline split — [DIST-CI-LAYOUT]

ci.yml (349 lines removed) split into five reusable workflows — ci-lint, ci-dotnet, ci-rust, ci-vsix, ci-vsix-windows — so a failure names the tier that broke instead of one opaque job.

• test-chunks.json + scripts/vsix-test-chunks.mjs — the 36 VS Code suites are partitioned into 7 Windows chunks. make _check-vsix-chunks fails the build if any suite belongs to no chunk, so a newly added suite cannot silently skip Windows coverage. [DIST-CI-WIN-VSIX]
• scripts/purge-path-binaries.sh — deletes any SharpLsp binary leaked onto the runner PATH, so the VS Code host can only resolve the freshly-staged bundled artifact. A dev copy on PATH silently substitutes itself for the artifact under test and turns a broken bundle green. [DIST-CI-SMOKE]

Debugger bundling — [DIST-DEBUGGER-BUNDLE]

scripts/fetch-netcoredbg.sh stages a platform-matched netcoredbg into the VSIX at package time; debug.ts resolves the bundled adapter. THIRD-PARTY-NOTICES.md (new) carries the redistribution notices.

New enforced lints

• BannedSymbols.txt — activates BannedApiAnalyzers RS0030 (error under -warnaserror) against DateTime.Now/Today/DateTimeOffset.Now (timezone-dependent, non-reproducible in tests) and Thread.Sleep (the sidecars are async end-to-end; blocking a pool thread risks starvation).
• clippy::print_stdout = "deny" — an LSP server speaks JSON-RPC over stdio, so a stray println! corrupts the protocol frame. print_stderr is deliberately not denied; stderr is the editor's log panel and the correct sink for pre-tracing bootstrap errors.

Also

Profiler flame-graph e2e test (tests/e2e_modules/profiler.rs), dependabot group bumps, Windows EOL normalisation for the scaffolding suite.

How Do The Automated Tests Prove It Works?

WorkspaceManagerSingleFileTests.cs — 15 coarse e2e tests, real files on disk, no mocks.

These replace an inherited test that was vacuous: GetDiagnosticsAsync returns a success Result carrying a list, and returns Ok([]) for an unknown document, so the original Assert.False(diags.IsError) passed with zero references loaded. Every assertion below is on actual Roslyn binding output.

• FileBasedApp_resolves_bcl_symbols_with_no_errors — BCL symbols bind; asserts no CS0103/CS0246 rather than merely "no exception".
• FileBasedApp_shebang_produces_no_diagnostic — proves the FileBasedProgram feature flag is live; without it this fails with CS9314.
• FileBasedApp_full_directive_header_produces_no_errors — exercises every ClassifyKeyword arm and both SplitOn branches: #:sdk, #:package Name@Version, #:package Name, #:property Name=Value, #:property Name, #:project.
• FileBasedApp_unresolvable_directives_still_bind_the_rest_of_the_file — #:frobnicate, an MSBuild-property include and a missing-file include degrade gracefully; asserts no CS0103, i.e. the rest of the file still binds.
• FileBasedApp_include_directive_pulls_referenced_file_into_closure, ..._glob_include_pulls_every_match_into_the_closure, ..._recursive_glob_include_reaches_nested_files — assert the included types actually resolve (One.V() + Two.V() compiles), not just that a path was collected.
• FileBasedApp_include_cycle_terminates — a mutually-including pair completes instead of hanging.
• FileBasedApp_closure_file_count_is_bounded — 70 files on disk, asserts exactly 64 in the closure plus the recorded "exceeded 64 files" issue.
• FileBasedApp_include_depth_is_bounded — a 12-deep chain records the nesting-limit issue.
• Two_file_based_apps_in_one_directory_do_not_collide — the regression that the directory-scan design would have shipped: two Mains in one folder.
• CsxScript_loads_with_script_semantics — #load resolves and script-kind semantics apply; fails with "#load is only allowed in scripts" if per-document SourceCodeKind regresses.
• Directory_without_project_or_root_file_is_an_error, Unsupported_document_is_a_load_error, Classify_maps_extensions_to_compilation_models.

FSharpScriptTests.fs — 3 tests. standalone fsx loads without an fsproj (this hard-failed before), fsx load closure includes the loaded script (asserts Lib.fsx and Main.fsx are in FCS SourceFiles), fsx defines INTERACTIVE and EDITING but not COMPILED (asserts on OtherOptions).

Suite totals: 895 tests pass — 91 Common, 464 C#, 340 F#.

Coverage ratchet: sharplsp-sidecar-csharp 95.08%, above the stored 95.0% threshold. The new bound/degradation paths were covered by adding tests, and dead code (FindMisplaced/FirstCodeTokenStart — a detector with no consumer) was deleted rather than shipped uncovered. The threshold was not lowered.

CI chunk gate: make _check-vsix-chunks reports 36 VS Code suites: 7 Windows chunks, 3 excluded and fails if that partition is ever incomplete.

Local gates green: cargo fmt, cargo clippy --all-targets -D warnings, zed clippy, csharpier check (92 files), dotnet build -warnaserror (0 warnings), prettier --check, eslint, tsc --noEmit.

Closes #188.