Neftedollar/orleans-fsharp

Orleans.FSharp is an F\# library that provides a functional, code-generation-free runtime for Microsoft Orleans, enabling developers to define grains using idiomatic F\# types and computation expressions. It supports core distributed computing patterns including event sourcing, transactions, and real-time push notifications via functional observers, while maintaining full interoperability with C\# clients. The system includes comprehensive tooling for testing, serialization, and static analysis, alongside extensive examples demonstrating parity with the classic Orleans model.

The new \examples/feature-tour\ project provides a runnable application that exercises the functional grain runtime (\grainContract\ + \grainFor\) against a live Orleans silo. It includes a status matrix documenting support for features such as persistence, scheduling, call filters, request context, cancellation, contract versioning, streams, observers, broadcast channels, heterogeneous clustering, implicit stream subscriptions, placement, distributed transactions, streaming replies, reentrancy, and event sourcing. The example also documents known hazards and workarounds, such as the need for C\#-declared observer interfaces due to Orleans' Roslyn generator constraints and the requirement to pre-load assemblies reached only through F\#.

examples/feature-tour · high confidence

The bank-account example now includes a functional, journaled implementation of the account grain alongside the existing event-sourced grain. This new twin uses the \journaledGrainFor\ computation expression and provides a typed API (\AccountApi\) that returns specific refusal reasons (e.g., \InsufficientFunds\, \NonPositiveAmount\) instead of silently ignoring rejected commands, and exposes the journal version directly. It delegates to the same domain logic (\applyEvent\, \handleCommand\) as the classic grain to ensure business rule parity while demonstrating the functional runtime's capabilities.

examples/bank-account/src/Domain · high confidence

New shared files (CounterContract.fs, Types.fs) define the client/server boundary for the functional counter grain and introduce core domain types (CounterState, ChatMessage, MetricEvent, etc.) used across the testbed.

testbed/src/Shared · high confidence

The SignalR Realtime example now includes a functional-runtime implementation of the DashboardGrain (DashboardGrainFunctional.fs) alongside the existing computation-expression version. This new grain exposes a typed API with separate operations for retrieving the current sequence number and fetching the latest metrics, while maintaining the same 2-second timer-based metric generation logic. This provides a modern, type-safe alternative for consuming the dashboard data via SignalR.

examples/signalr-realtime/src/Grains · high confidence

The feature tour example now includes comprehensive demonstrations of key Orleans capabilities using the functional runtime. Broadcast channels and implicit subscriptions are showcased with F\# consumer grains that automatically activate upon receiving messages. Call filters are demonstrated by intercepting and rejecting specific operations before they reach handlers. Cooperative cancellation is shown with a slow operation that respects cancellation tokens. Event sourcing is implemented using journaled grains with state upcasting and two different storage providers. Heterogeneous placement is proven in a two-silo cluster where grain types are hosted selectively. Reentrancy variants are tested, including whole-grain reentrancy and per-request interleaving predicates. Grain observers are demonstrated with a functional notifier and client-side recording observers. Persistence is shown with primary state holders and secondary persistent states, including explicit read/write/clear operations. Finally, placement strategies are demonstrated with stateless workers and custom placement providers.

examples/feature-tour/src/FeatureTour · high confidence

The Orleans.FSharp.EventSourcing package now provides a declarative F\# computation expression (eventSourcedGrain { }) for defining event-sourced grains, including support for custom log-consistency storage adapters and configurable snapshot strategies. To bridge F\# definitions to Orleans, the Orleans.FSharp.Generator tool scans assemblies at build time for \[FSharpEventSourcedGrain\] attributes and emits minimal C\# stub classes via Scriban templates, enabling zero-handwritten-C\# integration for both typed and universal grain patterns.

src/Orleans.FSharp.EventSourcing · high confidence

This change adds the core abstractions for the new functional grain transport in \src/Orleans.FSharp.Abstractions\. It introduces \FunctionalGrainReference\ to handle acknowledged, one-way, transactional, and server-streaming requests via a fixed payload codec, and \FunctionalJournal\ to manage durable event-sourced state using immutable F\# types wrapped in serializable cells. Additionally, it defines \FunctionalObserver\ for push-based notifications and \FunctionalTransport\ for admission flags and payload limits, enabling a codegen-free, type-safe communication layer for F\# grains.

src/Orleans.FSharp.Abstractions · high confidence

