Workable.SignalR 1.1.80726.1

• net10.0

  • Workable (>= 1.1.80726.1)
  • Workable.Abstractions (>= 1.1.80726.1)
  • Workable.AspNetCore (>= 1.1.80726.1)
  • Workable.Views (>= 1.1.80726.1)

# 1.1.080726.1

Date: 2026-08-07

## Breaking Changes

- `IWorkAuthorizationGroupProvider.GetGroups(...)` is now asynchronous and accepts a `CancellationToken`. Custom providers must return `ValueTask<IReadOnlySet<string>>` and observe cancellation.
- `IWorkSystem.CreateSession(...)` and `IWorkSystem.DescribeAccess(...)` now return `ValueTask` results because authorization-group resolution may require asynchronous I/O. Their existing unsuffixed names are retained.
- `IWorkQueueService` now requires `NotifyDurableWorkAvailable()`. Custom queue implementations, decorators, and test doubles must implement the new synchronous notification member. This source break is intentional; no default compatibility implementation is provided.

## Added

- Added `IWorkAuthorizationGroupContextProvider` and `IWorkAuthorizationGroupResolver` so invocation adapters can contribute ambient authorization groups while durable and background execution resolves groups for a persisted actor through `IWorkAuthorizationGroupProvider`.
- Added `IWorkQueueService.NotifyDurableWorkAvailable()` so applications using caller-owned durability transactions can wake the local durable queue reader immediately after a successful commit.
- Added durable lifecycle benchmark coverage for caller-owned SQL transaction commit, notification, and completion.
- Added originating-actor criteria, an actor index, and actor-keyed change notifications for worker queries and realtime invalidation, including HTTP query support.
- Added `WatchWorkers` as the discoverable worker-list form of the existing named workers view, plus `WatchMyWorkers` for a server-enforced authenticated-actor scope. Both retain the initial-snapshot and reconnect-reconciliation guarantees of named views.
- Added `CurrentIterationSequence` to worker overview rows and detailed worker-grid rows so active list items can open an iteration stream without embedding iteration output or history in every grid publication.
- Added bounded, replayable per-iteration status streams through `IWorkExecutionContext.Status`, `IWorkSystem.IterationStatuses`, and SignalR. The new surface includes actor-scoped `StreamMyIterationStatus`, sequence cursors, explicit replay-gap messages, atomically attached terminal iteration results, and configurable payload, replay, and subscription limits.
- Added actor-selectivity and iteration publication, replay, concurrency, and system-retention benchmarks.

## Changed

- ASP.NET Core authorization-group resolution now reuses the built-in HTTP claims implementation instead of requiring durable queue consumers to reproduce HTTP-specific claim parsing.
- Durable workflow recovery now resolves authorization groups asynchronously from the persisted actor, retries transient resolution failures with bounded backoff, and remains recoverable across host restarts.
- Durable workflow dispatch explicitly notifies the local queue reader after its workflow transaction commits.
- Waiting for an accepted durable worker issues one immediate reader notification but no longer lowers the configured fallback polling interval to 50 milliseconds.
- Durable queue notifications are local, coalesced while a wake is pending, and backed by fallback polling for cross-process discovery and missed signals.
- Worker-list convenience methods reuse the existing named-view subscription, seed, shared-change-stream, coalescing, authorization, and reconnect path rather than maintaining a second realtime implementation.
- SQL profile parameters now expose `IsBinaryOmitted`; the admin UI renders omitted values explicitly and generates a commented `NULL` placeholder instead of reconstructing unavailable binary data.
- System-wide iteration-status retention now uses an ordered, compacting eviction index so publication at the replay limit does not scan every historical iteration buffer.

## Fixed

- Named-view subscriptions now start their shared change stream before querying the direct seed, hold group broadcasts behind that seed, and reconcile every active state-based view after the shared stream restarts. This prevents a newer update from being overtaken by an older initial snapshot and closes changes that occur during reconnect gaps.
- `WatchWorkerOverview` now sends a complete synchronized initial snapshot, gates subsequent group updates until seeding finishes, and recomputes latest state from worker-keyed changes. Worker detail clients no longer need a separate HTTP read to avoid missing activity during subscription establishment.
- The admin UI now recognizes structured profiling context delivered as either an object or a serialized JSON object, restoring SQL command and parameter display for both representations.

## Security

- Updated the admin UI dependency tree to patched releases, including Next.js and `eslint-config-next` 16.3.0 and PostCSS 8.5.25.
- SQL profiling no longer retains binary parameter bytes. It preserves bounded parameter metadata and emits an explicit `<binary omitted>` marker and `IsBinaryOmitted` flag instead.
- Authorization snapshots are used only when their actor matches the request-context actor; mismatched snapshots are ignored and groups are resolved for the actual caller.
- Named-system HTTP routes now require real access to the selected system in addition to any configured built-in-surface group.
- Removed waiter-driven rapid fallback polling that could sustain unnecessary durable-store claim traffic while accepted callers remained waiting.
- Durable queue notification remains a trusted in-process hint and is not exposed through the built-in HTTP or MCP adapters. Repeated calls cannot build an unbounded signal backlog, though callers should not invoke it continuously without a corresponding committed enqueue.
- `WatchMyWorkers` and `StreamMyIterationStatus` derive their actor from the authenticated SignalR request context, reject callers without a stable actor id, and never trust a browser-supplied actor id for user-scoped access.
- Iteration-status access is filtered through the caller's authorized work-system session, while payload sizes and subscription counts are bounded to limit memory and fanout abuse.