Docs & Rules

akkadotnet/akka.netGitHubLast refreshed Oct 3, 2026

This is a public, read-only report. Striff reads this repository's docs, turns each sentence that makes a claim about the code into a rule, and checks the rule against the code on the default branch. How this works

2+ names in these docs no longer match the code.

devd39d14dlisted 7h ago

Is this yours? Install to manage it

Once installed, Striff checks every pull request.

1 stale1

1 stale

78 docs, listed Oct 3

akkadotnet/akka.netOpen repository

Names these docs write that the code no longer has2

Each sentence below names a type the default branch doesn't declare, or declares somewhere else. Edit the doc so it matches the code, or bring the type back.

Goneakka.actor.ActorNotFound
It is completed with failure akka.actor.ActorNotFound if no such actor exists or the identification didn't complete within the supplied timeout.
akka.actor declares nothing by this name. Closest name there: ActorNotFoundException.
View on GitHub
Goneakka.actor.ActorNotFound
It is completed with failure akka.actor.ActorNotFound if no such actor exists or the identification didn't complete within the supplied timeout.
akka.actor declares nothing by this name. Closest name there: ActorNotFoundException.
View on GitHub

akkadotnet/akka.net — documented rules

72 of 72 rules, printed October 3, 2026.

	The sentence in your docs