The Orleans.FSharp.Runtime library now provides a complete functional grain implementation, replacing the previous grain{} surface with a new set of core modules. Users can now configure Orleans clients using a dedicated F\# computation expression (ClientConfigBuilder.fs) that supports localhost, static gateway, and custom clustering modes, along with TLS and stream provider settings. The runtime introduces a functional activation model (FunctionalActivation.fs) and dispatch layer (FunctionalDispatch.fs) that handles grain lifecycle, reminders, timers, and implicit stream/broadcast subscriptions without requiring C\# code generation. It also includes a journaled event-sourcing capability (FunctionalJournal.fs) that integrates with Orleans' log-consistency providers, and exposes configurable F\# serialization policies (FSharpBinaryCodec) to handle payload encoding without attributes.

src/Orleans.FSharp.Runtime · high confidence

The Orleans.FSharp documentation is now published as a standalone website built with Astro and Starlight, hosted at neftedollar.com/orleans-fsharp/. The site features a black theme, a comprehensive sidebar covering functional runtime, data/messaging, and legacy archives, and includes SEO optimizations such as Open Graph tags, Twitter cards, and JSON-LD structured data. It also supports agentic search discovery via registered MCP actions and maintains a synchronized mirror of the source Markdown documentation.

website · high confidence

A new 'Orleans F\# Project' template is available, providing a self-contained solution structure for building Orleans applications in F\#. The template targets .NET 10.0 and is configured to opt out of Central Package Management to ensure it restores standalone. It demonstrates an idiomatic functional API for defining grains, featuring a typed \CounterApi\ with \increment\, \decrement\, and \value\ operations, implemented via \grainFor\ and \FunctionalGrain.ref\. The included sample silo configures localhost clustering and memory storage, running a demo that exercises the counter grain. The template also includes property-based tests using FsCheck and Unquote to verify the counter's state transition logic.

templates/orleans-fsharp · high confidence

A new analyzer package, Orleans.FSharp.Analyzers, is introduced to enforce idiomatic F\# usage in Orleans grain code. It includes the OF0001 rule, which flags the use of \async { }\ blocks in favor of \task { }\ within grain handlers. Users can suppress this warning using the provided \\[\<AllowAsync\>\]\ attribute when \async\ is genuinely required, such as for interop with Async-returning libraries. The analyzer is implemented as a CLI plugin using the FSharp.Analyzers.SDK and requires explicit invocation via the \fsharp-analyzers\ tool in CI environments, rather than running automatically during standard builds.

src/Orleans.FSharp.Analyzers · high confidence

A new sample project has been added to demonstrate the Orleans.FSharp library's capabilities. It includes runnable examples for various grain patterns: a chat room using the functional runtime (spec 003), an event-sourced bank account, a leaderboard with grain-to-grain communication, and grains using the universal pattern (FSharpGrain.ref) without C\# stubs. The sample also showcases features like additional state, lifecycle hooks (onActivate/onDeactivate), reminders, timers, and typed result extraction via ask.

src/Orleans.FSharp.Sample · high confidence

The Orleans.FSharp.Testing package introduces a comprehensive testing toolkit for Orleans.FSharp applications. It includes GrainMock for unit-testing grain interactions without a silo, GrainArbitrary and FsCheckHelpers for automatic property-based testing of F\# discriminated unions and state machines, and LogCapture for asserting structured log output. For integration testing, it provides TestHarness for in-process silo testing with memory storage and WebTestHarness for end-to-end HTTP endpoint testing, including a lightweight WebUnitTestHarness that injects a mock grain factory into an ASP.NET Core TestServer.

src/Orleans.FSharp.Testing · high confidence

Added a new \examples/signalr-realtime\ project that demonstrates Orleans grains pushing real-time metrics to a browser dashboard via SignalR. The example uses the functional grain runtime (reusing the pure \generateMetrics\ function) instead of the deprecated computation expression, targeting .NET 10. It includes a co-hosted ASP.NET Core and Orleans setup, fixing a standalone-hosting assembly loading issue and correcting a JSON casing mismatch in the client-side JavaScript to ensure metrics render correctly.

examples/signalr-realtime · high confidence

The Orleans.FSharp documentation site has been redesigned using the Starlight framework, introducing a new layout and navigation structure. This update adds custom Astro components, including \DocBreadcrumb\ for consistent page navigation and \FeatureCard\ for displaying feature highlights with interactive hover states. The site now includes a comprehensive set of documentation pages covering the functional grain runtime, API reference, advanced topics like transactions and state migration, and interop guides for C\# consumers.

