Workable.Views 1.1.71926.1

• net10.0

  • Workable.Abstractions (>= 1.1.71926.1)

# 1.1.071926.1

Date: 2026-07-19

## Added

- Added configurable canceled-child handling for `DispatchEach(...)` through `WorkflowCanceledChildBehavior.Continue`, `Block`, and `CancelWorkflow`. The selected policy is applied across non-durable execution, durable execution and recovery, joins, final child waits, outstanding-child cancellation, and operator status reporting.
- Added `WorkerActionRequest` so single-worker actions can carry an optional human-readable reason while the concise `Execute(worker, action, cancellationToken)` overload remains available.
- Added `IWorkExecutionContext.CancellationRequestContext` so running work can inspect the sanitized caller identity and reason for an accepted explicit cancellation before Workable signals the execution cancellation token. Pause, shutdown interruption, and lease loss continue to leave this value unset.
- Added `IWorkflowDispatchEachBuilder.Outputs<TOutput>()`, which returns a typed reference to each fan-out child's output and allows a later `DispatchEach(...)` step to consume those outputs without reconstructing a reference from the earlier step name.
- Added `IWorkPersistenceStore.DurableWorkersExist(...)` so persistence providers can resolve large durable-workflow fan-outs with one batched lookup. Existing providers remain compatible through a default fallback to `DurableWorkerExists(...)`; the SQL Server provider implements a single set-based query.

## Changed

- `DispatchEach(...)` defaults canceled expanded children to `Continue`, treating them as skipped after the remaining siblings settle. Select `WorkflowCanceledChildBehavior.Block` when a canceled child should stop the workflow at its next synchronization point.
- The configured `DispatchEach` cancellation policy is now part of the workflow definition fingerprint. Changing it while an incomplete durable run is retained is handled as a workflow definition mismatch.
- `CancelWorkflow` now cancels the workflow and requests cancellation of its remaining outstanding children, including active and recovered durable executions. `Block` leaves remaining siblings running and blocks at the next synchronization point, while `Continue` waits for the remaining siblings before advancing.
- Single-worker action reasons are stored in action history as `RequestContext.Description`. The HTTP adapter preserves the existing `description` wire property and maps it to `WorkerActionRequest.Reason`.
- Compatibility: the new `IWorkerOperations` request overload and `IWorkExecutionContext.CancellationRequestContext` use default interface implementations, so previously compiled direct implementations remain loadable. Implementers can override the new members to preserve cancellation reasons and expose cancellation request context.
- Refreshed the README and API, adapter, registration, queueing, workflow, authorization, querying, views, durability, and sample-host documentation to match the current runtime surfaces. Removed temporary documentation and test-audit working files after their findings were incorporated.

## Fixed