Read Oct 2	> [!NOTE] > The interface `IWithStash` implements the marker interface `IRequiresMessageQueue<IDequeBasedMessageQueueSemantics>` which requests the system to automatically choose a deque-based mailbox implementation for the actor (defaults to an unbounded deque mailbox).	IWithStash implements IRequiresMessageQueue	Holds
Read Oct 2	To get the value, you need to call `response.Get(key)` with the key, you've sent with the request.	IGetResponse has a `Get` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	Flag has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	GCounter has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	PNCounter has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	GSet has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	ORSet has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	ORDictionary has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	PNCounterDictionary has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	LWWRegister has a `Merge` method	Holds
Read Oct 2	All of them share some common members, such as (default) empty value or `Merge` method used to merge two replicas of the same data with automatic conflict resolution.	LWWDictionary has a `Merge` method	Holds
Read Oct 2	`PNCounterDictionary` is a dictionary implementation based on `ORDictionary`, where values are represented as PN-Counters.	PNCounterDictionary depends on ORDictionary	Holds
Read Oct 2	Each `AtomicWrite` message contains a `Payload` property that contains:	AtomicWrite has `Payload`	Holds
Read Oct 2	In order to do this, you will need to extend two things, `IExtension` and `ExtensionIdProvider<T>`.	IExtension is a contract	Holds
Read Oct 2	The identifier must be defined with the `PersistenceId` method.	PersistentActor has a `PersistenceId` method	Holds
Read Oct 2	You can override the `InternalStashOverflowStrategy` property to return `DiscardToDeadLetterStrategy` or `ReplyToStrategy` for any "individual" persistent actor, or define the "default" for all persistent actors by providing a fully-qualified class name, which must be a subclass of `StashOverflowStrategyConfigurator`, in the persistence configuration:	PersistentActor has `InternalStashOverflowStrategy`	Holds
Read Oct 2	The `PersistAsync` method provides a tool for implementing high-throughput persistent actors.	PersistentActor has a `PersistAsync` method	Holds
Read Oct 2	`PersistentActor` provides an utility method called `DeferAsync`, which works similarly to `PersistAsync` yet does not persist the passed in event.	PersistentActor has a `DeferAsync` method	Holds
Read Oct 2	Each event is of course stored atomically, but it is also possible to store several events atomically by using the `PersistAll` or `PersistAllAsync` method.	PersistentActor has a `PersistAll` method	Holds
Read Oct 2	Each event is of course stored atomically, but it is also possible to store several events atomically by using the `PersistAll` or `PersistAllAsync` method.	PersistentActor has a `PersistAllAsync` method	Holds
Read Oct 2	It is possible to delete all messages (journaled by a single persistent actor) up to a specified sequence number; Persistent actors may call the `DeleteMessages` method to this end.	PersistentActor has a `DeleteMessages` method	Holds
Read Oct 2	Method Persist / PersistAsync, Success persist handler invoked, Failure / Rejection OnPersistFailure, After failure handler invoked Actor is stopped	PersistentActor has a `Persist` method	Holds
Read Oct 2	Method Persist / PersistAsync, Success persist handler invoked, Failure / Rejection OnPersistFailure, After failure handler invoked Actor is stopped	PersistentActor has an `OnPersistFailure` method	Holds
Read Oct 2	Failure / Rejection OnPersistRejected, After failure handler invoked No automatic actions	PersistentActor has `OnPersistRejected`	Holds
Read Oct 2	Method Recovery, Success RecoverySuccess, Failure / Rejection OnRecoveryFailure, After failure handler invoked Actor is stopped	PersistentActor has an `OnRecoveryFailure` method	Holds
Read Oct 3	A generated serializer derives from `AkkaSerializer`, then `SerializerV2`, then `Serializer`.	AkkaSerializer extends SerializerV2	Holds
Read Oct 3	A generated serializer derives from `AkkaSerializer`, then `SerializerV2`, then `Serializer`.	SerializerV2 extends Serializer	Holds
Read Oct 3	`MessagePackSizes` is the same public, static exact-size math the generated serializers use internally.	MessagePackSizes is declared public	Holds
Read Oct 3	`MessagePackSizes` is the same public, static exact-size math the generated serializers use internally.	MessagePackSizes is declared static	Holds
Read Oct 2	In the above example we used ``ToMaterialized` `to indicate that we want to transform the materialized value of the source and sink, and we used the convenience function` `Keep.Right`` to say that we are only interested in the materialized value of the sink.	Keep has `Right`	Holds
Read Oct 2	For this reason there is a convenience method called ``RunWith()` `available for` `Sink,` `Source` `or` `Flow` `requiring, respectively, a supplied` `Source` `(in order to run a` `Sink), a` `Sink` `(in order to run a` `Source) or both a` `Source` `and a` `Sink` `(in order to run a` `Flow``, since it has neither attached yet).	Sink has a `RunWith` method	Holds
Read Oct 2	For this reason there is a convenience method called ``RunWith()` `available for` `Sink,` `Source` `or` `Flow` `requiring, respectively, a supplied` `Source` `(in order to run a` `Sink), a` `Sink` `(in order to run a` `Source) or both a` `Source` `and a` `Sink` `(in order to run a` `Flow``, since it has neither attached yet).	Source has a `RunWith` method	Holds
Read Oct 2	For this reason there is a convenience method called ``RunWith()` `available for` `Sink,` `Source` `or` `Flow` `requiring, respectively, a supplied` `Source` `(in order to run a` `Sink), a` `Sink` `(in order to run a` `Source) or both a` `Source` `and a` `Sink` `(in order to run a` `Flow``, since it has neither attached yet).	Flow has a `RunWith` method	Holds
Read Oct 2	Most notably this includes the various forms of the ``Run()` `and` `RunWith()` `methods defined on` Source `and` Flow `elements as well as a small number of special syntactic sugars for running with well-known sinks, such as` `RunForeach(el => ...)` `(being an alias to` `RunWith(Sink.Foreach(el => ...))``.	Source has a `RunForeach` method	Holds
Read Oct 2	To allow for parallel processing you will have to insert asynchronous boundaries manually into your flows and graphs by way of adding ``Attributes.AsyncBoundary` `using the method` `Async` `on` `Source,` `Sink` `and` `Flow`` to pieces that shall communicate with the rest of the graph in an asynchronous fashion.	Source has an `Async` method	Holds
Read Oct 2	To allow for parallel processing you will have to insert asynchronous boundaries manually into your flows and graphs by way of adding ``Attributes.AsyncBoundary` `using the method` `Async` `on` `Source,` `Sink` `and` `Flow`` to pieces that shall communicate with the rest of the graph in an asynchronous fashion.	Sink has an `Async` method	Holds
Read Oct 2	To allow for parallel processing you will have to insert asynchronous boundaries manually into your flows and graphs by way of adding ``Attributes.AsyncBoundary` `using the method` `Async` `on` `Source,` `Sink` `and` `Flow`` to pieces that shall communicate with the rest of the graph in an asynchronous fashion.	Flow has an `Async` method	Holds
Read Oct 2	This is particularly useful in the case of "materialized value powered" `Source`s, like `Source.Queue`, `Source.ActorRef` or `Source.Maybe`.	Source has `Queue`	Holds
Read Oct 2	This is particularly useful in the case of "materialized value powered" `Source`s, like `Source.Queue`, `Source.ActorRef` or `Source.Maybe`.	Source has `ActorRef`	Holds
Read Oct 2	This is particularly useful in the case of "materialized value powered" `Source`s, like `Source.Queue`, `Source.ActorRef` or `Source.Maybe`.	Source has `Maybe`	Holds
Read Oct 2	By using the `PreMaterialize` operator on a `Source`, you can obtain its materialized value and another `Source`.	Source has `PreMaterialize`	Holds
Read Oct 2	Also, there are two query methods available for output ports: `IsAvailable(out)` returns true if the port can be pushed	GraphStageLogic has an `IsAvailable` method	Holds
Read Oct 2	The following operations are available for input ports: `Pull(in)` requests a new element from an input port.	GraphStageLogic has a `Pull` method	Holds
Read Oct 2	Finally, there are two methods available for convenience to complete the stage and all of its ports: `CompleteStage()` is equivalent to closing all output ports and cancelling all input ports.	GraphStageLogic has a `CompleteStage` method	Holds
Read Oct 2	From the `GraphStageLogic` the following operations are available on an output port: `Push(out,elem)` pushes an element to the output port.	GraphStageLogic has a `Push` method	Holds
Read Oct 2	`Complete(out)` closes the output port normally.	GraphStageLogic has a `Complete` method	Holds
Read Oct 2	`Fail(out,exception)` closes the port with a failure signal.	GraphStageLogic has a `Fail` method	Holds
Read Oct 2	`IsClosed(out)` returns true if the port is closed.	GraphStageLogic has an `IsClosed` method	Holds
Read Oct 2	`Grab(in)` acquires the element that has been received during an `onPush` It cannot be called again until the port is pushed again by the upstream.	GraphStageLogic has a `Grab` method	Holds
Read Oct 2	`Cancel(in)` closes the input port.	GraphStageLogic has a `Cancel` method	Holds
Read Oct 2	`HasBeenPulled(in)` returns true if the port has been already pulled.	GraphStageLogic has a `HasBeenPulled` method	Holds
Read Oct 2	`FailStage(exception)` is equivalent to failing all output ports and cancelling all input ports.	GraphStageLogic has a `FailStage` method	Holds
Read Oct 2	`Emit(out, elem)` and `EmitMultiple(out, Enumerable(elem1, elem2))` replaces the `OutHandler` with a handler that emits one or more elements when there is demand, and then reinstalls the current handlers	GraphStageLogic has an `Emit` method	Holds
Read Oct 2	`Emit(out, elem)` and `EmitMultiple(out, Enumerable(elem1, elem2))` replaces the `OutHandler` with a handler that emits one or more elements when there is demand, and then reinstalls the current handlers	GraphStageLogic has an `EmitMultiple` method	Holds
Read Oct 2	`Read(in, andThen, onClose)` and `ReadMany(in, n, andThen, onClose)` replaces the `InHandler` with a handler that reads one or more elements as they are pushed and allows the handler to react once the requested number of elements has been read.	GraphStageLogic has a `Read` method	Holds
Read Oct 2	`Read(in, andThen, onClose)` and `ReadMany(in, n, andThen, onClose)` replaces the `InHandler` with a handler that reads one or more elements as they are pushed and allows the handler to react once the requested number of elements has been read.	GraphStageLogic has a `ReadMany` method	Holds
Read Oct 2	`AbortEmitting(out)` and `AbortReading(in)` which will cancel an ongoing emit or read	GraphStageLogic has an `AbortEmitting` method	Holds
Read Oct 2	`AbortEmitting(out)` and `AbortReading(in)` which will cancel an ongoing emit or read	GraphStageLogic has an `AbortReading` method	Holds
Read Oct 2	It is possible to opt out from this behavior by invoking `SetKeepGoing(true)` (which is not supported from the stage's constructor and usually done in `PreStart`).	GraphStageLogic has a `SetKeepGoing` method	Holds
Read Oct 2	Timers can be scheduled by calling one of `ScheduleOnce(key,delay)`, `SchedulePeriodically(key,period)` or `SchedulePeriodicallyWithInitialDelay(key,delay,period)` and passing an object as a key for that timer (can be any object, for example a String).	TimerGraphStageLogic has a `ScheduleOnce` method	Holds
Read Oct 2	The `OnTimer(key)` method needs to be overridden and it will be called once the timer of key fires.	TimerGraphStageLogic has an `OnTimer` method	Holds
Read Oct 2	It is possible to cancel a timer using `CancelTimer(key)` and check the status of a timer with `IsTimerActive(key)`.	TimerGraphStageLogic has a `CancelTimer` method	Holds
Read Oct 2	It is possible to cancel a timer using `CancelTimer(key)` and check the status of a timer with `IsTimerActive(key)`.	TimerGraphStageLogic has an `IsTimerActive` method	Holds
Read Oct 2	In order to receive asynchronous events that are not arriving as stream elements (for example a completion of a task or a callback from a 3rd party API) one must acquire a `AsyncCallback` by calling `GetAsyncCallback()` from the stage logic.	GraphStageLogic has a `GetAsyncCallback` method	Holds
Read Oct 2	The difference is that in this case the method `CreateLogicAndMaterializedValue(inheritedAttributes)` needs to be overridden, and in addition to the stage logic the materialized value must be provided	GraphStageWithMaterializedValue has a `CreateLogicAndMaterializedValue` method	Holds
Read Oct 2	Cleaning up resources should be done in `GraphStageLogic.PostStop` and not in the `InHandler` and `OutHandler` callbacks.	GraphStageLogic has `PostStop`	Holds
Read Oct 2	After each incoming message, the ``ActorSubscriber` `will automatically invoke the` `IRequestStrategy.RequestDemand`` and propagate the returned demand to the stream.	IRequestStrategy has `RequestDemand`	Holds
Read Oct 2	the merge and broadcast junctions were imported into the graph using ``builder.Add(...)``, an operation that will make a copy of the blueprint that is passed to it and return the inlets and outlets of the resulting copy so that they can be wired up.	Builder has an `Add` method	Holds
Read Oct 2	This is constructed using ``GraphDSL.Create` `and returning a` `SourceShape`` from the function passed in .	GraphDsl has a `Create` method	Holds
Read Oct 2	This example demonstrates how `BidiFlow` subgraphs can be hooked together and also turned around with the ``.Reversed`` method.	BidiFlow has a `Reversed` method	Holds
Read Oct 2	The graph takes elements from the source, prints them, then broadcasts those elements to a consumer (we just used ``Sink.Ignore` `for now) and to a feedback arc that is merged back into the main stream via a` `Merge`` junction.	Sink has `Ignore`	Holds
Read Oct 2	We do this by using a ``Concat` `junction on the backwards arc that injects a single element using` `Source.Single``.	Source has `Single`	Holds

72 rules from 9 docs

See these where the change is. The browser extension puts a pull request's doc findings, and a diagram of what it changed, on the GitHub page itself, so the code and what your docs say about it are side by side.