website/src · high confidence

The bank-account example now includes a functional journaled twin alongside the existing event-sourced implementation. This new version uses the \journaledGrainFor\ definition to manage state via an immutable event log, providing typed refusals for invalid operations (such as overdrafts or non-positive amounts) instead of silently ignoring them. The example demonstrates inter-account transfers, overdraft protection, and event replay, with property-based tests ensuring parity between the classic and functional implementations.

examples/bank-account · high confidence

A new \examples/bank-transactions\ project has been added, providing a complete ACID transaction demo for Orleans. It features a 'functional twin' implementation (\AccountGrainFunctional.fs\) that mirrors the classic \FSharpTransactionalGrain\ model using the new \grainFor\ and \transactional\ APIs, allowing users to compare the two authoring styles. The example includes a solution with Domain, Silo, and Test projects, demonstrating atomic cross-grain transfers, overdraft handling, and consistent balance snapshots, alongside property-based tests that verify business logic parity between the classic and functional approaches.

examples/bank-transactions, examples/dashboard · high confidence

The chat-room example now includes a functional twin of the classic chat grain (ChatGrainFunctional.fs) that implements full room domain logic including join/leave, message posting with validation, history queries, and typing indicators. Unlike the classic grain which relies on IChatObserver interfaces requiring C\# code generation, this functional implementation uses functional observers (RoomObserverApi) that work without code generation, enabling live push notifications from F\# clients. The classic grain remains available but is marked obsolete, serving as a reference for the deprecated observer model.

examples/chat-room/src/Grains · high confidence

A new \quickstart-functional.fsx\ sample demonstrates the idiomatic F\# API for defining and running Orleans grains using the functional runtime, allowing users to define grains via plain F\# records without needing C\# interfaces or code generation. This complements the existing \quickstart.fsx\ sample, which continues to illustrate the classic interface-based authoring style.

samples · high confidence

A new testbed has been added to demonstrate a two-silo Orleans cluster using F\# silos communicating via Redis. This includes Dockerfiles for the client and silo services, a docker-compose configuration to orchestrate the environment, and a solution file that ensures the CodeGen generator and sample projects are correctly included for Release builds. The testbed also features a comprehensive stress test script that validates grain activation, throughput, state consistency, and silo distribution under load.

testbed · high confidence

This release introduces a new idiomatic F\# API for Microsoft Orleans, replacing the previous universal message-passing surface with a functional grain runtime. The new API uses API records and computation expressions (grainContract/contract) to define grain contracts and definitions without per-project C\# code generation. It includes a new FSharpBinaryCodec for serializing F\# types (discriminated unions, records, options, etc.) using TypeShape, eliminating the need for \[GenerateSerializer\] attributes. The release also adds broadcast channels, functional observers, lifecycle hooks, and various parity features with Orleans. The old grain{} message-passing surface is marked obsolete.

src/Orleans.FSharp · high confidence

The repository is now open-source under the MIT License, introducing standard project governance files including a Code of Conduct, CONTRIBUTING guide, and issue/PR templates. It also adds a .gitleaks configuration to prevent accidental secret commits and establishes a .gitignore to exclude build artifacts, IDE settings, and AI assistant data. The project structure is formalized with a solution file (Orleans.FSharp.slnx), centralized build properties (Directory.Build.props/targets) for versioning and packaging, and a comprehensive CHANGELOG documenting the 5.0.0 functional-first release.

(repo-wide) · high confidence

The chat-room silo now runs as a standalone F\# application using the functional grain runtime, enabling real-time push notifications via functional observers without requiring C\# source generators or observer interfaces. This change replaces the previous classic grain model setup, allowing the silo to operate independently while demonstrating parity with the original C\#-based example through a fully functional F\# implementation.

examples/chat-room/src/Silo · high confidence

The chat-room example now runs as a standalone solution featuring a fully functional grain implementation that supports real-time push notifications via functional observers (eliminating the need for generated observer interfaces). It also introduces a C\# interop layer, allowing the F\# grain to be hosted and called directly from C\# code through a facade interface, with F\# types like Result and List mapped transparently to their CLR equivalents.

examples/chat-room · high confidence