- Workflow-run and operator views now distinguish canceled fan-out children according to the configured policy instead of reporting every canceled `DispatchEach` child as blocked or canceled in the same way.
- Workflow cancellation now verifies that a canceled worker is recorded as a child of the referenced `DispatchEach` step before applying `CancelWorkflow`, including during durable recovery.
- Chained `DispatchEach` output expansion now honors the source fan-out's cancellation policy, so `Continue` skips canceled source children instead of blocking the downstream fan-out.
- Chained `DispatchEach` output expansion now treats a successfully completed empty source fan-out as an empty expansion instead of failing it as unavailable, in both durable and non-durable workflows.
- Fan-out and join execution now cancel remaining child waiters after an early blocked, canceled, or failed outcome, preventing abandoned durable polling loops.
- `CancelWorkflow` now cancels outstanding children before marking and persisting a durable workflow as canceled, so recovery cannot mistake a partially canceled run for a fully settled final run after an interruption.
- Durable joins and trailing waits now coalesce child-retention checks into bounded batched lookups instead of polling persistence once per child every 100 milliseconds. Child completions flow through a single-pass queue, and cancellation-policy resolution uses indexed child membership, avoiding quadratic task and fan-out scans as children settle.
- Durable workflow persistence is now ordered per run, with receipt writes coalesced and join progress checkpointed at exponentially decreasing thresholds. This prevents stale concurrent snapshots from erasing child receipts or final state while avoiding one full-run write per child on large fan-outs.
- Workflow cancellation is now idempotent and outcome-aware: cancellation conflicts are retried, rejected child actions keep the workflow non-final with structured errors, queued fan-outs cannot recursively re-enter cancellation, and final workflow state cannot regress during a concurrent execution handoff.
- Non-durable workflow cancellation now defers its final `Canceled` transition until outstanding child cancellation requests succeed, so a rejected sibling cancellation leaves both manual and `CancelWorkflow` policy executions blocked and recoverable.
- Chained `DispatchEach` source children are observed in completion order while their outputs retain source order, allowing a later canceled or failed child to stop the workflow without waiting behind an earlier child that never settles.
- Durable existence fallback checks now use bounded concurrency, and provider-originated cancellation completes the active lookup batch instead of leaving workflow waiters unresolved.
- Workable now replaces caller-supplied reserved workflow identifiers (`workflow-run`, `workflow-definition`, and `workflow-step`) when dispatching children, preventing conflicting metadata from breaking lifecycle validation.
- Final workers are scheduled for retention before workflow observers run, and durable child receipts are persisted independently of the child's canceled execution token, preventing slow finalization observers from leaving canceled workers untracked.
- A failed durable child-receipt write now keeps the final worker protected and is retried through retention finalization before worker cleanup, so transient persistence failures cannot remove the workflow's only recoverable child state.
- Workflow-child lifecycle events, retention decisions, completion receipts, and blocked-run auto-resume now require the claimed worker to belong to the claimed workflow step, preventing forged workflow identifiers from mutating or retaining a run.
- Explicit worker cancellation now publishes its request context before canceling executing code, so cleanup and audit logic can reliably observe the accepted cancellation caller and reason.
- Per-run persistence ordering now covers transactional commit as well as the transactional upsert call, preventing a delayed provider commit from overwriting a later workflow snapshot.
- Durable final completions now persist before publishing terminal state or settling their public workflow handles; a failed final write leaves query-visible state non-final and faults both the handle and registered execution instead of acknowledging a completion that recovery has not recorded.
- Durable workflow writes now apply their matching in-memory transition while the per-run persistence gate is still held, preventing a child receipt that arrives during final settlement, resume, or control-intent persistence from restoring an older run state.
- Durable blocked-run auto-resume now applies its in-memory `Running` transition before releasing the per-run persistence gate, preventing a queued child receipt from restoring the previously persisted `Blocked` state.
- Blocked-run auto-resume now evaluates final children after their receipts are recorded, rechecks after an earlier blocked execution finishes settling, and treats a canceled `DispatchEach` child as settled only for `Continue`. This covers both restart-then-cancel and cancel-then-restart ordering without resuming `Block` or `CancelWorkflow` runs.
- Transient durable auto-resume failures now enter one coalesced retry loop per blocked run with capped exponential backoff. Retries remain active through temporary execution or cancellation gates—including an unsuccessful competing cancellation—and concurrent requests are handed off when an existing retry retires, allowing a later persistence attempt to resume the workflow exactly once while shutdown cancels and drains pending retries.
- Accepted workflow cancellations now propagate the sanitized operator identity and reason to outstanding child cancellations. Durable pending cancellations persist that context and restore it during recovery instead of attributing child cancellation to the workflow starter.
- Accepted workflow cancellation is now a monotonic control intent: a later pause request cannot overwrite a pending durable cancellation, and a repeated cancel cannot replace the first accepted operator context while the active execution and its children are still settling.
- Workflow execution bookkeeping is registered before background execution can finish, per-run action gates are released when their callers leave, and execution settlement shares the action gate so a stale blocked completion cannot follow a concurrent final cancellation.
- Retention finalization guards no longer reschedule themselves during count-based cleanup; workers are re-registered once finalization exits without creating a tight retention loop while persistence or workflow observers are slow.
- Retention retries and workflow-protected children are now deferred until their next purge interval without remaining eligible for immediate count-based selection, preventing tight retry loops when a system is over its final-worker cap.
- Deferred retention schedules now supersede earlier queued purge deadlines for the same worker, preserving the full retry or protection interval before cleanup.
- Final durable-workflow cleanup now resolves absent child persistence in one batched lookup instead of issuing a growing number of scalar existence queries as large fan-outs are purged.
- Expanded regression coverage across authorization, dynamic registration, HTTP and MCP adapters, querying, durable queues, realtime broadcasting, view contracts, retention, worker edge cases, workflow execution, and durable workflow recovery, raising core line coverage above 95 percent.
- Added contract and end-to-end tests for typed `DispatchEach` child-output references and fluent-builder behavior, with 100 percent changed-line coverage for the new staged builder implementation.