Docs & rules

Altinn/altinn-studioGitHub

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 stale names in these docs.

maina117f7cLast read Oct 3

Is this yours? Install to manage it

Once installed, Striff checks every pull request.

Rules summary
Documents
Rules
33
2
2
1 stale name
2
31
23
23
19
19
4
4
4
4
4
1 stale name4
8
8
8
8
40 docs
Altinn/altinn-studioOpen repository

Stale names in these docs2

Each sentence below has a stale name: 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.

  • GoneSaveProcessStateToStorage
    Enqueue-at-commit, one workflow per side effect. A critical EnqueueSideEffectsWorkflow step runs immediately after SaveProcessStateToStorage and enqueues the side-effect commands as separate single-step sibling workflows — one per side effect — submitted as one atomic batch, where each sibling is:

    The repository once had src/App/backend/src/Altinn.App.Core/Internal/WorkflowEngine/Commands/SaveProcessStateToStorage.cs. It doesn't now.

    View on GitHub

  • GoneLayoutSetComponent
    LayoutSetComponent: Has a collection of PageComponent and represents a layout set.

    The repository once had src/App/backend/src/Altinn.App.Core/Models/Layout/LayoutSetComponent.cs. It doesn't now.

    View on GitHub

Altinn/altinn-studio — documented rules

33 of 33 rules, printed November 17, 2026.

The sentence in your docs
Prerequisites shipped separately (each valuable alone): AppCommand passes the HTTP status code into ExecutionResult so app-callback error entries carry it (today only WebhookCommand does), and the retry delay calculation gains jitter so retry waves de-synchronize with or without a breaker.
2 rules from this sentence
AppCommand depends on ExecutionResult
Holds
WebhookCommand depends on ExecutionResult
Holds
A task that does one thing implements IServiceTask and only writes Execute;
IServiceTask has Execute
Holds
a task with more than one durable step implements IPipelineServiceTask and composes its pipeline in Define:
IPipelineServiceTask has Define
Holds
A composition is zero or more Stage(...) calls and HandleReplies(...) handlers, in any order, ended by exactly one terminal — Finally(...) for work that finishes by itself or by polling, or ConcludeOnReplies(...) for work answered by a message.
2 rules from this sentence
ServiceTaskPipelineBuilder has a Stage method
Holds
ServiceTaskPipelineBuilder has a Finally method
Holds
Every stage may be retried on failure, so its work MUST be idempotent. Use ServiceTaskContext.StepId as the idempotency key for an outbound call the stage must not repeat — it is stable across retries of the same step and covers the crash window between sending and completing.
ServiceTaskContext has StepId
Holds
Completed(), Defer(delay, reason?), FailedRetryable(msg), FailedPermanent(msg).
4 rules from this sentence
ServiceTaskStageResult has a Completed method
Holds
ServiceTaskStageResult has a Defer method
Holds
ServiceTaskStageResult has a FailedRetryable method
Holds
ServiceTaskStageResult has a FailedPermanent method
Holds
The total wait is bounded by ProcessStepOptions.WaitBudget (or the engine default);
ProcessStepOptions has WaitBudget
Holds
Read ServiceTaskContext.Wait (DeferCount, StartedAt, Deadline, and the derived Remaining/IsFinalCheck) to pace the wait or give up early with a message that names what never arrived.
ServiceTaskContext has Wait
Holds
Id is the reply address, Deadline is when the mailbox stops accepting answers.
2 rules from this sentence
ServiceTaskMailbox has Id
Holds
ServiceTaskMailbox has Deadline
Holds
MailboxOptions.Timeout runs from the mint, and the deadline is absolute — no message re-arms it.
MailboxOptions has Timeout
Holds
the stage members, plus Conclude(ServiceTaskResult) for the send whose failure already settles the task — a recipient address that does not exist — where waiting out the exchange would only delay the same verdict.
ServiceTaskOpeningStageResult has a Conclude method
Holds
ConcludeOnReplies(handle, onMessage, onClosed) — the exchange the task ends on.
ServiceTaskPipelineBuilder has a ConcludeOnReplies method
Holds
HandleReplies(handle, onMessage, onClosed) — an exchange the pipeline carries on past.
ServiceTaskPipelineBuilder has a HandleReplies method
Holds
the channel that receives it (a queue subscriber, a webhook endpoint) reads the echoed mailbox id and calls ForwardReply(mailboxId, serviceTaskType, payload, idempotencyKey), doing no work of its own beyond decoding enough to forward.
IServiceTaskReplyForwarder has a ForwardReply method
Holds
FiksArkivServiceTask publishes the mailbox id as the outbound message's klientKorrelasjonsId, and FiksArkivSubscriber.IncomingMessageListener reads the echo, decrypts, and forwards.
FiksArkivSubscriber has IncomingMessageListener
Holds
It contains common properties such as Id, Type, DataModelBindings, and TextResourceBindings.
4 rules from this sentence
BaseComponent has Id
Holds
BaseComponent has Type
Holds
BaseComponent has DataModelBindings
Holds
BaseComponent has TextResourceBindings
Holds
The CommandRegistry maps type strings to ICommand singletons.
CommandRegistry depends on ICommand
Holds
The engine stores it as the step's StateOut, and each step's StateOut becomes the next step's StateIn:
Step has StateOut
Holds
Step marked Failed with error details recorded in ErrorHistory
Step has ErrorHistory
Holds
command.waitBudget (default EngineSettings.DefaultStepWaitBudget = 24h, rejected at enqueue above MaxStepWaitBudget = 14d) caps total waiting, measured from the step's first deferral (Step.FirstDeferredAt, persisted), so it survives restarts and re-fetches.
2 rules from this sentence
EngineSettings has DefaultStepWaitBudget
Holds
EngineSettings has MaxStepWaitBudget
Holds
A command reads DeferCount from CommandExecutionContext.Step and WaitDeadline from the context itself, so it can back off its own cadence adaptively — or give up early, deliberately, instead of being failed anonymously when the budget expires.
2 rules from this sentence
CommandExecutionContext has Step
Holds
CommandExecutionContext has WaitDeadline
Holds
EngineSettings.MaxMailboxTimeout caps it — the derivation is written on the setting itself and pinned by CallbackTokenLifetimeInvariantTests.
EngineSettings has MaxMailboxTimeout
Holds
33 rules from 4 docs

More open-source reports

Every report →

Other public repositories whose docs Striff read and checked against their code.