The typesafe-ids example has been rewritten to demonstrate the new functional grain runtime alongside the classic grain authoring style. The example now includes functional equivalents for the User, Order, and Router grains (UserGrainFunctional.fs, OrderGrainFunctional.fs, RouterGrainFunctional.fs) which use the new \grainContract\ and \grainFor\ constructs. The classic \grain {}\ CE versions are kept as deprecated references. The example highlights three key F\# features: type-safe IDs using units of measure to prevent mixing up User and Order IDs at compile time, active patterns for message routing in the Router grain, and exhaustive matching for order state transitions. The project now targets .NET 10.0 and includes a new solution structure with Domain, Silo, and Domain.Tests projects.

examples/typesafe-ids · high confidence

The \.specify\ directory has been completely removed, deleting the entire Spec-Driven Development scaffolding. This includes the project constitution, all Markdown templates (spec, plan, tasks, checklist, constitution, and agent-file), and the Bash automation scripts used to manage feature branches, validate prerequisites, and update AI agent context files. Users will no longer have access to the \/speckit\ command-line workflow or the associated project structure conventions.

.specify · high confidence

The bank-account example has been updated to demonstrate a functional, journaled grain model alongside the classic event-sourced grain. The silo now registers both the traditional \AddFSharpEventSourcedGrain\ and the new \AddFunctionalJournaledGrain\, allowing the application to interact with accounts via a direct API record (\AccountApi\) without requiring interface-based code generation. This change enables users to observe specific behaviors of the functional runtime, such as separate journals for independent operations and explicit handling of refused commands (which do not advance the journal version).

examples/bank-account/src/Silo · high confidence

The Fable Fullstack example has been updated to demonstrate the new functional grain runtime alongside the legacy computation expression model. The server now exposes the \/api/ITodoApi/\*\ endpoints via a functional twin (\TodoGrainFunctional.fs\) that uses \grainFor\ and explicit \stateFrom\ persistence, while the original \grain {}\ implementation is retained as a deprecated reference. This change also resolves a startup issue in \WebApplicationBuilder\-based hosts by ensuring required assemblies are pre-loaded before Orleans initialization, preventing activation failures for memory storage grains.

examples/fable-fullstack · high confidence

The Hello World example has been restructured into a standalone F\# project that utilizes the functional grain runtime (grainContract + grainFor) instead of the legacy computation-expression model. This change eliminates the need for a C\# CodeGen bridge, allowing the example to run directly from an F\# silo. The example demonstrates key functional runtime features, including typed grain references, concurrent GrainBatch operations, and pure state migration chains, while keeping the original grain {} definition as a deprecated reference.

examples/hello-world · high confidence

The Orleans.FSharp.CodeGen project has been introduced as a non-packable source archive containing legacy C\# Roslyn bridge code. This project provides backward-compatible concrete grain implementations (such as Counter, Echo, and Order) that delegate to F\# GrainDefinitions, enabling Orleans source generators to produce grain metadata for the older per-grain interface pattern. It is retained solely to support migration examples and integration tests, as new functional grains now utilize the typed API records and fixed proxies from Orleans.FSharp.Abstractions without requiring per-grain C\# stubs.

src/Orleans.FSharp.CodeGen · high confidence

The order-processing example now includes a full-parity functional twin (OrderGrainFunctional.fs) that replaces the original grain computation expression with a pure transition function, typed Result replies, and explicit persistence. This functional grain can run standalone in a silo, resolving a previous limitation where the original F\# grain required C\# code generation to be hosted. The example also fixes a standalone hosting gap by ensuring the memory reminder service assembly is force-loaded before the silo starts.

examples/order-processing · high confidence

The testbed silo entry point (Program.fs) has been rewritten in F\#, replacing the previous C\# implementation. It now explicitly configures Redis clustering and grain storage, resolves advertised IP addresses for Docker environments, and registers a F\# JSON serialization fallback. The silo defines two grains (Counter and Chat) using the standard F\# grain builder and registers a new functional-runtime equivalent of the Counter grain (CounterGrainFunctional.fs) alongside the original, allowing the client to interact with the new functional-style grain definition.

testbed/src/Silo · high confidence

The dashboard hub and application startup have been rewritten to use a functional grain twin (DashboardFunctionalDef) instead of the classic Orleans grain model. This change resolves a critical issue where F\# assemblies lacked the necessary source-generated attributes for the classic grain interface, which previously caused connection crashes with 'Could not find an implementation for interface IDashboardGrain'. The new implementation registers the functional grain in Program.fs and updates DashboardHub.fs to call the functional API (DashboardApi.ref), ensuring stable real-time metric delivery to the browser client.

examples/signalr-realtime/src/Web · high confidence

Client-side stress test harness for Orleans.FSharp; Expanded integration and property-based test coverage for Orleans.FSharp; New CI validation scripts for documentation integrity, release packaging, and analyzer smoke tests.

The project now uses Central Package Management (Directory.Packages.props) to centrally version all dependencies, ensuring consistency across the solution. This change upgrades the target framework to .NET 10.0 and sets the minimum supported Microsoft Orleans version to 10.1.0 (with CI testing against 10.2.2). Key library updates include FSharp.Core 10.1.201, Microsoft.Extensions packages 10.0.9, and test tooling such as xunit 2.9.3 and FsCheck 3.3.3. Additionally, OpenTelemetry.Api is pinned to 1.16.0 to address a vulnerability in the Dashboard dependency.

(dependencies) · high confidence

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

• CAI 68 → 71 (+3.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 73 → 72 (-0.9)
• Architecture 95 → 100 (+4.8)
• Maturity 70 → 69 (-1.1)
• Readiness 68 → 80 (+11.7)
• Security 80 → 87 (+7.3)
• Performance 64 → 68 (+4.6)

• AstWalker.collectAsyncRanges (cognitive 32) (src/Orleans.FSharp.Analyzers/AsyncUsageAnalyzer.fs)
• AstWalker.collectAsyncRanges (cyclomatic 50) (src/Orleans.FSharp.Analyzers/AsyncUsageAnalyzer.fs)
• ClientConfigModule.applyToBuilder (cyclomatic 22) (src/Orleans.FSharp.Runtime/ClientConfigBuilder.fs)
• Discovery.discoverEventSourcedGrains (cognitive 67) (src/Orleans.FSharp.Generator/Discovery.fs)
• Duplicated block (11 lines × 2) (src/Orleans.FSharp.Runtime/SiloConfigBuilder.fs)
• Duplicated block (12 lines × 2) (src/Orleans.FSharp.Runtime/SiloConfigBuilder.fs)
• Duplicated block (17 lines × 3) (src/Orleans.FSharp/GrainDirectory.fs)
• Duplicated block (18 lines × 2) (src/Orleans.FSharp/GrainBuilder.fs)
• Duplicated block (19 lines × 3) (src/Orleans.FSharp.Abstractions/IFSharpGrainInterfaces.cs)
• Duplicated block (20 lines × 2) (src/Orleans.FSharp/GrainBuilder.fs)
• Duplicated block (20 lines × 2) (src/Orleans.FSharp/GrainBuilder.fs)
• Duplicated block (21 lines × 2) (src/Orleans.FSharp/GrainBuilder.fs)
• Duplicated block (5 lines × 2) (src/Orleans.FSharp/FSharpBinaryCodec.fs)
• Duplicated block (6 lines × 2) (src/Orleans.FSharp.EventSourcing/EventSourcedGrainDiscovery.fs)
• Duplicated block (6 lines × 3) (src/Orleans.FSharp.Runtime/SiloConfigBuilder.fs)
• Duplicated block (7 lines × 2) (src/Orleans.FSharp/FSharpBinaryCodec.fs)
• Duplicated block (7 lines × 2) (testbed/src/Client/Program.fs)
• Duplicated block (8 lines × 2) (src/Orleans.FSharp.Runtime/SiloConfigBuilder.fs)
• Duplicated block (8 lines × 2) (src/Orleans.FSharp/Streaming.fs)
• Duplicated block (8 lines × 4) (src/Orleans.FSharp/StreamProviders.fs)
• …and 30 more

• Dependency advisory scan runs only on code events
• Documentation: no installation or build instructions (README.md)
• Documentation: written for insiders (examples/bank-transactions/README.md)
• Documentation: written for insiders (examples/chat-room/README.md)
• Duplicated block (10 lines × 2) (examples/feature-tour/src/FeatureTour/Program.fs)
• Duplicated block (11 lines × 2) (examples/feature-tour/src/FeatureTour/Interleaving.fs)
• Duplicated block (11 lines × 2) (src/Orleans.FSharp.Abstractions/FunctionalObserver.cs)
• Duplicated block (11 lines × 2) (testbed/src/Client/Program.fs)
• Duplicated block (12 lines × 3) (examples/hello-world/src/Grains/CounterGrainFunctional.fs)
• Duplicated block (12 lines × 4) (examples/hello-world/src/Grains/CounterGrainFunctional.fs)
• Duplicated block (14 lines × 2) (src/Orleans.FSharp.Abstractions/FunctionalTransportSerialization.cs)
• Duplicated block (15 lines × 2) (examples/hello-world/src/Grains/CounterGrainFunctional.fs)
• Duplicated block (22 lines × 7) (src/Orleans.FSharp.Abstractions/FunctionalObserver.cs)
• Duplicated block (23–25 lines × 2) (src/Orleans.FSharp.Abstractions/FunctionalRequestBody.cs)
• Duplicated block (25 lines × 3) (src/Orleans.FSharp.Abstractions/FunctionalObserver.cs)
• Duplicated block (37–41 lines × 3) (src/Orleans.FSharp.Abstractions/FunctionalTransportSerialization.cs)
• Duplicated block (8 lines × 2) (src/Orleans.FSharp.EventSourcing/EventSourcedGrainDiscovery.fs)
• Inconsistent naming for similar test facade methods that accept a string argument and likely perform a similar 'send message' or 'invoke action' behavior. 'SAY' and 'Shout' are semantically distinct verbs (volume/intent) but structurally identical in this test context (Facade methods taking a string). Given the other facades use 'Join', 'Post', 'MemberCount', etc., these two stand out as using imperative verbs for actions where a noun or standard verb might be expected, and they differ from each other without a clear semantic distinction in the test harness context.
• Low IaC: DS-0026 (testbed/Dockerfile.silo)
• Medium IaC: WD-COMPOSE-0002 (testbed/docker-compose.yml)
• …and 122 more

• 289 commits — 268 feature/other, 21 fixes

• tests/Orleans.FSharp.Integration — 39 commits
• website/src — 36 commits
• src/Orleans.FSharp — 34 commits
• tests/Orleans.FSharp.Tests — 30 commits
• (root) — 21 commits
• examples/feature-tour — 20 commits
• specs/003-functional-grain-runtime — 15 commits
• src/Orleans.FSharp.Runtime — 15 commits
• (repo) — 10 commits
• docs/functional-grains.md — 9 commits
• specs/004-orleans-parity-extensions — 8 commits
• .github/workflows — 5 commits
• examples/chat-room — 5 commits
• docs/api-reference.md — 4 commits
• tests/Orleans.FSharp.SeamProof — 4 commits
• src/Orleans.FSharp.Abstractions — 3 commits
• src/Orleans.FSharp.CodeGen — 3 commits
• docs/resilience.md — 2 commits
• examples/signalr-realtime — 2 commits
• examples/typesafe-ids — 2 commits

• fix: Add Phase 0 seam-proof project with fixed transport and activation spike
• fix: Add protocol, fixed-codec, and binding test suites
• fix: Add the fixed functional transport types and explicit codecs
• fix: Derive every verdict from what the section observed, and fail on regression
• fix: Fix the testbed Release build by listing Sample and Generator in Testbed.slnx
• fix: Merge pull request #28 from Neftedollar/fix/pin-sdk-10-0-201
• fix: Merge pull request #30 from Neftedollar/fix/resilience-and-stream-cursor
• fix: Name the field a cleared state broke on, and fix two doc snippets
• fix: Publish the fixed transport codecs through an assembly manifest provider
• fix: fix(004): bind the journal facade to the invocation that resolved it
• fix: fix(004): do not read argument 0 of an invokable that has no arguments
• fix: fix(004): reject a second grain type binding one actor brand's interleave predicate
• fix: fix(004): surface a wrong-typed broadcast item instead of dropping it silently
• fix: fix: await the asTaskSeq stream subscription on first pull, and probe readiness in its test
• fix: fix: complete serialization hardening and 5.0 release gates (#34)
• fix: fix: harden persistence upgrades for 5.0
• fix: fix: make the GrainResilience deadline fire for the caller
• fix: fix: validate and run the packaged functional template
• fix: fix: validate silo startup before runtime initialization (#35)
• fix: samples: add a functional-runtime quickstart, fix the classic one's silent crash
• …and 269 more

• 1 added · 0 removed (a removed endpoint is potentially breaking)

• GET /exercise

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

Neftedollar/orleans-fsharp 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.