diff --git a/.gitignore b/.gitignore index 704aa48..d878310 100644 --- a/.gitignore +++ b/.gitignore @@ -30,6 +30,8 @@ bld/ *.nupkg *.snupkg **/artifacts/ +# Exception: pre-release packages committed for CI bootstrap (removed once upstream publishes) +!eng/local-feed/*.nupkg # Test Results [Tt]est[Rr]esult*/ @@ -50,7 +52,9 @@ docs/api/ *.db-shm *.db-wal -# Aspire AppHost and UITests use RestorePackagesWithLockFile=false; exclude their -# ephemeral lock files that --use-lock-file can create at restore time. +# These projects use RestorePackagesWithLockFile=false; exclude their ephemeral +# lock files that --use-lock-file can create at restore time. src/WorkflowFramework.Dashboard.AppHost/packages.lock.json tests/WorkflowFramework.Dashboard.UITests/packages.lock.json +tests/WorkflowFramework.Extensions.Approvals.Acceptance/packages.lock.json +tests/WorkflowFramework.Extensions.Approvals.Integration.Tests/packages.lock.json diff --git a/.plan/patternkit-extension-backlog.md b/.plan/patternkit-extension-backlog.md new file mode 100644 index 0000000..25860c2 --- /dev/null +++ b/.plan/patternkit-extension-backlog.md @@ -0,0 +1,569 @@ +# PatternKit Extension Backlog + +**Source:** Phase G rejection list in `docs/patternkit-adoption.md` +**PatternKit version assessed against:** 0.105.0 +**Generated:** 2026-05-22 + +This document characterizes every step kept bespoke in Phase G and proposes the generic PatternKit primitive that would absorb each one. Generality ratings are on a 1–5 scale (5 = clearly broadly useful pattern that belongs in PatternKit; 1 = workflow-engine-specific glue that should stay bespoke). Priority is assigned by combining generality rating with the amount of bespoke code that would be deleted from WorkflowFramework. + +--- + +## Summary Table + +| Step | Proposed PatternKit Primitive | Generality | Priority | +|------|-------------------------------|-----------|----------| +| `ScatterGatherStep` | `ScatterGather` | 5 | High | +| `WireTapStep` | `WireTap` (or `FireAndForget`) | 5 | High | +| `IdempotentReceiverStep` | `IdempotencyGuard` | 5 | High | +| `MessageTranslatorStep` | `AsyncTransformer` | 5 | High | +| `ClaimCheckStep` / `ClaimRetrieveStep` | `ExternalStore` (store+retrieve pair) | 4 | High | +| `AggregatorStep` | `Aggregator` with `CompletionPolicy` | 5 | Med | +| `SplitterStep` | `FanOut` | 4 | Med | +| `NormalizerStep` | `TypeDispatchRouter` | 4 | Med | +| `TransactionalOutboxStep` | `OutboxWriter` | 3 | Med | +| `ContentEnricherStep` | `ContextMutator` (or promote `AsyncAction`) | 2 | Low | +| `ContentFilterStep` | `ContextMutator` (or promote `AsyncAction`) | 2 | Low | +| `MessageFilterStep` | `Guard` (predicate gate) | 4 | Med | +| `PollingConsumerStep` | `PollingSource` adapter primitive | 3 | Low | + +--- + +## G.2 — Composition Steps + +### `ScatterGatherStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Composition/ScatterGatherStep.cs` + +**What it does:** Broadcasts one workflow context to a fixed list of handlers running in parallel via `Task.WhenAll`. Each branch writes its result into a named context key. After the timeout fires (a linked `CancellationTokenSource`), only the branches that completed contribute to the aggregation. Per-branch errors are swallowed so one bad branch cannot abort others. + +**Why existing primitive didn't fit:** `AsyncActionComposite` supports parallel execution but has no concept of per-branch result collection, error isolation, or deadline semantics. Adding those on top would require the same amount of code as the bespoke implementation. + +**Shape of generic primitive:** A strongly-typed `ScatterGather` that fires N async functions in parallel, collects their outputs (null on error or timeout), applies a caller-supplied aggregator, and returns a `ScatterGatherResult`. Works on raw `Task` delegates — no coupling to `IWorkflowContext`. Every system that fans out to N services and merges responses (pricing engines, search aggregators, health checks) would use this. + +**Generality:** 5 + +```csharp +public sealed class ScatterGather +{ + public static Builder Create(); + + public sealed class Builder + { + // Add a branch that produces a TResult + public Builder AddBranch(Func> branch); + // Swallow per-branch exceptions (default: true) + public Builder SwallowBranchErrors(bool swallow = true); + // Overall deadline + public Builder WithTimeout(TimeSpan timeout); + public ScatterGather Build(); + } + + /// + /// Runs all branches. Partial results are returned if the deadline fires. + /// + public ValueTask> ExecuteAsync(CancellationToken ct = default); +} + +public sealed class ScatterGatherResult +{ + public IReadOnlyList Results { get; } + public bool TimedOut { get; } + public int SucceededCount { get; } +} +``` + +--- + +### `AggregatorStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Composition/AggregatorStep.cs` + +**What it does:** Collects items from a context-provided enumerable and applies a caller-supplied aggregation action. Collection stops when one of three configurable completion policies triggers: item count reached, predicate satisfied, or (in the options API, preparatory for future streaming use) a timeout fires. + +**Why existing primitive didn't fit:** No Aggregator primitive exists in PatternKit 0.105.0. The completion-policy tri-mode logic (count / predicate / timeout) is the entire feature; no existing PatternKit behavioral primitive gets close. + +**Shape of generic primitive:** A generic `Aggregator` that takes an `IEnumerable` (or `IAsyncEnumerable`) and a composable `CompletionPolicy` value type. The aggregator iterates until the policy signals done, then hands the collected window to a caller-supplied fold function. Useful in streaming, data pipeline, event-batch, and reactive systems far beyond workflow engines. + +**Generality:** 5 + +```csharp +// Completion policy is a value type to avoid allocations +public readonly struct CompletionPolicy +{ + public static CompletionPolicy AfterCount(int count); + public static CompletionPolicy When(Func, bool> predicate); + public static CompletionPolicy AfterTimeout(TimeSpan timeout); + public static CompletionPolicy All(); // collect everything +} + +public sealed class Aggregator +{ + public static Aggregator Create(CompletionPolicy policy); + + /// + /// Collects from until the policy is satisfied, + /// then returns the collected window. + /// + public IReadOnlyList Collect(IEnumerable source); + public ValueTask> CollectAsync( + IAsyncEnumerable source, + CancellationToken ct = default); +} +``` + +--- + +### `SplitterStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Composition/SplitterStep.cs` + +**What it does:** Given a delegate that extracts an `IEnumerable` from context, executes a single `IStep` once per item — either sequentially or in parallel. Tracks the current item in `__SplitterCurrentItem` and collects per-item results in `__SplitterResults`. + +**Why existing primitive didn't fit:** `AsyncActionComposite` requires all child actions to be registered at build time. `SplitterStep`'s item list is determined at execution time from context; you cannot build the composite without running first. + +**Shape of generic primitive:** A `FanOut` that takes an `IEnumerable` and a `Func>`, executes it per-item (parallel or sequential), and returns `IReadOnlyList`. Applicable in batch processing, ETL pipelines, parallel API calls, and any map-over-collection pattern. + +**Generality:** 4 + +```csharp +public sealed class FanOut +{ + public static Builder Create(); + + public sealed class Builder + { + public Builder WithProcessor(Func> processor); + public Builder Parallel(bool parallel = true); + // Optional: max degree of parallelism + public Builder MaxDegreeOfParallelism(int max); + public FanOut Build(); + } + + public ValueTask> ExecuteAsync( + IEnumerable items, + CancellationToken ct = default); +} +``` + +--- + +### `ResequencerStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Composition/ResequencerStep.cs` + +**What it does:** Pure LINQ `OrderBy` over a context-provided collection. One-liner implementation with no structural complexity. + +**Why existing primitive didn't fit:** PatternKit has no sort-pipeline primitive; wrapping with PatternKit would add indirection for zero benefit. + +**Shape of generic primitive:** No PatternKit primitive is warranted here. The implementation is three lines of LINQ. Any generic `Sort` primitive would be identical to calling `.OrderBy()` directly. **Recommended to stay bespoke.** + +**Generality:** 1 + +--- + +### `ProcessManagerStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Composition/ProcessManagerStep.cs` + +**What it does:** Implements the EIP Process Manager — a long-running correlator that picks the next step to execute by delegating to a context-reading function at runtime, re-evaluating after each step completes. + +**Why existing primitive didn't fit:** PatternKit `AsyncStateMachine` requires all states and transitions to be declared at construction time. `ProcessManagerStep` resolves its next-step delegate dynamically from mutable context; the state space is open and runtime-defined. + +**Shape of generic primitive:** A true runtime-dynamic state machine would require an entirely different abstraction from `StateMachine`. The delta from PatternKit's existing `StateMachine` is large enough that a separate `DynamicStateMachine` primitive might be warranted if multiple projects need it — but it is borderline. **Recommend: keep bespoke for now; revisit if a second consumer emerges.** + +**Generality:** 2 + +--- + +### `ComposedMessageProcessorStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Composition/ComposedMessageProcessorStep.cs` + +**What it does:** Composes SplitterStep → per-item-processor → AggregatorStep as a single pipeline step, all sourced from context delegates at runtime. + +**Why existing primitive didn't fit:** No single PatternKit primitive composes all three dynamic operations. It is a thin orchestrator over three other bespoke steps. + +**Shape of generic primitive:** Once `FanOut` and `Aggregator` exist in PatternKit, this step can be rewritten as three lines of those primitives. No separate PatternKit primitive is needed — it dissolves when its constituent primitives are promoted. + +**Generality:** 2 + +--- + +## G.3 — Channel Steps + +### `WireTapStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Channel/WireTapStep.cs` + +**What it does:** Executes a side-effect action on the current value without affecting the return path. By default, exceptions thrown by the tap action are swallowed so the main pipeline continues unaffected. Configurable to let exceptions propagate when strict auditing is needed. + +**Why existing primitive didn't fit:** `AsyncActionDecorator` wraps a component and transforms/intercepts its result. `WireTapStep` wraps nothing — it IS the side effect. The decorator pattern adds indirection without modelling "fire side-effect, return same value." + +**Shape of generic primitive:** A value-passing `WireTap` that runs one or more side-effect delegates and returns the original value unchanged. Broadly useful: observability middleware, audit logging, metrics emission, notification fanout in any pipeline or chain. The error-swallowing flag maps to `ObserveErrors` / `SwallowErrors` on the builder. + +**Generality:** 5 + +```csharp +public sealed class WireTap +{ + public static Builder Create(); + + public sealed class Builder + { + public Builder Tap(Action sideEffect); + public Builder TapAsync(Func sideEffect); + // If false, tap exceptions propagate (default: true = swallow) + public Builder SwallowErrors(bool swallow = true); + public WireTap Build(); + } + + /// + /// Runs all taps and returns unchanged. + /// + public ValueTask ExecuteAsync(T value, CancellationToken ct = default); +} +``` + +--- + +### `ChannelAdapterStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Channel/ChannelAdapterStep.cs` + +**What it does:** Sends or receives a message via an `IChannelAdapter` (abstraction over queue/topic/socket). The operation is a side effect against an external transport, not a type mapping. + +**Why existing primitive didn't fit:** PatternKit `AsyncAdapter` is a type-mapping primitive that transforms one type into another. `ChannelAdapterStep` performs an I/O side-effect; the type signature is orthogonal. + +**Shape of generic primitive:** A transport-agnostic `ChannelAdapter` primitive with pluggable send/receive contracts would be broadly useful. However, channel semantics (ack, nack, redelivery, back-pressure) vary dramatically between transports. A thin interface like `IChannelAdapter` already lives in the abstractions project. **Recommended: promote `IChannelAdapter` to PatternKit.Messaging if a Messaging namespace is planned; hold on the step wrapper itself.** + +**Generality:** 3 + +--- + +### `MessageBridgeStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Channel/MessageBridgeStep.cs` + +**What it does:** Receives from one `IChannelAdapter` and immediately forwards to another in a single atomic step. Implements the EIP Message Bridge pattern. + +**Why existing primitive didn't fit:** PatternKit Bridge connects two class hierarchies (abstraction/implementation separation). It does not model a runtime receive→forward relay between two transport endpoints. + +**Shape of generic primitive:** A `MessageRelay` or `Bridge` primitive (receive from `ISource` → publish to `ISink`) would be useful anywhere message forwarding between two transports is needed (e.g., bus-to-bus migration, fan-in). Low complexity, but the abstraction is clean. **Low priority compared to higher-complexity primitives.** + +**Generality:** 3 + +--- + +### `DeadLetterStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Channel/DeadLetterStep.cs` + +**What it does:** Extracts a dead-letter payload from context and writes it to an `IDeadLetterStore`. Implements EIP Dead Letter Channel. + +**Why existing primitive didn't fit:** PatternKit Decorator transforms inputs; it cannot catch exceptions and route them to error stores. No dead-letter primitive exists in PatternKit 0.105.0. + +**Shape of generic primitive:** A `DeadLetterChannel` primitive that accepts a failed item plus an `IDeadLetterSink`, stores it, and optionally emits an event. Useful in any resilient messaging, retry, and error-drain pipeline — well beyond workflow engines. + +**Generality:** 4 + +```csharp +public interface IDeadLetterSink +{ + ValueTask WriteAsync(T item, Exception? reason, CancellationToken ct = default); +} + +public sealed class DeadLetterChannel +{ + public static DeadLetterChannel Create(IDeadLetterSink sink); + + /// + /// Routes to the dead-letter sink. + /// Optionally attaches metadata. + /// + public ValueTask SendAsync(T item, Exception? reason = null, CancellationToken ct = default); +} +``` + +--- + +## G.4 — Endpoint Steps + +### `IdempotentReceiverStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Endpoint/IdempotentReceiverStep.cs` + +**What it does:** Decorates any `IStep` with idempotency: extracts a string message ID from context, checks it against an in-memory `HashSet` (under a plain `lock`), and skips execution if the ID has been seen before. + +**Why existing primitive didn't fit:** No idempotency primitive exists in PatternKit 0.105.0. The `HashSet + lock` implementation is correct but in-process only (no persistence, no distributed dedup). A PatternKit primitive should abstract the backing store. + +**Shape of generic primitive:** An `IdempotencyGuard` that wraps any `Func` and enforces once-and-only-once execution per key. The backing store is pluggable (`IIdempotencyStore`), with a built-in in-memory default. Useful in event consumers, webhook handlers, API retry deduplication, and any at-least-once delivery context. + +**Generality:** 5 + +```csharp +public interface IIdempotencyStore +{ + // Returns true if the key was NEW (first seen); false if already processed + ValueTask TryAddAsync(TKey key, CancellationToken ct = default); +} + +public sealed class IdempotencyGuard +{ + // In-memory default + public static IdempotencyGuard InMemory(); + // Pluggable backing store (Redis, DB, etc.) + public static IdempotencyGuard WithStore(IIdempotencyStore store); + + /// + /// Executes only if has not been seen before. + /// Returns true if action was executed; false if it was deduplicated. + /// + public ValueTask ExecuteOnceAsync( + TKey key, + Func action, + CancellationToken ct = default); +} +``` + +--- + +### `PollingConsumerStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Endpoint/PollingConsumerStep.cs` + +**What it does:** Calls `IPollingSource.PollAsync()` and writes the resulting items list into `context.Properties[ResultKey]`. The step itself is a thin adaptor; all polling policy (interval, backoff) is the caller's responsibility. + +**Why existing primitive didn't fit:** No polling primitive exists in PatternKit 0.105.0. The step is almost trivially thin — one method call. + +**Shape of generic primitive:** A `PollingLoop` primitive that adds the poll interval, back-off, and error-retry concerns that the current `IPollingSource` interface leaves to the caller. `IPollingSource` is already a good abstraction; it just needs a runner. However, because the step itself is so thin, the value is primarily in the runner/loop primitive rather than the step wrapper. **Moderate priority.** + +**Generality:** 3 + +```csharp +public sealed class PollingLoop +{ + public static Builder Create(IPollingSource source); + + public sealed class Builder + { + public Builder WithInterval(TimeSpan interval); + public Builder WithExponentialBackoff(TimeSpan initial, TimeSpan max); + public Builder OnError(Func shouldContinue); + public PollingLoop Build(); + } + + /// + /// Polls until is cancelled, calling + /// for each non-empty result. + /// + public ValueTask RunAsync( + Func, CancellationToken, ValueTask> onBatch, + CancellationToken ct = default); +} +``` + +--- + +### `TransactionalOutboxStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Endpoint/TransactionalOutboxStep.cs` + +**What it does:** Extracts a message from context via a selector delegate, calls `IOutboxStore.SaveAsync()`, and writes the returned outbox ID back into context. Implements the write half of the Transactional Outbox pattern. + +**Why existing primitive didn't fit:** No outbox primitive exists in PatternKit 0.105.0. The pattern requires coordination between the write step (this) and a background relay publisher, which PatternKit does not model. + +**Shape of generic primitive:** An `OutboxWriter` that wraps `IOutboxStore` and provides a clean typed entry point. Pairing this with an `OutboxRelay` background pump would make the full pattern reusable. `IOutboxStore` already exists in the Abstractions project and could be promoted to PatternKit.Messaging. **Moderate generality** — the pattern is universal in microservices, but the backing store contract is highly persistence-tier-specific. + +**Generality:** 3 + +```csharp +public sealed class OutboxWriter +{ + public OutboxWriter(IOutboxStore store); + + /// + /// Saves to the outbox. + /// Returns the assigned outbox message ID. + /// + public ValueTask WriteAsync(T message, CancellationToken ct = default); +} + +// Companion (separate class): background drain pump +public sealed class OutboxRelay +{ + public OutboxRelay(IOutboxStore store, Func publisher); + public ValueTask DrainAsync(int batchSize = 100, CancellationToken ct = default); +} +``` + +--- + +## G.5 — Transformation Steps + +### `MessageTranslatorStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Transformation/MessageTranslatorStep.cs` + +**What it does:** Pulls `TIn` from context using a selector, calls `IMessageTranslator.TranslateAsync()`, and writes `TOut` back into context under a named key. Bridges a typed async conversion contract into the workflow context bag. + +**Why existing primitive didn't fit:** PatternKit `AsyncAdapter` requires constructing with a fixed conversion function and does not integrate with a named-service interface (`IMessageTranslator`) or participate in context key routing. The mismatch is minor — this is one of the strongest adoption candidates. + +**Shape of generic primitive:** An `AsyncTransformer` that takes any `Func>` (or the `IMessageTranslator` interface as an overload) and applies it. This is strictly more composable than `AsyncAdapter` — it is a pure function wrapper with no side-effect coupling. Useful in mapping pipelines, serialization chains, ML pre-processing, ETL, and anywhere a typed async transform is needed. + +**Generality:** 5 + +```csharp +public sealed class AsyncTransformer +{ + public static AsyncTransformer FromFunc( + Func> func); + + public static AsyncTransformer FromTranslator( + IAsyncTranslator translator); + + public ValueTask TransformAsync(TIn input, CancellationToken ct = default); +} + +// Thin interface PatternKit can own (aligns with IMessageTranslator, renamed for generality) +public interface IAsyncTranslator +{ + ValueTask TranslateAsync(TIn input, CancellationToken ct = default); +} +``` + +--- + +### `ContentEnricherStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Transformation/ContentEnricherStep.cs` + +**What it does:** Accepts a single `Func` and calls it. Provides a named wrapper (`ContentEnricher`) around an arbitrary async context-mutation action. No structural logic; purely a named step. + +**Why existing primitive didn't fit:** No enricher primitive was assessed. The implementation is so thin it is essentially a named lambda adapter. + +**Shape of generic primitive:** Could be absorbed by a general `ContextMutator` primitive, but this would just be a renamed `Action` wrapper. The value is in the name, not the structure. **Recommend: keep bespoke; not worth a PatternKit primitive at this granularity.** + +**Generality:** 2 + +--- + +### `ContentFilterStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Transformation/ContentFilterStep.cs` + +**What it does:** Structurally identical to `ContentEnricherStep` — a single `Func` with a different name (`ContentFilter`). Strips fields from context rather than adding them. + +**Why existing primitive didn't fit:** Same reasoning as `ContentEnricherStep` — no structural complexity to abstract. + +**Shape of generic primitive:** Same as `ContentEnricherStep` analysis — not worth a PatternKit primitive. A general `AsyncAction` or `ContextMutator` primitive would cover both, but both steps would become one-liners at the call site anyway. **Recommend: keep bespoke; consolidate with `ContentEnricherStep` into a shared internal base if desired.** + +**Generality:** 2 + +--- + +### `NormalizerStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Transformation/NormalizerStep.cs` + +**What it does:** Detects the incoming data format using a delegate, looks up a matching `IStep` in a `Dictionary`, and dispatches to it. Falls back to a default translator if the format is unknown. Throws if neither is found. + +**Why existing primitive didn't fit:** PatternKit's `AsyncActionStrategy` (used by `ContentBasedRouterStep`) builds its predicate/handler pairs at construction time and evaluates them in order. `NormalizerStep` uses a keyed dictionary lookup (O(1)) not a sequential predicate scan. + +**Shape of generic primitive:** A `TypeDispatchRouter` — a keyed dispatch table that maps a runtime-computed discriminator key to an action/handler, with an optional default case. Broadly useful: format routing, command dispatch, event handlers, variant execution — any "switch on a runtime string/enum and execute the matching handler" pattern. + +**Generality:** 4 + +```csharp +public sealed class TypeDispatchRouter + where TKey : notnull +{ + public static Builder Create(); + + public sealed class Builder + { + public Builder Register(TKey key, Func handler); + public Builder WithDefault(Func fallback); + // Throw if no match and no default (default behavior) + public Builder ThrowIfUnmatched(bool shouldThrow = true); + public TypeDispatchRouter Build(); + } + + public ValueTask DispatchAsync(TKey key, TTarget target, CancellationToken ct = default); +} +``` + +--- + +### `ClaimCheckStep` / `ClaimRetrieveStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Transformation/ClaimCheckStep.cs` + +**What it does:** `ClaimCheckStep` stores a large payload in an `IClaimCheckStore` and writes the resulting claim ticket string into context. `ClaimRetrieveStep` reads the ticket from context and retrieves the payload, writing it back under a configurable key. The two steps are designed to be used as a matched pair flanking a pipeline that needs to carry only a lightweight reference. + +**Why existing primitive didn't fit:** No claim-check primitive exists in PatternKit 0.105.0. PatternKit Decorator transforms inputs in place; it does not model external reference storage with a retrieve step. + +**Shape of generic primitive:** An `ExternalStore` primitive (or `ClaimCheck`) that owns the store-and-retrieve pair. The key insight is the generic ticket type — making it `string` is a design choice that should be preserved or made configurable. Useful in any pipeline where oversized payloads need to be offloaded: file processing, ML inference, document transformation, cross-service data handoff. + +**Generality:** 4 + +```csharp +public interface IExternalStore +{ + ValueTask StoreAsync(T payload, CancellationToken ct = default); + ValueTask RetrieveAsync(string ticket, CancellationToken ct = default); +} + +public sealed class ExternalStore +{ + public ExternalStore(IExternalStore store); + + /// Stores payload; returns the claim ticket. + public ValueTask StoreAsync(T payload, CancellationToken ct = default); + + /// Retrieves payload using a previously obtained ticket. + public ValueTask RetrieveAsync(string ticket, CancellationToken ct = default); +} +``` + +--- + +### `MessageFilterStep` + +**File:** `src/WorkflowFramework.Extensions.Integration/Routing/MessageFilterStep.cs` + +**What it does:** Evaluates a single synchronous `Func` predicate. If it returns false, sets `context.IsAborted = true` and returns. One of the simplest implementations in the codebase — but the pattern (predicate gate that halts a pipeline) recurs everywhere. + +**Why existing primitive didn't fit:** PatternKit.Core 0.105.0 does not expose a standalone predicate/guard primitive. Strategy is overkill for a single boolean. + +**Shape of generic primitive:** A `Guard` primitive — a lightweight predicate gate that conditionally blocks execution. Useful as a composable building block in pipelines, interceptors, authorization checks, and circuit-breaker logic. The guard can throw, return false, or call a fallback on mismatch. + +**Generality:** 4 + +```csharp +public sealed class Guard +{ + public static Guard When(Func predicate); + public static Guard WhenAsync(Func> predicate); + + /// + /// Returns true if the guard passes; false if blocked. + /// Optionally invokes when predicate fails. + /// + public ValueTask EvaluateAsync( + T value, + Func? onBlocked = null, + CancellationToken ct = default); +} +``` + +--- + +## Notes on Steps Outside G.4/G.5 Scope + +The following steps from the adoption doc are bespoke for architectural reasons and are not candidates for PatternKit primitives: + +- **`RoutingSlipStep`** — Dynamic itinerary from context; PatternKit `AsyncActionChain` is construction-time only. Stay bespoke. +- **`DynamicRouterStep`** — Routing function produces a different step each iteration from evolving context (feedback loop). No static primitive models this. Stay bespoke. +- **`RecipientListStep`** — Recipients resolved from context at execution time. `AsyncActionComposite` requires build-time registration. Stay bespoke. +- **`ResequencerStep`** — Three lines of LINQ. No abstraction warranted. +- **`ProcessManagerStep`** / **`ComposedMessageProcessorStep`** — Runtime-dynamic state; dissolves naturally once constituent primitives (`FanOut`, `Aggregator`) are promoted to PatternKit. diff --git a/.plan/patternkit-iteration-2.md b/.plan/patternkit-iteration-2.md new file mode 100644 index 0000000..3ec04eb --- /dev/null +++ b/.plan/patternkit-iteration-2.md @@ -0,0 +1,334 @@ +# PatternKit Adoption — Iteration 2 Plan + +**Branch (target):** `feat/consume-patternkit-0.113+` (after PatternKit ships extensions) +**Date drafted:** 2026-05-22 +**Author:** Claude Opus 4.7 (planning agent) +**Predecessor:** `feat/consume-patternkit-0.112` (PR #25) + `docs/patternkit-followup.md` + +This plan resolves the 7 deferrals captured during the 0.112.0 adoption pass. For each +deferral we pick one of three paths: + +- **A — Extend PatternKit:** add a new variant/overload upstream, then adopt in WF. +- **B — Change WF behavior to match PatternKit:** delete bespoke code, update tests with rationale. +- **C — Keep bespoke:** truly WF-specific glue; document the dead end. + +User direction: **strongly prefer A or B**. C only when no cross-project value exists. + +--- + +## Decision Matrix + +| # | Step | Path | PatternKit work | WF work | Effort | Priority | +|---|------|------|-----------------|---------|--------|----------| +| 1 | NormalizerStep | **A** | Add `KeyedNormalizer` | Swap NormalizerStep to wrap it; keep dictionary contract intact | M | P1 | +| 2 | ContentEnricherStep | **C** | none | none (document why) | S | P3 | +| 3 | ClaimCheckStep / ClaimRetrieveStep | **A + B** | Add untyped-payload overload `IClaimCheckStore` convenience adapter + `ClaimCheck` builder that accepts caller-supplied `claimId` and `MessageHeaders.Empty` | Migrate `WorkflowFramework.Extensions.Integration.Abstractions.IClaimCheckStore` to a thin facade over `PatternKit.IClaimCheckStore`; swap steps | L | P2 | +| 4 | IdempotentReceiverStep | **B** | none | Switch from "set.Add before inner" to PatternKit semantics: claim → invoke → mark Completed/Failed; failure allows retry. Replace HashSet with `IIdempotencyStore` (default in-memory). Update characterization test `ReAttemptAfterExceptionIsSkipped` → `ReAttemptAfterExceptionIsAllowed` with rationale comment | M | P1 (bug fix) | +| 5 | PollingConsumerStep | **A** | Add `PollOnceAsync(handler, ct)` to `AsyncPollingConsumer` (single-shot equivalent of `RunAsync`) | Swap PollingConsumerStep to call `PollOnceAsync`; preserve `ResultKey` write contract | S | P1 | +| 6 | ScatterGatherStep | **A + B** | (no new PatternKit primitive required — 0.112 already has `AsyncScatterGather` with `CompletionStrategy.AllOrTimeout`) — but add a public `RecipientHandler` helper that accepts an `IStep` + `IWorkflowContext` adapter (lives in WF, not PK) | Refactor handler contract: each `IStep` returns its `__Result_{Name}` value as the typed response; aggregator wraps PatternKit envelopes; deprecate shared-context fan-out write path; UPDATE `ScatterGatherStepTests.cs` to assert envelope-based outputs (still surface `ResultsKey` for back-compat) | L | P2 | +| 7 | TransactionalOutboxStep | **A + B** | Add an untyped convenience: `IOutboxStore` overloads + `OutboxMessage` access pattern (already typed; just need clean adoption) | Migrate `WorkflowFramework.Extensions.Integration.Abstractions.IOutboxStore` to thin facade over `PatternKit.IOutboxStore`; swap step; write `OutboxIdKey = result.Id` | M | P2 | + +**Path tally:** A=2, B=1, A+B=3, C=1. **Dominant pattern: A+B combined adoptions** — the +WF Abstractions layer (`IClaimCheckStore`, `IOutboxStore`) needs to be re-rooted on PatternKit's +typed interfaces, after which the steps become trivial pass-throughs. + +--- + +## Per-step Detail + +### 1. NormalizerStep → Path A (extend PatternKit) + +**Rationale.** Keyed string-discriminator dispatch is a legitimate, broadly useful variant +distinct from PatternKit's predicate-first design. Other projects that translate +format-tagged messages (CSV/JSON/Avro by header) need the same O(1) keyed dispatch. +Forcing every keyed lookup into a predicate chain is a real perf and ergonomics regression. + +**API sketch.** + +```csharp +namespace PatternKit.Messaging.Transformation; + +public sealed class KeyedNormalizer + where TKey : notnull +{ + public delegate TKey KeySelector(TRaw raw); + public delegate ValueTask AsyncNormalizerHandler(TRaw raw, CancellationToken ct); + + public static Builder Create(string name, KeySelector keySelector); + + public ValueTask> NormalizeAsync(TRaw raw, CancellationToken ct = default); + + public sealed class Builder + { + public Builder For(TKey key, AsyncNormalizerHandler handler); + public Builder Default(AsyncNormalizerHandler handler); + // Optional: customise miss-reason formatter so WF test can pin format key in message + public Builder OnMissReason(Func formatter); + public KeyedNormalizer Build(); + } +} +``` + +**Effort:** M (≈250 LOC + tests in PatternKit; ≈30 LOC change in WF). + +**WF adoption:** `NormalizerStep` becomes a wrapper over `KeyedNormalizer` with the format-detector as the `KeySelector` and a custom `OnMissReason` that yields the exact existing error string. Test `UnknownFormatNoDefaultThrows` passes without modification. + +--- + +### 2. ContentEnricherStep → Path C (keep bespoke) + +**Rationale.** `ContentEnricherStep` is a 3-line wrapper around `Func`. +It exists only to give the delegate a `Name` and `IStep` shape so the workflow engine can +order/inspect it. There is no payload, no copy, no error policy — it is workflow-engine glue. +PatternKit's `AsyncContentEnricher` solves a different problem (functional payload +augmentation with per-step audit). Adopting it would force every WF user to invent a fake +payload type and add ~10 lines of builder setup to replace 3 lines. + +**Why no Path A is worthwhile.** A new `AsyncSideEffectEnricher` primitive would +essentially be "named delegate with Name property" — the abstraction adds no value beyond what +`IStep` itself already provides in WF. Other projects don't need it because they don't have +the `IStep`/`IWorkflowContext` constraint. + +**Action:** add a `// Path C — kept bespoke per .plan/patternkit-iteration-2.md` header +comment to the source file. No code change. No PR. + +--- + +### 3. ClaimCheckStep / ClaimRetrieveStep → Path A + B + +**Rationale.** PatternKit's typed `IClaimCheckStore` is the better contract +(typed payload, headers for traceability, caller-supplied claim ID for determinism). +WF's untyped `IClaimCheckStore` is a legacy shape. We adopt PatternKit's interface as +the source of truth and provide a back-compat shim during the migration window. + +**Path A — PatternKit extension.** Add an `IClaimCheckStore` convenience overload +that accepts a null/empty `MessageHeaders` (`MessageHeaders.Empty` already exists). This +unblocks projects that don't yet have typed payloads. + +**Path B — WF behavior change.** +- Migrate `WorkflowFramework.Extensions.Integration.Abstractions.IClaimCheckStore` to a thin + facade interface that documents itself as a back-compat shim and delegates to + `IClaimCheckStore`. +- `ClaimCheckStep` and `ClaimRetrieveStep` consume `IClaimCheckStore` directly. +- Claim IDs become deterministic: WF generates a stable `Guid.NewGuid().ToString("N")` and + passes it as `claimId`, rather than receiving one back from the store. + +**Tests to update.** `ClaimCheckStepTests.cs` — ID generation moves from the store to the +step; assertions on store-returned IDs become assertions on the value placed in +`ClaimTicketKey`. Same behavioral outcome. + +**Back-compat.** Keep the old `IClaimCheckStore` interface deprecated (with `[Obsolete]`) for +one release. Provide an in-tree adapter `LegacyClaimCheckStoreAdapter` that implements +`IClaimCheckStore` over the legacy untyped interface so existing integrations keep +working until they migrate. + +**Effort:** L (interface migration + adapter + step rewrite + test updates). + +--- + +### 4. IdempotentReceiverStep → Path B (change WF; PatternKit is correct) + +**Rationale.** This is the textbook case for Path B — the bespoke "lock the ID at ingress, +permanently dedupe even on failure" behavior is a **latent bug**. A transient infrastructure +failure in the inner step locks the message ID forever; any retry (which is exactly what +idempotency-with-retry is supposed to enable) is silently swallowed. PatternKit's claim → +invoke → mark Completed/Failed semantics are the correct production behavior: dedupe a +*completed* attempt, allow retry of a *failed* attempt. + +**What WF behavior changes.** +- Replace the private `HashSet _processedIds` with an injected `IIdempotencyStore` + (PatternKit interface). Provide an `InMemoryIdempotencyStore` default in the step's parameterless ctor for back-compat. +- Wrap the inner step invocation in a try/catch: on success → `MarkCompletedAsync(key, result: null)`; on exception → `MarkFailedAsync(key, ex.Message)`, then rethrow. +- A repeat call with the same key in `Failed` status returns `Claimed = false` and resets to `Processing` — the inner step IS invoked again. + +**Tests to update.** +- Rename `ReAttemptAfterExceptionIsSkipped` → `ReAttemptAfterExceptionIsAllowed`. +- Assertion flips from "inner not called second time" to "inner IS called second time". +- Add a comment block on the test: + > Behavior change rationale: the bespoke pre-call HashSet.Add was a latent bug. A + > transient inner-step failure should not lock out future retries. PatternKit's + > `IdempotentReceiver` provides the correct claim → invoke → + > mark-Completed/Failed semantics. See `.plan/patternkit-iteration-2.md` §4. +- Keep `DuplicateAfterSuccessIsSkipped` exactly as-is (completed-status dedupe still works). + +**Backward-compat.** SemVer minor bump for the WF extensions package. Release notes call this +out as a "fix" (it removes a silent dedup hazard). Consumers who depended on the bug-as-feature can +opt back in by injecting a custom `IIdempotencyStore` that treats Failed as "stay-locked". + +**Effort:** M. + +--- + +### 5. PollingConsumerStep → Path A (extend PatternKit) + +**Rationale.** A single-shot poll is genuinely useful outside WF — any cron-tick consumer +(Azure Function, AWS Lambda, scheduled background job) wants to poll once, hand the result to a +handler, then exit. PatternKit's `AsyncPollingConsumer` already encapsulates the source +contract, jitter, and back-off compute; exposing a `PollOnceAsync` simply skips the loop. + +**API sketch.** + +```csharp +public sealed class AsyncPollingConsumer +{ + // Existing: + public ValueTask RunAsync(AsyncMessageHandler handler, MessageContext? ctx, CancellationToken ct); + + // New (Path A addition): + /// + /// Performs a single poll cycle: invokes the source once, calls the handler if a message + /// is produced, and returns. Does not loop, does not sleep, does not apply back-off. + /// Useful when the consumer is driven externally (cron, workflow tick, test). + /// + public ValueTask PollOnceAsync( + AsyncMessageHandler handler, + MessageContext? context = null, + CancellationToken cancellationToken = default); +} +``` + +Returns `true` if a message was processed, `false` if the poll was empty. WF maps the result +to its `ResultKey` context property (preserving the IReadOnlyList contract by wrapping the +single message in a list — or, better, generalising `PollOnceAsync` to surface the +raw message and letting WF wrap it). + +**Effort:** S (≈40 LOC in PatternKit + 4 tests; ≈15 LOC change in WF). + +**Lifecycle clarification.** WF's `IPollingSource` returns `IReadOnlyList` (batch). The +adoption either (a) keeps WF's `IPollingSource` and uses `PollOnceAsync` as scaffolding only, +or (b) introduces a second `IPollingSource.PollOneAsync()` overload in WF Abstractions for +the single-message contract. Defer (b) to a follow-up — (a) gets the adoption done. + +--- + +### 6. ScatterGatherStep → Path A + B + +**Rationale.** PatternKit's `AsyncScatterGather` with `CompletionStrategy.AllOrTimeout` and +`ResponseEnvelope` already provides the timeout, per-branch error isolation, and +partial-result semantics WF needs. What WF *also* needs is to stop using shared-context +mutation as the result transport — that pattern is a concurrency hazard. The right answer is to +adopt PatternKit AND refactor handlers to return typed values. + +**Path A — small PatternKit-side helper.** No new core primitive required. Add a small docs +sample showing the `IStep`-as-recipient pattern; if requested, add a `WorkflowRecipientAdapter` +extension class (in PatternKit or a new `PatternKit.Workflow.Adapters` package) that wraps an +`IStep` + result-key into an `AsyncRecipientHandler`. Optional; the wrap can live in WF. + +**Path B — WF behavior change.** +- New `ScatterGatherStep` recipient contract: each recipient is a `(string name, Func>)` pair rather than an `IStep` that writes to a shared key. +- Step builds `AsyncScatterGather>` with `CompletionStrategy.AllOrTimeout(timeout)`. +- Aggregator unpacks envelopes (`envelopes.Where(e => e.Succeeded).Select(e => e.Response)`) into the `ResultsKey` list — preserving the public output contract. +- The `__Result_{handler.Name}` convention is deprecated. Tests that pin those individual keys + are rewritten to assert against the envelope list or the aggregated `ResultsKey`. + +**Tests to update.** `ScatterGatherStepTests.cs` — every scenario that reads +`context.Properties[$"__Result_{name}"]` is rewritten to read the envelope list. Behavior +identical from the workflow author's perspective (the aggregated `ResultsKey` is unchanged); the +internal handler-output transport changes. + +**Backward-compat.** Major bump for the recipient contract (this is a public API change in WF). +Provide an obsoleted overload accepting `IEnumerable` that internally adapts via an +`IStep`-to-recipient bridge for one release, then remove. + +**Effort:** L (recipient contract migration + test rewrite + adapter + docs). + +--- + +### 7. TransactionalOutboxStep → Path A + B + +**Rationale.** Same story as ClaimCheck (#3). PatternKit's typed `IOutboxStore` + +`OutboxMessage` is the right contract (typed payload, dispatched/attempt tracking, +deterministic IDs). WF's `IOutboxStore` predates it and was untyped. Adopt PatternKit as the +source of truth. + +**Path A — PatternKit extension.** Likely unnecessary: `IOutboxStore` already works +with `Message`. If WF integrations need it, add a small `OutboxStoreExtensions.EnqueuePayloadAsync(this IOutboxStore store, TPayload payload, …)` +overload that constructs the `Message` envelope internally. ≈10 LOC. + +**Path B — WF behavior change.** +- Re-root `WorkflowFramework.Extensions.Integration.Abstractions.IOutboxStore` as a thin + facade over `IOutboxStore` (mirroring ClaimCheck approach). +- `TransactionalOutboxStep` consumes `IOutboxStore` directly: + + ```csharp + var msg = new Message(payload, MessageHeaders.Empty); + var record = await _store.EnqueueAsync(msg, id: null, createdAt: null, ct); + context.Properties[OutboxIdKey] = record.Id; + ``` +- Provide `LegacyOutboxStoreAdapter : IOutboxStore` over the deprecated + `WF.IOutboxStore` for one release window. + +**Tests to update.** `TransactionalOutboxStepTests.cs` — `OutboxIdKey` is now sourced from +`record.Id` rather than `SaveAsync`'s return — same value, different code path. Existing +assertions on the stored payload need a wrapping change (`Payload` → `Message.Payload`). + +**Backward-compat.** Minor bump with `[Obsolete]` on the legacy interface; remove next major. + +**Effort:** M. + +--- + +## Execution Sequence + +Three sequential phases. Within each phase, work is parallelizable across multiple PRs. + +### Phase 1 — PatternKit extensions (one upstream PR, blocked on PatternKit maintainer) + +Single PR titled **"Add keyed normalizer + single-shot polling consumer + outbox payload convenience"**: + +1. `KeyedNormalizer` + tests (NormalizerStep adoption unblock) +2. `AsyncPollingConsumer.PollOnceAsync` + tests (PollingConsumerStep adoption unblock) +3. `OutboxStoreExtensions.EnqueuePayloadAsync` convenience + tests (TransactionalOutboxStep ergonomics) + +Ship as `PatternKit 0.113.0`. ScatterGather and ClaimCheck need NO upstream changes — +PatternKit 0.112.0 already has the required surface; only WF-side changes are needed. + +**Effort total:** M+S+S = ≈400 LOC + tests in one PatternKit PR. + +### Phase 2 — WF refactor PR #1: drop-in adoptions (after 0.113.0 ships) + +Single WF PR titled **"feat: adopt PatternKit 0.113 — NormalizerStep / PollingConsumerStep / IdempotentReceiverStep"**: + +- NormalizerStep → KeyedNormalizer (no test changes) +- PollingConsumerStep → PollOnceAsync (no test changes) +- IdempotentReceiverStep → IdempotentReceiver behavior fix (test rename + assertion flip with documented rationale) + +These three are independent and the behavioral change (IdempotentReceiver) is isolated to its +own characterization test set. Ship as one PR for atomic review. + +### Phase 3 — WF refactor PR #2: interface migrations (larger, separate review) + +Single WF PR titled **"feat!: migrate IClaimCheckStore / IOutboxStore / ScatterGather recipient contract to PatternKit"** (major bump): + +- ClaimCheckStep / ClaimRetrieveStep → `IClaimCheckStore` + legacy adapter +- TransactionalOutboxStep → `IOutboxStore` + legacy adapter +- ScatterGatherStep → typed recipient contract + envelope-based aggregation + legacy `IStep` adapter + +These three share the same shape (untyped → typed abstraction migration + legacy adapter ++ test rewrite) and benefit from being reviewed together. + +### Phase 4 — Path C documentation (no PR; comment-only) + +Add a header comment to `ContentEnricherStep.cs` linking to this plan and explaining the +"workflow-engine glue, no broader pattern" reasoning. Update `docs/patternkit-adoption.md` to +move ContentEnricherStep from "Future Evaluation Targets" to "Intentionally Bespoke" with +the Path C rationale. + +--- + +## Summary Of Outcomes (post-plan) + +| Step | After Iteration 2 | +|------|-------------------| +| NormalizerStep | Wraps `KeyedNormalizer` | +| ContentEnricherStep | Bespoke, documented Path C | +| ClaimCheckStep / ClaimRetrieveStep | Consume `IClaimCheckStore`; legacy adapter retained 1 release | +| IdempotentReceiverStep | Wraps `IdempotentReceiver<…>`; bug fixed; characterization test rewritten | +| PollingConsumerStep | Wraps `AsyncPollingConsumer.PollOnceAsync` | +| ScatterGatherStep | Wraps `AsyncScatterGather<…>` with `AllOrTimeout` strategy; typed recipient contract | +| TransactionalOutboxStep | Consumes `IOutboxStore`; legacy adapter retained 1 release | + +**Bespoke code deleted (estimate):** ~280 LOC across the 6 adopted steps. +**Latent bugs fixed:** 1 (IdempotentReceiver dedup-on-failure). +**Legacy adapters added:** 2 (IClaimCheckStore, IOutboxStore) — removable next major. +**Tests rewritten (count):** ~6 scenarios across 3 test files (IdempotentReceiver, ScatterGather, Outbox). diff --git a/.plan/tinybdd-patternkit-execution-plan.md b/.plan/tinybdd-patternkit-execution-plan.md new file mode 100644 index 0000000..34cb522 --- /dev/null +++ b/.plan/tinybdd-patternkit-execution-plan.md @@ -0,0 +1,423 @@ +# TinyBDD Coverage + PatternKit Adoption — Phased Execution Plan + +**Repo:** `C:\git\WorkflowFramework` (GitHub: `jerrettdavis/WorkflowFramework`) +**Companion:** `C:\git\PatternKit` (GitHub: `jerrettdavis/PatternKit`, NuGet: `PatternKit`) +**Working branch:** `feat/tinybdd-coverage` +**End state:** All phases merged green to `main` via independent PRs (or an explicit stacked series). + +--- + +## Cross-Cutting Rules + +These rules apply to **every** phase. Violating any of them is a blocker for merge. + +1. **One phase = one PR.** Each phase must be independently mergeable. The next phase may not start until the previous PR is green on CI and merged (or explicitly stacked). +2. **Public API is frozen.** PatternKit adoption is internal-only — wrap, don't replace. Any change to public surface needs a separate API-evolution PR. If a public type would shift, fall back to an internal helper. +3. **TinyBDD style is mandatory for new tests.** `[Scenario("...")] [Fact]` on `async` methods. Inherit `WorkflowFramework.Tests.TinyBDD.Support.TinyBddTestBase(ITestOutputHelper)`. Use `Given(...).When(...).Then(...)` and the shared `ScenarioExpect` helper. xUnit `[Fact]/[Theory]` alone is not acceptable for new coverage. +4. **Multi-target green.** Tests run on `net8.0`, `net9.0`, `net10.0` and must pass on all three on CI (`.github/workflows/ci.yml`). +5. **Conventional commits** per `memstack.md`: `feat(phase-X): ...`, `test(phase-X): ...`, `refactor(phase-X): ...`, `chore(phase-X): ...`. Scope = phase ID. +6. **No `--no-verify`.** No skipping pre-commit hooks, no bypassing CI checks, no force pushes to `main`/`feat/tinybdd-coverage` shared base. +7. **Coverage may not regress.** Every PR must hold or improve line coverage on the project(s) it touches. CI gate enforces `codecov.yml` thresholds. +8. **Behavioral equivalence first.** When swapping a bespoke implementation for a PatternKit-backed one, the *first* commit in that phase must be a TinyBDD scenario set that pins current behavior. The *second* commit does the swap. Diff = green-on-both-sides. +9. **No PatternKit prerelease pins.** Use stable NuGet versions only. Pin the version in `Directory.Packages.props`, not in individual `.csproj` files. +10. **Compensation paths get explicit scenarios.** Any state-machine or saga adoption must include a failing-step → compensate path in TinyBDD coverage, not just the happy path. + +--- + +## Quick Wins (Do First — Land Each Within One Small PR) + +These are independent, one-PR-each warmups that build muscle memory for the bigger phases and visibly raise the project count before Phase D begins. Order is loose; any can be done in parallel by separate sessions. + +### QW-1 — Add `Extensions.Polly` test project skeleton +- **Scope:** Create `tests/WorkflowFramework.Extensions.Polly.Tests/` with `.csproj` mirroring an existing test project (e.g., `WorkflowFramework.Tests.TinyBDD.csproj`), reference `src/WorkflowFramework.Extensions.Polly`, add one smoke scenario for `ResilienceMiddleware` and one for `WorkflowBuilderPollyExtensions`. +- **Tests:** ~6 scenarios. +- **Done:** Project compiles on net8/9/10, green in CI. + +### QW-2 — `Specification` for `DefaultWorkflowValidator` +- **Scope:** Add `PatternKit` package ref to `src/WorkflowFramework`. Introduce an internal `WorkflowSpec` (composed of `HasAtLeastOneStep`, `NoDuplicateStepNames`) using `PatternKit.Core.Behavioral` Specification pattern (or fall back to a plain composable `IWorkflowRule` if Specification isn't there). `DefaultWorkflowValidator` delegates to it. Public API unchanged. +- **Tests:** Add `tests/WorkflowFramework.Tests.TinyBDD/Core/Validation/DefaultWorkflowValidatorScenarios.cs` — ~8 scenarios covering empty steps, duplicate names (case-insensitive), success path, null guard. +- **Done:** Coverage on `src/WorkflowFramework/Validation/` ≥ 95%, CI green. + +### QW-3 — `StateMachine` pilot for `WorkflowStatus` transitions +- **Scope:** Add an internal `WorkflowStatusMachine` in `src/WorkflowFramework/Internal/` using PatternKit `Behavioral.State.StateMachine`. Allowed transitions: `Pending→Running`, `Running→Completed`, `Running→Faulted`, `Running→Compensated` (via compensation event), `Running→Aborted`, `Running→Suspended`, `Suspended→Running`. Wire it as an *advisory* observer of existing `WorkflowEngine` transitions — engine remains authoritative. +- **Tests:** `tests/WorkflowFramework.Tests.TinyBDD/Core/WorkflowStatusMachineScenarios.cs` — ~12 scenarios covering legal and illegal transitions, idempotent terminal states. +- **Done:** No public API change; advisory layer can be removed in one revert if PatternKit StateMachine doesn't fit. CI green. + +### QW-4 — `Extensions.Reactive` test project skeleton +- **Scope:** Create `tests/WorkflowFramework.Extensions.Reactive.Tests/` with TinyBDD style from-the-start. Cover `IAsyncStep` (single happy path, single fault, cancellation). 1 file, ~5 scenarios. +- **Done:** Project compiles + green, multi-target. + +### QW-5 — `Extensions.Expressions` test project skeleton +- **Scope:** Create `tests/WorkflowFramework.Extensions.Expressions.Tests/`. Cover `SimpleExpressionEvaluator` (literals, simple arithmetic, variable lookup, missing variable), `TemplateEngine` (substitution, escaping), `ExpressionBuilderExtensions` (wires into builder). ~10 scenarios. +- **Done:** Project compiles + green, multi-target. Establishes baseline for Phase F PatternKit `Interpreter` adoption. + +**Cumulative Quick-Wins payoff:** +4 projects under TinyBDD coverage, ~41 new scenarios, first PatternKit reference landed, no public API churn. + +--- + +## Phase D — Core Engine BDD Coverage *(HIGHEST PRIORITY)* + +### Goal +Reach near-complete TinyBDD coverage of the workflow execution path (`src/WorkflowFramework/`) so subsequent PatternKit adoptions have a behavioral safety net. + +### Scope (src targets — already present, need coverage) +- `src/WorkflowFramework/WorkflowEngine.cs` +- `src/WorkflowFramework/Builder/WorkflowBuilder.cs` +- `src/WorkflowFramework/Builder/WorkflowBuilder{TData}.cs` +- `src/WorkflowFramework/Builder/WorkflowBuilderExtensions.cs` +- `src/WorkflowFramework/Builder/IConditionalBuilder.cs` + `IParallelBuilder.cs` +- `src/WorkflowFramework/Internal/ConditionalStep.cs` +- `src/WorkflowFramework/Internal/LoopSteps.cs` +- `src/WorkflowFramework/Internal/ParallelStep.cs` +- `src/WorkflowFramework/Internal/DelegateStep.cs` +- `src/WorkflowFramework/Internal/TypedStepAdapter.cs` + `TypedWorkflowAdapter.cs` +- `src/WorkflowFramework/Pipeline/Pipeline.cs` + `IPipelineStep.cs` (+ a PipelineBuilder if it exists; add scenarios if found) +- `src/WorkflowFramework/Registry/WorkflowRegistry.cs` +- `src/WorkflowFramework/Checkpointing/WorkflowResumeEngine.cs` (fill the gaps left by the partial coverage) +- `src/WorkflowFramework/Triggers/CronExpression.cs`, `TriggerSourceFactory.cs`, `WorkflowTriggerService.cs` + +### Test files to add (under `tests/WorkflowFramework.Tests.TinyBDD/Core/`) +- `Engine/WorkflowEngineScenarios.cs` — happy path, middleware chain order, event raise order, compensation on failure, abort token, cancellation, OperationCanceledException pass-through, multiple errors aggregation. +- `Builder/WorkflowBuilderScenarios.cs` — step add ordering, naming, duplicate detection, typed data flow. +- `Builder/WorkflowBuilderExtensionsScenarios.cs` — fluent helpers (`.AddStep()`, conditional wiring, parallel wiring). +- `Internal/ConditionalStepScenarios.cs` — true/false branch, missing branch, predicate exception, nested conditional. +- `Internal/LoopStepsScenarios.cs` — count-loop, while-loop, do-while, break, max-iteration safety. +- `Internal/ParallelStepScenarios.cs` — all-success, partial-failure aggregation, cancellation propagation. +- `Internal/DelegateStepScenarios.cs` — sync delegate, async delegate, throwing delegate. +- `Internal/TypedAdapterScenarios.cs` — typed step round-trip, typed workflow round-trip. +- `Pipeline/PipelineScenarios.cs` — single-step, multi-step, short-circuit, error. +- `Registry/WorkflowRegistryScenarios.cs` — register, lookup, duplicate, missing. +- `Checkpointing/WorkflowResumeEngineScenarios.cs` — resume from checkpoint, missing checkpoint, replay-skipping completed steps, compensation on resume failure. +- `Triggers/CronExpressionScenarios.cs` — common cron expressions, edge cases (leap year, DST window), invalid expression rejection. +- `Triggers/TriggerSourceFactoryScenarios.cs`, `Triggers/WorkflowTriggerServiceScenarios.cs`. + +### Estimated test count +**~95 new scenarios** across ~14 files. + +### PatternKit adoptions in this phase +**None.** Phase D is purely characterization. Adoptions land in Phase F+. + +### Dependencies +- Quick Wins QW-1 through QW-5 merged (optional but recommended — they validate the test-project scaffolding pattern). +- Otherwise depends only on `main`. + +### Done criteria +- +90–100 new TinyBDD scenarios green on net8/9/10. +- Coverage on `src/WorkflowFramework/` rises from current baseline (estimated ~60%) to **≥ 90% line, ≥ 85% branch**. +- `tests/WorkflowFramework.Tests.TinyBDD/` totals **≥ 250 scenarios** (current 164 + Quick Wins + Phase D). +- `.github/workflows/ci.yml` green on PR head commit. +- No public API symbol added or removed (verify with API-diff tool or manual `grep` over public surface). + +### Risk / rollback +- **Risk:** `CronExpression` parsing may have subtle DST/timezone bugs surfaced by new scenarios. **Mitigation:** treat newly-found bugs as separate fix PRs; mark the failing scenario `[Scenario(Skip="bug #N")]` only if blocking, with a tracking issue. +- **Risk:** `WorkflowResumeEngine` scenarios may require a fake checkpoint store. **Mitigation:** reuse `InMemoryWorkflowCheckpointStore` or add a minimal test-only fake under `tests/WorkflowFramework.Tests.TinyBDD/Support/`. +- **Rollback:** Tests are additive — revert the PR commit, no source changes to undo. + +--- + +## Phase E — Resurrect Missing Test Projects with TinyBDD-from-Start + +### Goal +Close the four "zero tests at all" gaps so every extension shipped today has at least baseline BDD coverage. These are the highest-risk projects because they have no behavioral net. + +### Scope +For each of the following, create a new TinyBDD-style test project under `tests/`: + +1. **`tests/WorkflowFramework.Extensions.Polly.Tests/`** *(already started in QW-1; this phase rounds it out)* + - `ResilienceMiddlewareScenarios.cs` — retry on transient, circuit-break, fallback, timeout. + - `WorkflowBuilderPollyExtensionsScenarios.cs` — fluent retry wiring, named pipeline lookup. +2. **`tests/WorkflowFramework.Extensions.Reactive.Tests/`** *(extends QW-4)* + - `IAsyncStepScenarios.cs` — happy, fault, cancel, backpressure (if applicable). +3. **`tests/WorkflowFramework.Extensions.Expressions.Tests/`** *(extends QW-5)* + - `SimpleExpressionEvaluatorScenarios.cs` — full grammar coverage. + - `TemplateEngineScenarios.cs` — substitution, escaping, missing-token policy. + - `ExpressionBuilderExtensionsScenarios.cs` — DI wiring, evaluator selection. +4. **`tests/WorkflowFramework.Extensions.Distributed.Redis.Tests/`** + - `RedisDistributedLockScenarios.cs` — acquire, release, timeout, contention. Use `Testcontainers.Redis` (already a likely dep — verify in `Directory.Packages.props`) or `StackExchange.Redis` test harness. + - `RedisWorkflowQueueScenarios.cs` — enqueue, dequeue, FIFO order, visibility timeout. + +### Estimated test count +**~35–40 scenarios** across ~7 files (in addition to Quick Wins). + +### PatternKit adoptions +**None directly.** Lays groundwork for Phase F pilot (`RetryPolicy` wrapping in Polly extension) and for Phase G `Interpreter` adoption in Expressions. + +### Dependencies +- Quick Wins (provide skeleton structure for 3 of the 4 projects). +- Phase D can run in parallel — no source overlap. + +### Done criteria +- 4 previously-untested projects each have a passing test project on net8/9/10. +- Each project reaches **≥ 70% line coverage** (these are smaller projects, so 70% is reasonable in one PR; raise in Phase I). +- CI matrix includes the new projects. +- README test-project list updated. + +### Risk / rollback +- **Risk:** Redis tests require a container — CI runner may not have Docker. **Mitigation:** gate Redis container-based scenarios behind a `[Trait("Category","Integration")]` filter; ship at least one non-container scenario (lock semantics via in-process fake) so net8/9/10 unit lanes always run something. If CI doesn't support containers at all, mark integration lane optional. +- **Risk:** Polly v8 API surface may have shifted from v7 references in `ResilienceMiddleware`. **Mitigation:** verify `Polly` package version in `Directory.Packages.props` before writing scenarios. +- **Rollback:** Per-project revert; each test project is its own folder. + +--- + +## Phase F — PatternKit Foundation + Pilot Adoption + +### Goal +Land PatternKit as a first-class internal dependency with **one** real adoption proving the wrap-don't-replace pattern, and lock the API-stability invariant. + +### Scope +- **`Directory.Packages.props`**: add ``. Source: confirm via `dotnet list package` or NuGet.org once a stable version is pinned. +- **`src/WorkflowFramework/WorkflowFramework.csproj`**: reference `PatternKit`. +- **`src/WorkflowFramework.Extensions.Polly/WorkflowFramework.Extensions.Polly.csproj`**: reference `PatternKit`. +- **Pilot adoption** — pick exactly **one** of the two below (recommend A; B is fallback if A hits friction): + - **A. `StateMachine` for `WorkflowStatus`** *(promote QW-3 to authoritative)*: move `WorkflowStatusMachine` from advisory to in-engine. `WorkflowEngine` uses the machine to gate transitions; rejected transitions throw `InvalidWorkflowStateException`. All current paths in `WorkflowEngine.cs` get a corresponding `Fire(event)` call. + - **B. `RetryPolicy` wrapping `IStep.ExecuteAsync` in Polly extension**: `ResilienceMiddleware` delegates retry/backoff to `PatternKit.Core.Behavioral.RetryPolicy` (verify exact namespace). Existing Polly v8 `ResiliencePipeline` remains the outer envelope; PatternKit handles the per-step retry decision tree. +- **Pilot tests**: `Core/PatternKit/StateMachinePilotScenarios.cs` (option A) or `Extensions.Polly.Tests/PatternKitRetryScenarios.cs` (option B). ~15 scenarios pinning the wrapped behavior. + +### Estimated test count +**~15 new scenarios** plus the existing Phase D + Phase E test count must remain green (regression gate). + +### PatternKit adoptions +- One pilot (A or B above). +- Foundation: package referenced from 2 projects, **public API unchanged**. + +### Dependencies +- **Phase D merged** (need engine coverage in place before touching engine internals for option A). +- Quick Win QW-3 merged if option A is chosen. +- Phase E merged if option B is chosen (need Polly test project baseline). + +### Done criteria +- PatternKit referenced in `Directory.Packages.props` at a pinned stable version. +- One pilot adoption merged with paired TinyBDD scenarios. +- Pre-adoption tests still pass (behavioral equivalence proven). +- Public API diff = empty. +- CI green on net8/9/10. + +### Risk / rollback +- **Risk:** PatternKit `StateMachine` may not expose a hook for the compensation transition (`Running → Compensated` via a saga rollback event). **Mitigation:** if so, restrict the machine to happy-path transitions and leave compensation as direct status assignment. Document the limitation in `src/WorkflowFramework/Internal/WorkflowStatusMachine.cs` header. +- **Risk:** PatternKit `RetryPolicy` semantics differ from Polly's (e.g., jitter, backoff base). **Mitigation:** characterization tests first — capture exact current behavior, then prove PatternKit replicates. +- **Rollback:** Drop the pilot adoption commit, keep the package reference. Pre-adoption tests stay green. + +--- + +## Phase G — EIP Integration Step Replacement (PatternKit-Backed) + +### Goal +Replace bespoke `Extensions.Integration` EIP step implementations with PatternKit Enterprise Integration backers. Each replacement requires a TinyBDD scenario set proving behavioral equivalence *before* the swap. + +### Scope — src (24 EIP step classes confirmed) + +**Routing** (`src/WorkflowFramework.Extensions.Integration/Routing/`) +- `ContentBasedRouterStep.cs`, `DynamicRouterStep.cs`, `MessageFilterStep.cs`, `RecipientListStep.cs`, `RoutingSlipStep.cs` + +**Composition** (`Composition/`) +- `AggregatorStep.cs`, `ComposedMessageProcessorStep.cs`, `ProcessManagerStep.cs`, `ResequencerStep.cs`, `ScatterGatherStep.cs`, `SplitterStep.cs` + +**Channel** (`Channel/`) +- `ChannelAdapterStep.cs`, `DeadLetterStep.cs`, `MessageBridgeStep.cs`, `WireTapStep.cs` + +**Endpoint** (`Endpoint/`) +- `IdempotentReceiverStep.cs`, `PollingConsumerStep.cs`, `TransactionalOutboxStep.cs` + +**Transformation** (`Transformation/`) +- `ClaimCheckStep.cs`, `ContentEnricherStep.cs`, `ContentFilterStep.cs`, `MessageTranslatorStep.cs`, `NormalizerStep.cs` + +**Builder** (`Builder/`) +- `IntegrationBuilderExtensions.cs` — adapts wiring to PatternKit-backed steps where the type changes internally. + +### Scope — tests (under `tests/WorkflowFramework.Tests.TinyBDD/Integration/` — already has 3 files; expand to one per step) +Add or extend (existing files are noted in **bold**): +- **`RoutingSlipStepScenarios.cs`** (rename current `RoutingSlipStepTests.cs` to scenario style if not already) +- **`ScatterGatherStepScenarios.cs`** +- **`ContentBasedRouterStepScenarios.cs`** +- `DynamicRouterStepScenarios.cs`, `MessageFilterStepScenarios.cs`, `RecipientListStepScenarios.cs` +- `AggregatorStepScenarios.cs`, `ComposedMessageProcessorStepScenarios.cs`, `ProcessManagerStepScenarios.cs`, `ResequencerStepScenarios.cs`, `SplitterStepScenarios.cs` +- `ChannelAdapterStepScenarios.cs`, `DeadLetterStepScenarios.cs`, `MessageBridgeStepScenarios.cs`, `WireTapStepScenarios.cs` +- `IdempotentReceiverStepScenarios.cs`, `PollingConsumerStepScenarios.cs`, `TransactionalOutboxStepScenarios.cs` +- `ClaimCheckStepScenarios.cs`, `ContentEnricherStepScenarios.cs`, `ContentFilterStepScenarios.cs`, `MessageTranslatorStepScenarios.cs`, `NormalizerStepScenarios.cs` +- `IntegrationBuilderExtensionsScenarios.cs` + +### Estimated test count +**~120–150 new scenarios** (5–7 per step × ~24 steps). + +### PatternKit adoptions (each verified to exist under `src/PatternKit.Core/EnterpriseIntegration/`) +- `RoutingSlipStep` → `PatternKit.Core.Behavioral.Chain` or dedicated `AsyncRoutingSlip` if exposed. +- `ScatterGatherStep` → PatternKit ScatterGather. +- `AggregatorStep` → PatternKit Aggregator. +- `SplitterStep` → PatternKit Splitter. +- `WireTapStep` → PatternKit WireTap. +- `RecipientListStep` → PatternKit RecipientList. +- `ContentBasedRouterStep`/`DynamicRouterStep` → PatternKit `Strategy` or content-based router primitive. +- `MessageFilterStep` → PatternKit `Specification` filter. +- `ProcessManagerStep` → PatternKit `AsyncSaga` (if present). +- `MessageTranslatorStep`/`NormalizerStep`/`ContentEnricherStep`/`ContentFilterStep` → PatternKit `Adapter`/`Decorator`. +- `ChannelAdapterStep`/`MessageBridgeStep` → PatternKit `Adapter`. +- `DeadLetterStep`/`IdempotentReceiverStep`/`PollingConsumerStep`/`TransactionalOutboxStep` → may not have direct PatternKit analogues; keep bespoke but add scenarios. +- `ClaimCheckStep` → PatternKit `Proxy`/`Flyweight` or bespoke. +- `ComposedMessageProcessorStep`/`ResequencerStep` → likely bespoke; add scenarios only. + +**Sub-PR strategy:** Group steps by pattern (Routing PR, Composition PR, Channel PR, Endpoint PR, Transformation PR) — 5 sub-PRs, each independently mergeable. + +### Dependencies +- **Phase D** (engine coverage in place — EIP steps invoke engine internals via `IStep`). +- **Phase F** (PatternKit package reference and pilot adoption pattern established). + +### Done criteria +- All 24 EIP step classes have a TinyBDD scenario file with ≥ 5 scenarios each. +- At least 12 of 24 steps have a PatternKit-backed internal implementation; the rest are documented as "intentionally bespoke" in their file header. +- Coverage on `src/WorkflowFramework.Extensions.Integration/` ≥ 90%. +- Public API on `Extensions.Integration` unchanged (verified via API diff). +- CI green on each sub-PR. + +### Risk / rollback +- **Risk:** A PatternKit primitive lacks a hook the bespoke step needed (e.g., `RoutingSlipStep` may emit custom telemetry events not exposed by `AsyncRoutingSlip`). **Mitigation:** wrap PatternKit primitive in a thin adapter that surfaces the missing event; if adapter is too heavy, keep bespoke and just add scenarios. Document the decision in the step file. +- **Risk:** Behavioral differences in error aggregation (Aggregator, ScatterGather) — PatternKit may aggregate differently from current bespoke logic. **Mitigation:** characterization scenarios *first*; if a difference is found, treat as a behavior decision, not a bug — document and choose explicitly which side wins. +- **Rollback:** Each sub-PR is reverted independently. Tests stay (additive); only the implementation swap reverts. + +--- + +## Phase H — Long-Tail Extensions (Coverage Sweep) + +### Goal +Bring every remaining extension project under TinyBDD coverage at a baseline level. Order chosen by user-facing surface area and risk. + +### Scope (priority order — each gets its own sub-PR or grouped sub-PR) + +**H.1 — Hosting & DI (foundational for everything else)** +- `src/WorkflowFramework.Extensions.Hosting/` → `tests/WorkflowFramework.Extensions.Hosting.Tests/` +- `src/WorkflowFramework.Extensions.DependencyInjection/` → augment existing tests if any; otherwise add TinyBDD project. + +**H.2 — Http & Connectors (external surface)** +- `src/WorkflowFramework.Extensions.Http/` → new test project, TinyBDD scenarios for request/response, retry, error mapping. +- `src/WorkflowFramework.Extensions.Connectors.Abstractions/`, `Connectors.Grpc/`, `Connectors.Messaging/` → new test projects. + +**H.3 — Events & Diagnostics (observability)** +- `src/WorkflowFramework.Extensions.Events/` → new test project. +- `src/WorkflowFramework.Extensions.Diagnostics/` → new test project (OpenTelemetry/activity scenarios). + +**H.4 — Persistence backends (5 projects)** +- `src/WorkflowFramework.Extensions.Persistence/` (abstractions) → new test project. +- `src/WorkflowFramework.Extensions.Persistence.InMemory/` → new test project. +- `src/WorkflowFramework.Extensions.Persistence.EntityFramework/` → new test project. +- `src/WorkflowFramework.Extensions.Persistence.PostgreSQL/` → new test project; Testcontainers gate. +- `src/WorkflowFramework.Extensions.Persistence.SqlServer/` → new test project; Testcontainers gate. +- `src/WorkflowFramework.Extensions.Persistence.Sqlite/` → new test project. + +**H.5 — Distributed backends** +- `src/WorkflowFramework.Extensions.Distributed/` (abstractions) → new test project. +- `src/WorkflowFramework.Extensions.Distributed.PostgreSQL/` → new test project; Testcontainers. + *(Redis covered in Phase E.)* + +**H.6 — HumanTasks** +- `src/WorkflowFramework.Extensions.HumanTasks/` → new test project. + +**H.7 — Agents & AI** +- `src/WorkflowFramework.Extensions.Agents/`, `Agents.Mcp/`, `Agents.Skills/` → new test projects. +- `src/WorkflowFramework.Extensions.AI/` → new test project. + +**H.8 — Configuration, Scheduling, Plugins, Visualization, DataMapping** +- `src/WorkflowFramework.Extensions.Configuration/` → new test project. +- `src/WorkflowFramework.Extensions.Scheduling/` → augment existing if any; otherwise add TinyBDD project. +- `src/WorkflowFramework.Extensions.Plugins/` → new test project; **also** evaluate `Strategy`/`AbstractFactory` PatternKit adoption here. +- `src/WorkflowFramework.Extensions.Visualization/` → new test project (rendering scenarios, mermaid-style output verification). +- `src/WorkflowFramework.Extensions.DataMapping/`, `DataMapping.Formats/`, `DataMapping.Schema/` → new test projects. + +### Test files +~25 new test projects, ~6–10 scenarios per src class, ~300+ scenarios total. + +### Estimated test count +**~300–400 new scenarios** across ~25 new test projects. + +### PatternKit adoptions +- `Extensions.Plugins` → `Strategy` + `AbstractFactory` for plugin loading. +- `Extensions.AI` / `Extensions.Agents` → potential `TypeDispatcher` for message routing. +- `Extensions.Visualization` → no adoption likely. +- All others: opportunistic — only adopt where it's clean. + +### Dependencies +- **Phase D** (engine baseline). +- **Phase F** (PatternKit reference pattern). +- H.4 and H.5 partially block on Testcontainers availability in CI. + +### Done criteria +- All 42 src projects have at least one test project under `tests/` (gap = zero). +- Every test project compiles + green on net8/9/10. +- Aggregate TinyBDD scenario count **≥ 600**. +- CI matrix includes every new test project. +- README updated with full test-project list. + +### Risk / rollback +- **Risk:** Testcontainers-dependent test projects may fail on locked-down CI runners. **Mitigation:** classify all integration tests with `[Trait("Category","Integration")]` and `dotnet test --filter Category!=Integration` in main lane; run integration lane on a separate workflow allowed to use Docker. +- **Risk:** Some extensions (AI, Agents.Mcp) may need fakes for external services. **Mitigation:** ship in-memory fakes under `tests/.../Support/` per-project. +- **Rollback:** Per-sub-PR revert; each project is independent. + +--- + +## Phase I — Coverage Tightening & Documentation + +### Goal +Hit the project-wide coverage target, surface coverage publicly, and document the testing pattern so future contributors stay consistent. + +### Scope +- Run `dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura` across the solution. +- Generate coverage report (`coverage-report/` already exists in repo — reuse). +- Identify projects below **95% line / 90% branch** and add targeted scenarios. +- Add or update coverage badge in `README.md` (Codecov badge — `codecov.yml` already present). +- Update `tests/WorkflowFramework.Tests.TinyBDD/README.md` with the canonical scenario template. +- Add a `.github/workflows/coverage.yml` (if not present) that uploads to Codecov and fails the PR below threshold. +- Document the PatternKit adoption inventory in `docs/` — which steps use which PatternKit primitive, which are intentionally bespoke. + +### Test files +~50–100 targeted "gap-filling" scenarios across already-existing test projects (no new projects expected at this point). + +### Estimated test count +**~50–100 new scenarios** (gap-fillers). + +### PatternKit adoptions +**None new** — this phase is consolidation. + +### Dependencies +- Phases D, E, F, G, H all merged. + +### Done criteria +- Project-wide line coverage **≥ 95%**, branch **≥ 88%** (the slightly lower branch threshold acknowledges hard-to-reach catch blocks in EF/cancellation paths). +- Coverage badge live on README and rendering green on `main`. +- `tests/WorkflowFramework.Tests.TinyBDD/README.md` documents the scenario template. +- `docs/patternkit-adoption.md` lists every adoption point. +- CI green; codecov gate enforced. + +### Risk / rollback +- **Risk:** Coverage tools (coverlet) may not see all targets across multi-target `net8/9/10` matrix — counts diverge. **Mitigation:** publish per-TFM reports; if a TFM is consistently lower, treat as separate sub-task. +- **Rollback:** Coverage configuration is metadata; revert is trivial. + +--- + +## Recommended Execution Order + +1. **Quick Wins QW-1 through QW-5** (parallelizable, one PR each — ~1 week elapsed). +2. **Phase D** — Core engine BDD coverage (single largish PR or 2–3 sub-PRs by area: Engine/Builder, Internal-Steps, Pipeline+Registry+Triggers). +3. **Phase E** — Resurrect missing test projects (one PR per project; QW already started 3 of 4). +4. **Phase F** — PatternKit foundation + pilot (one PR, depends on D; option A recommended). +5. **Phase G** — EIP integration step replacement (5 sub-PRs grouped by pattern family). +6. **Phase H** — Long-tail extensions (sub-PRs H.1 → H.8 in priority order; H.1, H.2, H.3 can stack; H.4 and H.5 may block on container CI). +7. **Phase I** — Coverage tightening + docs (one PR). + +**Parallelization windows:** +- Quick Wins are all parallelizable from each other. +- Within Phase D, Engine and Triggers can be split into parallel sub-PRs. +- Within Phase G, the 5 pattern-family sub-PRs are mutually independent (different folders, different test files). +- Within Phase H, H.6, H.7, H.8 are mutually independent of each other and of H.4/H.5. + +--- + +## Summary Table + +| Phase | New scenarios | New test projects | PatternKit adoptions | Blocks | +|-------|---------------|-------------------|----------------------|--------| +| QW-1..5 | ~41 | 3 | 1 (Specification), 1 (StateMachine advisory) | — | +| D | ~95 | 0 (extends TinyBDD) | 0 | QW (recommended) | +| E | ~35 (beyond QW) | 1 (Redis; rest extend QW) | 0 | QW | +| F | ~15 | 0 | 1 pilot (StateMachine OR RetryPolicy) | D | +| G | ~120–150 | 0 (extends TinyBDD) | ~12 EIP primitives | D, F | +| H | ~300–400 | ~25 | 2–4 (Plugins Strategy, Agents TypeDispatcher, etc.) | D, F | +| I | ~50–100 | 0 | 0 | D, E, F, G, H | +| **Total** | **~650–840** | **~29** | **~16–19** | — | diff --git a/Directory.Packages.props b/Directory.Packages.props index d16ef73..a7e41ea 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -89,7 +89,7 @@ - + diff --git a/benchmarks/WorkflowFramework.Benchmarks/packages.lock.json b/benchmarks/WorkflowFramework.Benchmarks/packages.lock.json index 063e30e..0e4e9df 100644 --- a/benchmarks/WorkflowFramework.Benchmarks/packages.lock.json +++ b/benchmarks/WorkflowFramework.Benchmarks/packages.lock.json @@ -174,7 +174,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -246,6 +247,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -431,7 +438,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -508,6 +516,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -683,7 +697,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -758,6 +773,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/docs/patternkit-adoption.md b/docs/patternkit-adoption.md index 0f17535..3dec0c2 100644 --- a/docs/patternkit-adoption.md +++ b/docs/patternkit-adoption.md @@ -1,7 +1,7 @@ # PatternKit Adoption Inventory -**PatternKit version:** 0.112.0 -**Last updated:** 2026-05-22 (feat/consume-patternkit-0.112 — WireTapStep adopted) +**PatternKit version:** 0.113.0 +**Last updated:** 2026-05-22 (feat/iter2-minor-refactors — NormalizerStep / PollingConsumerStep / IdempotentReceiverStep adopted) This document lists every point in the WorkflowFramework codebase where a PatternKit primitive is used, and every point where a step is intentionally kept bespoke with the rationale for that decision. This is the canonical reference for Phase I and future phases. @@ -57,6 +57,46 @@ This document lists every point in the WorkflowFramework codebase where a Patter | **Public API change** | None — swap is internal-only. | | **Net delta** | −15 lines of bespoke logic (try/catch error-swallowing replaced by `TapErrorPolicy`). | +### 5. `NormalizerStep` — Keyed normalizer pattern + +| Item | Detail | +|------|--------| +| **File** | `src/WorkflowFramework.Extensions.Integration/Transformation/NormalizerStep.cs` | +| **PatternKit namespace** | `PatternKit.Messaging.Transformation` | +| **Primitive** | `KeyedNormalizer` (new in 0.113.0) | +| **Purpose** | Delegates O(1) key-based dispatch to `KeyedNormalizer`. Each `IStep` translator is wrapped as an async handler. The original `InvalidOperationException` contract is preserved by catching `KeyNotFoundException` from the PatternKit miss path and wrapping it with the bespoke message. | +| **Phase introduced** | feat/iter2-minor-refactors | +| **Test coverage** | `tests/WorkflowFramework.Tests.TinyBDD/Integration/Transformation/NormalizerStepScenarios.cs` — all 9 scenarios pass without modification. | +| **Public API change** | None — swap is internal-only. | +| **Net delta** | −10 lines of bespoke dict-lookup logic (absorbed into KeyedNormalizer). | + +### 6. `PollingConsumerStep` — Async polling consumer pattern + +| Item | Detail | +|------|--------| +| **File** | `src/WorkflowFramework.Extensions.Integration/Endpoint/PollingConsumerStep.cs` | +| **PatternKit namespace** | `PatternKit.Messaging.Consumers` | +| **Primitive** | `AsyncPollingConsumer>.PollOnceAsync` (new in 0.113.0) | +| **Purpose** | Bridges `IPollingSource` (which returns `IReadOnlyList`) to `AsyncPollingConsumer`'s `AsyncPollSource` delegate via `WithSource`. Calls `PollOnceAsync` for a single-shot poll without entering the consumer's run loop. The `ResultKey` write contract and `IReadOnlyList` output type are unchanged. | +| **Phase introduced** | feat/iter2-minor-refactors | +| **Test coverage** | `tests/WorkflowFramework.Tests.TinyBDD/Integration/Endpoint/PollingConsumerStepScenarios.cs` — all 8 scenarios pass without modification. | +| **Public API change** | None — swap is internal-only. | +| **Net delta** | −4 lines (bespoke poll call replaced by consumer delegation). | + +### 7. `IdempotentReceiverStep` — Idempotent receiver pattern + +| Item | Detail | +|------|--------| +| **File** | `src/WorkflowFramework.Extensions.Integration/Endpoint/IdempotentReceiverStep.cs` | +| **PatternKit namespace** | `PatternKit.Messaging.Reliability` | +| **Primitive** | `IIdempotencyStore` (in 0.112.0+) with `TryClaimAsync` / `MarkCompletedAsync` / `MarkFailedAsync` | +| **Purpose** | Replaces the bespoke `HashSet` with claim/complete/fail semantics. The default store (`RetryAfterFailureIdempotencyStore`) resets Failed keys to Processing on re-claim, allowing retry after transient failure. Completed keys are still suppressed, preserving the successful-dedup contract. | +| **Phase introduced** | feat/iter2-minor-refactors | +| **Behavior change** | **BUG FIX:** Previously, a step failure permanently locked the idempotency key, preventing retries. A transient inner-step failure should not lock future attempts. The new semantics: `Failed` → retry allowed; `Completed` → deduplicated. | +| **Test coverage** | `tests/WorkflowFramework.Tests.TinyBDD/Integration/Endpoint/IdempotentReceiverStepScenarios.cs` — 9 scenarios; `ReAttemptAfterExceptionIsSkipped` renamed to `ReAttemptAfterExceptionIsAllowed` with assertion flipped. | +| **Public API change** | Added optional `IIdempotencyStore` overload in the constructor. Default two-arg constructor preserved. | +| **Net delta** | +83 lines net (bespoke `HashSet` replaced by `IIdempotencyStore` + internal default impl). | + --- ## Intentionally Bespoke @@ -197,16 +237,15 @@ When evaluating a bespoke component for PatternKit adoption, the following crite The following components are candidates for PatternKit adoption in later phases if suitable primitives become available or interface alignment is achieved: -| Component | Potential Primitive | Blocking Reason (assessed against 0.112.0) | +| Component | Potential Primitive | Blocking Reason (assessed against 0.113.0) | |-----------|--------------------|-----------------------| -| `NormalizerStep` | `Normalizer` (now in 0.112.0) | Behavioral mismatch: PatternKit uses content predicates (first match wins); bespoke uses O(1) dictionary keyed dispatch. Error message format differs — test pins format name in exception text. See `docs/patternkit-followup.md`. | -| `ContentEnricherStep` | `AsyncContentEnricher` (now in 0.112.0) | Semantic mismatch: PatternKit returns an enriched payload copy; bespoke mutates `IWorkflowContext` in place via a `Func`. Wrapping adds indirection for zero functional benefit. | -| `IdempotentReceiverStep` | `IdempotentReceiver` (now in 0.112.0) | Behavioral breaking change: PatternKit marks failed attempts as `Failed` in the store (allowing retry); bespoke registers the ID in a `HashSet` before calling inner, so a failed first attempt DOES suppress the second. Test `ReAttemptAfterExceptionIsSkipped` pins this behavior. | -| `ClaimCheckStep` / `ClaimRetrieveStep` | `ClaimCheck` (now in 0.112.0) | Interface mismatch: bespoke `IClaimCheckStore` is untyped (`object`); PatternKit `IClaimCheckStore` is typed. Bridging requires an adapter class, adding indirection without deleting complexity. | -| `PollingConsumerStep` | `AsyncPollingConsumer` (now in 0.112.0) | Semantic mismatch: PatternKit is a continuous polling loop (run until cancelled); bespoke is a single-shot poll (`PollAsync` → store results → return). Incompatible lifecycle models. | -| `ScatterGatherStep` | `AsyncScatterGather` (now in 0.112.0) | Integration complexity: handlers mutate a shared `IWorkflowContext` and write results to named context keys; PatternKit's per-recipient isolation model returns typed `TResponse` values. Adapting while preserving the `__Result_{handler.Name}` and `ResultsKey` contract would re-implement the existing complexity via a wrapper, defeating the purpose. | -| `TransactionalOutboxStep` | `IOutboxStore` (now in 0.112.0) | Interface mismatch: bespoke `IOutboxStore` uses `SaveAsync(object) → string`; PatternKit `IOutboxStore` uses `EnqueueAsync(Message) → OutboxMessage`. Different return types and message wrapper model. | -| `AggregatorStep` | PatternKit Aggregator (future) | No Aggregator primitive in 0.112.0 | +| `ContentEnricherStep` | `AsyncContentEnricher` (now in 0.113.0) | Path C — intentionally bespoke. PatternKit returns an enriched payload copy; bespoke mutates `IWorkflowContext` in place via a `Func`. Wrapping adds indirection for zero functional benefit. See `.plan/patternkit-iteration-2.md` §2. | +| `ClaimCheckStep` / `ClaimRetrieveStep` | `ClaimCheck` (now in 0.113.0) | Interface mismatch: bespoke `IClaimCheckStore` is untyped (`object`); PatternKit `IClaimCheckStore` is typed. Deferred to Iteration 2 Phase 3 — requires adapter + interface migration. | +| `ScatterGatherStep` | `AsyncScatterGather` (now in 0.113.0) | Integration complexity: handlers mutate a shared `IWorkflowContext` and write results to named context keys; PatternKit's per-recipient isolation model returns typed `TResponse` values. Deferred to Iteration 2 Phase 3. | +| `TransactionalOutboxStep` | `IOutboxStore` (now in 0.113.0) | Interface mismatch: bespoke `IOutboxStore` uses `SaveAsync(object) → string`; PatternKit `IOutboxStore` uses `EnqueueAsync(Message) → OutboxMessage`. Deferred to Iteration 2 Phase 3. | +| `AggregatorStep` | PatternKit Aggregator (future) | No Aggregator primitive in 0.113.0 | | `PluginManager` | `Strategy` + `AbstractFactory` | Phase H.8 — not yet started | | `AgentLoopStep` / `AgentDecisionStep` | TypeDispatcher | Phase H.7 — not yet started | | `ResilienceMiddleware` (Polly) | `RetryPolicy` | Phase F pilot option B — deferred | + +**Adopted in feat/iter2-minor-refactors (Iteration 2 Phase 2):** `NormalizerStep` (→ `KeyedNormalizer`), `PollingConsumerStep` (→ `PollOnceAsync`), `IdempotentReceiverStep` (→ `IIdempotencyStore` claim/complete/fail — includes bug fix). diff --git a/samples/WorkflowFramework.Samples.DataPipeline/packages.lock.json b/samples/WorkflowFramework.Samples.DataPipeline/packages.lock.json index e212491..ebe56d7 100644 --- a/samples/WorkflowFramework.Samples.DataPipeline/packages.lock.json +++ b/samples/WorkflowFramework.Samples.DataPipeline/packages.lock.json @@ -56,7 +56,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -96,6 +97,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -154,7 +161,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -196,6 +204,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -259,7 +273,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -301,6 +316,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/samples/WorkflowFramework.Samples.OrderProcessing/packages.lock.json b/samples/WorkflowFramework.Samples.OrderProcessing/packages.lock.json index 99b4644..589ee81 100644 --- a/samples/WorkflowFramework.Samples.OrderProcessing/packages.lock.json +++ b/samples/WorkflowFramework.Samples.OrderProcessing/packages.lock.json @@ -56,7 +56,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.visualization": { @@ -102,6 +103,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -160,7 +167,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.visualization": { @@ -208,6 +216,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -271,7 +285,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.visualization": { @@ -319,6 +334,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/samples/WorkflowFramework.Samples.TaskStream/packages.lock.json b/samples/WorkflowFramework.Samples.TaskStream/packages.lock.json index 7690946..ee81c45 100644 --- a/samples/WorkflowFramework.Samples.TaskStream/packages.lock.json +++ b/samples/WorkflowFramework.Samples.TaskStream/packages.lock.json @@ -248,7 +248,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -300,6 +301,12 @@ "Microsoft.SemanticKernel.Connectors.AzureOpenAI": "1.71.0", "Microsoft.SemanticKernel.Core": "1.71.0" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/samples/WorkflowFramework.Samples.VoiceWorkflows/packages.lock.json b/samples/WorkflowFramework.Samples.VoiceWorkflows/packages.lock.json index 038fe60..87b06bc 100644 --- a/samples/WorkflowFramework.Samples.VoiceWorkflows/packages.lock.json +++ b/samples/WorkflowFramework.Samples.VoiceWorkflows/packages.lock.json @@ -248,7 +248,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -313,6 +314,12 @@ "Microsoft.SemanticKernel.Connectors.AzureOpenAI": "1.71.0", "Microsoft.SemanticKernel.Core": "1.71.0" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/samples/WorkflowFramework.Samples.WebApi/packages.lock.json b/samples/WorkflowFramework.Samples.WebApi/packages.lock.json index ec02a5d..06f4bef 100644 --- a/samples/WorkflowFramework.Samples.WebApi/packages.lock.json +++ b/samples/WorkflowFramework.Samples.WebApi/packages.lock.json @@ -23,7 +23,10 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.dependencyinjection": { "type": "Project", @@ -44,6 +47,12 @@ "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/samples/WorkflowFramework.Samples/packages.lock.json b/samples/WorkflowFramework.Samples/packages.lock.json index 1791cd7..c3d518c 100644 --- a/samples/WorkflowFramework.Samples/packages.lock.json +++ b/samples/WorkflowFramework.Samples/packages.lock.json @@ -56,7 +56,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -103,6 +104,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/src/WorkflowFramework.Cli/packages.lock.json b/src/WorkflowFramework.Cli/packages.lock.json index 15ffa81..053cda5 100644 --- a/src/WorkflowFramework.Cli/packages.lock.json +++ b/src/WorkflowFramework.Cli/packages.lock.json @@ -62,7 +62,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.serialization": { @@ -108,6 +109,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/src/WorkflowFramework.Dashboard.Api/packages.lock.json b/src/WorkflowFramework.Dashboard.Api/packages.lock.json index 863f881..f38f02f 100644 --- a/src/WorkflowFramework.Dashboard.Api/packages.lock.json +++ b/src/WorkflowFramework.Dashboard.Api/packages.lock.json @@ -374,7 +374,10 @@ "contentHash": "EzimXy5WX7RJxf1pHBfolBApA4GR7qje1cY9XofD4C+cQepx0a5ZVlZjde8NHk+W1+6kltrbbfa8LIOVpTM6yQ==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.dashboard.persistence": { "type": "Project", @@ -532,6 +535,12 @@ "OpenTelemetry.Api": "[1.12.0, 2.0.0)" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "Polly.Core": { "type": "CentralTransitive", "requested": "[8.6.0, )", diff --git a/src/WorkflowFramework.Dashboard.Persistence/packages.lock.json b/src/WorkflowFramework.Dashboard.Persistence/packages.lock.json index 43ef498..05cde55 100644 --- a/src/WorkflowFramework.Dashboard.Persistence/packages.lock.json +++ b/src/WorkflowFramework.Dashboard.Persistence/packages.lock.json @@ -306,7 +306,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.serialization": { @@ -400,6 +401,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/src/WorkflowFramework.Dashboard/packages.lock.json b/src/WorkflowFramework.Dashboard/packages.lock.json index b032c27..cee6f29 100644 --- a/src/WorkflowFramework.Dashboard/packages.lock.json +++ b/src/WorkflowFramework.Dashboard/packages.lock.json @@ -29,13 +29,22 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.diagnostics": { "type": "Project", "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -94,7 +103,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -144,6 +154,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -207,7 +223,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -257,6 +274,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.AI/packages.lock.json b/src/WorkflowFramework.Extensions.AI/packages.lock.json index ffeaebc..e45a86f 100644 --- a/src/WorkflowFramework.Extensions.AI/packages.lock.json +++ b/src/WorkflowFramework.Extensions.AI/packages.lock.json @@ -119,7 +119,19 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -185,7 +197,16 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -392,7 +413,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection": { @@ -441,6 +463,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -686,7 +714,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection": { @@ -737,6 +766,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -997,7 +1032,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection": { @@ -1048,6 +1084,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Agents.Mcp/packages.lock.json b/src/WorkflowFramework.Extensions.Agents.Mcp/packages.lock.json index 42deb88..215ce25 100644 --- a/src/WorkflowFramework.Extensions.Agents.Mcp/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Agents.Mcp/packages.lock.json @@ -129,7 +129,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.agents": { "type": "Project", @@ -148,6 +151,15 @@ "WorkflowFramework": "[1.0.0, )" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -228,7 +240,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.agents": { "type": "Project", @@ -247,6 +262,12 @@ "WorkflowFramework": "[1.0.0, )" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -457,7 +478,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -525,6 +547,12 @@ "Microsoft.SemanticKernel.Connectors.AzureOpenAI": "1.71.0", "Microsoft.SemanticKernel.Core": "1.71.0" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -766,7 +794,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -837,6 +866,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -1093,7 +1128,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -1164,6 +1200,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Agents.Skills/packages.lock.json b/src/WorkflowFramework.Extensions.Agents.Skills/packages.lock.json index 09493e8..a8b2d60 100644 --- a/src/WorkflowFramework.Extensions.Agents.Skills/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Agents.Skills/packages.lock.json @@ -114,7 +114,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.agents": { "type": "Project", @@ -133,6 +136,15 @@ "WorkflowFramework": "[1.0.0, )" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -216,7 +228,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.agents": { "type": "Project", @@ -235,6 +250,12 @@ "WorkflowFramework": "[1.0.0, )" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -457,7 +478,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -525,6 +547,12 @@ "Microsoft.SemanticKernel.Connectors.AzureOpenAI": "1.71.0", "Microsoft.SemanticKernel.Core": "1.71.0" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -766,7 +794,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -837,6 +866,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -1093,7 +1128,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -1164,6 +1200,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Agents/packages.lock.json b/src/WorkflowFramework.Extensions.Agents/packages.lock.json index fbcaf64..137ccab 100644 --- a/src/WorkflowFramework.Extensions.Agents/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Agents/packages.lock.json @@ -139,7 +139,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.ai": { "type": "Project", @@ -147,6 +150,15 @@ "System.Text.Json": "[10.0.1, )", "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -227,7 +239,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.ai": { "type": "Project", @@ -235,6 +250,12 @@ "System.Text.Json": "[10.0.1, )", "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -443,7 +464,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -503,6 +525,12 @@ "Microsoft.SemanticKernel.Connectors.AzureOpenAI": "1.71.0", "Microsoft.SemanticKernel.Core": "1.71.0" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -750,7 +778,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -812,6 +841,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Text.Json": { "type": "CentralTransitive", "requested": "[10.0.1, )", @@ -1068,7 +1103,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -1130,6 +1166,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Text.Json": { "type": "CentralTransitive", "requested": "[10.0.1, )", diff --git a/src/WorkflowFramework.Extensions.Approvals.Abstractions/packages.lock.json b/src/WorkflowFramework.Extensions.Approvals.Abstractions/packages.lock.json index 2c4e81f..e9dc962 100644 --- a/src/WorkflowFramework.Extensions.Approvals.Abstractions/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Approvals.Abstractions/packages.lock.json @@ -84,19 +84,22 @@ }, "System.Runtime.CompilerServices.Unsafe": { "type": "Transitive", - "resolved": "6.0.0", - "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg==" + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" + "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { "type": "CentralTransitive", @@ -108,6 +111,15 @@ "System.Threading.Tasks.Extensions": "4.5.4" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -162,7 +174,10 @@ "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { "type": "CentralTransitive", @@ -170,6 +185,12 @@ "resolved": "8.0.2", "contentHash": "3iE7UF7MQkCv1cxzCahz+Y/guQbTqieyxyaWKhrRO91itI9cOKO76OHeQDahqG4MmW5umr3CcCvGmK92lWNlbg==" }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -244,7 +265,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -275,6 +297,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -343,7 +371,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -375,6 +404,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -448,7 +483,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -480,6 +516,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Approvals.Cli/packages.lock.json b/src/WorkflowFramework.Extensions.Approvals.Cli/packages.lock.json index 7f020dd..101d38f 100644 --- a/src/WorkflowFramework.Extensions.Approvals.Cli/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Approvals.Cli/packages.lock.json @@ -77,7 +77,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -126,6 +127,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -206,7 +213,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -256,6 +264,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -341,7 +355,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -391,6 +406,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Approvals.Email/packages.lock.json b/src/WorkflowFramework.Extensions.Approvals.Email/packages.lock.json index 32240f9..e10f673 100644 --- a/src/WorkflowFramework.Extensions.Approvals.Email/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Approvals.Email/packages.lock.json @@ -35,7 +35,10 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.approvals": { "type": "Project", @@ -55,6 +58,12 @@ "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -133,7 +142,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -179,6 +189,12 @@ "Microsoft.Extensions.Logging.Abstractions": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -262,7 +278,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -308,6 +325,12 @@ "Microsoft.Extensions.Logging.Abstractions": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Approvals.Slack/packages.lock.json b/src/WorkflowFramework.Extensions.Approvals.Slack/packages.lock.json index 9c0b40b..d5a4dd1 100644 --- a/src/WorkflowFramework.Extensions.Approvals.Slack/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Approvals.Slack/packages.lock.json @@ -41,7 +41,10 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.approvals": { "type": "Project", @@ -61,6 +64,12 @@ "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -203,7 +212,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -258,6 +268,12 @@ "Microsoft.Extensions.Logging.Abstractions": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -405,7 +421,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -460,6 +477,12 @@ "Microsoft.Extensions.Logging.Abstractions": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Approvals.Teams/packages.lock.json b/src/WorkflowFramework.Extensions.Approvals.Teams/packages.lock.json index 9c0b40b..d5a4dd1 100644 --- a/src/WorkflowFramework.Extensions.Approvals.Teams/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Approvals.Teams/packages.lock.json @@ -41,7 +41,10 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.approvals": { "type": "Project", @@ -61,6 +64,12 @@ "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -203,7 +212,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -258,6 +268,12 @@ "Microsoft.Extensions.Logging.Abstractions": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -405,7 +421,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -460,6 +477,12 @@ "Microsoft.Extensions.Logging.Abstractions": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Approvals/packages.lock.json b/src/WorkflowFramework.Extensions.Approvals/packages.lock.json index 2dc782b..19839d6 100644 --- a/src/WorkflowFramework.Extensions.Approvals/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Approvals/packages.lock.json @@ -94,7 +94,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals.abstractions": { @@ -109,6 +110,12 @@ "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -206,7 +213,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals.abstractions": { @@ -222,6 +230,12 @@ "WorkflowFramework": "[1.0.0, )" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -324,7 +338,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals.abstractions": { @@ -340,6 +355,12 @@ "WorkflowFramework": "[1.0.0, )" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Configuration/packages.lock.json b/src/WorkflowFramework.Extensions.Configuration/packages.lock.json index ae94dd4..22964ca 100644 --- a/src/WorkflowFramework.Extensions.Configuration/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Configuration/packages.lock.json @@ -135,7 +135,19 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -213,7 +225,16 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -289,7 +310,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -323,6 +345,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -413,7 +441,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -449,6 +478,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -544,7 +579,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -580,6 +616,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Connectors.Abstractions/packages.lock.json b/src/WorkflowFramework.Extensions.Connectors.Abstractions/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Connectors.Abstractions/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Connectors.Abstractions/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Connectors.Grpc/packages.lock.json b/src/WorkflowFramework.Extensions.Connectors.Grpc/packages.lock.json index 634a236..943af13 100644 --- a/src/WorkflowFramework.Extensions.Connectors.Grpc/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Connectors.Grpc/packages.lock.json @@ -42,14 +42,39 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.connectors.abstractions": { "type": "Project", "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -80,13 +105,22 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.connectors.abstractions": { "type": "Project", "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -144,7 +178,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -190,6 +225,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -248,7 +289,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -296,6 +338,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -359,7 +407,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -407,6 +456,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Connectors.Messaging/packages.lock.json b/src/WorkflowFramework.Extensions.Connectors.Messaging/packages.lock.json index 627868f..c5a078b 100644 --- a/src/WorkflowFramework.Extensions.Connectors.Messaging/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Connectors.Messaging/packages.lock.json @@ -62,25 +62,37 @@ }, "System.Runtime.CompilerServices.Unsafe": { "type": "Transitive", - "resolved": "4.5.3", - "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw==" + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" + "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.connectors.abstractions": { "type": "Project", "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -117,13 +129,22 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.connectors.abstractions": { "type": "Project", "dependencies": { "WorkflowFramework": "[1.0.0, )" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -187,7 +208,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -227,6 +249,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -291,7 +319,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -333,6 +362,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -402,7 +437,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -444,6 +480,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.DataMapping.Formats/packages.lock.json b/src/WorkflowFramework.Extensions.DataMapping.Formats/packages.lock.json index a6ca723..8b62cd2 100644 --- a/src/WorkflowFramework.Extensions.DataMapping.Formats/packages.lock.json +++ b/src/WorkflowFramework.Extensions.DataMapping.Formats/packages.lock.json @@ -110,7 +110,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.datamapping": { "type": "Project", @@ -130,6 +133,15 @@ "System.Threading.Tasks.Extensions": "4.5.4" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } + }, "System.Text.Json": { "type": "CentralTransitive", "requested": "[10.0.1, )", @@ -203,7 +215,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.datamapping": { "type": "Project", @@ -219,6 +234,12 @@ "resolved": "8.0.2", "contentHash": "3iE7UF7MQkCv1cxzCahz+Y/guQbTqieyxyaWKhrRO91itI9cOKO76OHeQDahqG4MmW5umr3CcCvGmK92lWNlbg==" }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Text.Json": { "type": "CentralTransitive", "requested": "[10.0.1, )", @@ -293,7 +314,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -340,6 +362,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -414,7 +442,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -464,6 +493,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -553,7 +588,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -603,6 +639,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.DataMapping.Schema/packages.lock.json b/src/WorkflowFramework.Extensions.DataMapping.Schema/packages.lock.json index 5a0bc3d..140be7a 100644 --- a/src/WorkflowFramework.Extensions.DataMapping.Schema/packages.lock.json +++ b/src/WorkflowFramework.Extensions.DataMapping.Schema/packages.lock.json @@ -119,7 +119,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.datamapping": { "type": "Project", @@ -138,6 +141,15 @@ "Microsoft.Bcl.AsyncInterfaces": "8.0.0", "System.Threading.Tasks.Extensions": "4.5.4" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -203,7 +215,10 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "workflowframework.extensions.datamapping": { "type": "Project", @@ -218,6 +233,12 @@ "requested": "[8.0.2, )", "resolved": "8.0.2", "contentHash": "3iE7UF7MQkCv1cxzCahz+Y/guQbTqieyxyaWKhrRO91itI9cOKO76OHeQDahqG4MmW5umr3CcCvGmK92lWNlbg==" + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -281,7 +302,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -328,6 +350,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -406,7 +434,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -456,6 +485,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -539,7 +574,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -589,6 +625,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.DataMapping/packages.lock.json b/src/WorkflowFramework.Extensions.DataMapping/packages.lock.json index 301c129..c274363 100644 --- a/src/WorkflowFramework.Extensions.DataMapping/packages.lock.json +++ b/src/WorkflowFramework.Extensions.DataMapping/packages.lock.json @@ -129,7 +129,19 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -201,7 +213,16 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -271,7 +292,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -305,6 +327,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -389,7 +417,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -425,6 +454,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -514,7 +549,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -550,6 +586,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.DependencyInjection/packages.lock.json b/src/WorkflowFramework.Extensions.DependencyInjection/packages.lock.json index a7eae5d..e6a46a3 100644 --- a/src/WorkflowFramework.Extensions.DependencyInjection/packages.lock.json +++ b/src/WorkflowFramework.Extensions.DependencyInjection/packages.lock.json @@ -62,19 +62,31 @@ }, "System.Runtime.CompilerServices.Unsafe": { "type": "Transitive", - "resolved": "4.5.3", - "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw==" + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" + "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -111,7 +123,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -175,7 +196,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -209,6 +231,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -273,7 +301,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -309,6 +338,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -378,7 +413,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -414,6 +450,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Diagnostics/packages.lock.json b/src/WorkflowFramework.Extensions.Diagnostics/packages.lock.json index 8fa6eb7..d1f2d9c 100644 --- a/src/WorkflowFramework.Extensions.Diagnostics/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Diagnostics/packages.lock.json @@ -99,14 +99,17 @@ }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" + "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { "type": "CentralTransitive", @@ -117,6 +120,15 @@ "Microsoft.Bcl.AsyncInterfaces": "8.0.0", "System.Threading.Tasks.Extensions": "4.5.4" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -171,13 +183,22 @@ "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { "type": "CentralTransitive", "requested": "[8.0.2, )", "resolved": "8.0.2", "contentHash": "3iE7UF7MQkCv1cxzCahz+Y/guQbTqieyxyaWKhrRO91itI9cOKO76OHeQDahqG4MmW5umr3CcCvGmK92lWNlbg==" + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -250,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -281,6 +303,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -355,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -386,6 +415,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net9.0": { @@ -460,7 +495,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -491,6 +527,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/src/WorkflowFramework.Extensions.Distributed.PostgreSQL/packages.lock.json b/src/WorkflowFramework.Extensions.Distributed.PostgreSQL/packages.lock.json index 90736db..13ee70e 100644 --- a/src/WorkflowFramework.Extensions.Distributed.PostgreSQL/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Distributed.PostgreSQL/packages.lock.json @@ -77,7 +77,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -117,6 +118,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -210,7 +217,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -253,6 +261,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -351,7 +365,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -394,6 +409,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Distributed.Redis/packages.lock.json b/src/WorkflowFramework.Extensions.Distributed.Redis/packages.lock.json index 4e9f8aa..82bf014 100644 --- a/src/WorkflowFramework.Extensions.Distributed.Redis/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Distributed.Redis/packages.lock.json @@ -77,7 +77,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -123,6 +124,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -219,7 +226,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -268,6 +276,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -366,7 +380,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -415,6 +430,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Distributed/packages.lock.json b/src/WorkflowFramework.Extensions.Distributed/packages.lock.json index 20ebae8..7bebd8b 100644 --- a/src/WorkflowFramework.Extensions.Distributed/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Distributed/packages.lock.json @@ -119,7 +119,19 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -185,7 +197,16 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -249,7 +270,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -289,6 +311,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -367,7 +395,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -409,6 +438,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -492,7 +527,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -534,6 +570,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Events/packages.lock.json b/src/WorkflowFramework.Extensions.Events/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Events/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Events/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Expressions/packages.lock.json b/src/WorkflowFramework.Extensions.Expressions/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Expressions/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Expressions/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Hosting/packages.lock.json b/src/WorkflowFramework.Extensions.Hosting/packages.lock.json index d60a8a7..ccec49c 100644 --- a/src/WorkflowFramework.Extensions.Hosting/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Hosting/packages.lock.json @@ -86,7 +86,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -126,6 +127,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -220,7 +227,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -262,6 +270,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -361,7 +375,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -403,6 +418,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Http/packages.lock.json b/src/WorkflowFramework.Extensions.Http/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Http/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Http/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.HumanTasks/packages.lock.json b/src/WorkflowFramework.Extensions.HumanTasks/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.HumanTasks/packages.lock.json +++ b/src/WorkflowFramework.Extensions.HumanTasks/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Integration.Abstractions/packages.lock.json b/src/WorkflowFramework.Extensions.Integration.Abstractions/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Integration.Abstractions/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Integration.Abstractions/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Integration/Endpoint/IdempotentReceiverStep.cs b/src/WorkflowFramework.Extensions.Integration/Endpoint/IdempotentReceiverStep.cs index 7eb2e26..eee6825 100644 --- a/src/WorkflowFramework.Extensions.Integration/Endpoint/IdempotentReceiverStep.cs +++ b/src/WorkflowFramework.Extensions.Integration/Endpoint/IdempotentReceiverStep.cs @@ -1,24 +1,42 @@ +using PatternKit.Messaging.Reliability; + namespace WorkflowFramework.Extensions.Integration.Endpoint; /// /// Ensures duplicate messages are handled only once by tracking message IDs. +/// Uses PatternKit with claim → invoke → complete/fail semantics: +/// a successful processing marks the key Completed (suppressing future duplicates), while a +/// failure marks the key Failed and allows retry on the next attempt. /// public sealed class IdempotentReceiverStep : IStep { private readonly IStep _innerStep; private readonly Func _messageIdSelector; - private readonly HashSet _processedIds = new(); - private readonly object _lock = new(); + private readonly IIdempotencyStore _store; /// - /// Initializes a new instance of . + /// Initializes a new instance of with an injected + /// idempotency store. /// /// The step to wrap with idempotency. /// Function to extract a unique message ID from context. - public IdempotentReceiverStep(IStep innerStep, Func messageIdSelector) + /// The idempotency store to use. + public IdempotentReceiverStep(IStep innerStep, Func messageIdSelector, IIdempotencyStore store) { _innerStep = innerStep ?? throw new ArgumentNullException(nameof(innerStep)); _messageIdSelector = messageIdSelector ?? throw new ArgumentNullException(nameof(messageIdSelector)); + _store = store ?? throw new ArgumentNullException(nameof(store)); + } + + /// + /// Initializes a new instance of with the default + /// in-memory idempotency store. + /// + /// The step to wrap with idempotency. + /// Function to extract a unique message ID from context. + public IdempotentReceiverStep(IStep innerStep, Func messageIdSelector) + : this(innerStep, messageIdSelector, new RetryAfterFailureIdempotencyStore()) + { } /// @@ -29,12 +47,84 @@ public async Task ExecuteAsync(IWorkflowContext context) { var messageId = _messageIdSelector(context); - lock (_lock) + var claim = await _store.TryClaimAsync(messageId, context.CancellationToken).ConfigureAwait(false); + if (!claim.Claimed) + return; // Completed — successful duplicate, silently skip. + + try + { + await _innerStep.ExecuteAsync(context).ConfigureAwait(false); + await _store.MarkCompletedAsync(messageId, null, context.CancellationToken).ConfigureAwait(false); + } + catch { - if (!_processedIds.Add(messageId)) - return; // Already processed + await _store.MarkFailedAsync(messageId, null, context.CancellationToken).ConfigureAwait(false); + throw; } + } - await _innerStep.ExecuteAsync(context).ConfigureAwait(false); + /// + /// In-memory idempotency store that resets a Failed key to Processing on the next + /// TryClaim call, allowing retry after a transient failure. + /// This is the correct production behaviour: dedupe a Completed attempt, allow retry of a + /// Failed attempt. + /// + private sealed class RetryAfterFailureIdempotencyStore : IIdempotencyStore + { + private readonly object _gate = new(); + private readonly Dictionary _entries = new(StringComparer.Ordinal); + + public ValueTask TryClaimAsync(string key, CancellationToken cancellationToken = default) + { + cancellationToken.ThrowIfCancellationRequested(); + + lock (_gate) + { + if (_entries.TryGetValue(key, out var existing)) + { + if (existing.Status == IdempotencyEntryStatus.Failed) + { + // A prior attempt failed — reset to Processing so this attempt proceeds. + _entries[key] = new Entry(IdempotencyEntryStatus.Processing); + return new ValueTask(IdempotencyClaim.ClaimedKey(key)); + } + + // Key is Processing or Completed — do not allow concurrent or duplicate processing. + return new ValueTask( + IdempotencyClaim.Existing(key, existing.Status, existing.Result, null)); + } + + _entries[key] = new Entry(IdempotencyEntryStatus.Processing); + return new ValueTask(IdempotencyClaim.ClaimedKey(key)); + } + } + + public ValueTask MarkCompletedAsync(string key, object? result = null, CancellationToken cancellationToken = default) + { + cancellationToken.ThrowIfCancellationRequested(); + lock (_gate) + _entries[key] = new Entry(IdempotencyEntryStatus.Completed, result); + return default; + } + + public ValueTask MarkFailedAsync(string key, string? reason = null, CancellationToken cancellationToken = default) + { + cancellationToken.ThrowIfCancellationRequested(); + lock (_gate) + _entries[key] = new Entry(IdempotencyEntryStatus.Failed); + return default; + } + + private sealed class Entry + { + internal Entry(IdempotencyEntryStatus status, object? result = null) + { + Status = status; + Result = result; + } + + internal IdempotencyEntryStatus Status { get; } + internal object? Result { get; } + } } } diff --git a/src/WorkflowFramework.Extensions.Integration/Endpoint/PollingConsumerStep.cs b/src/WorkflowFramework.Extensions.Integration/Endpoint/PollingConsumerStep.cs index 23668e1..78ed8d3 100644 --- a/src/WorkflowFramework.Extensions.Integration/Endpoint/PollingConsumerStep.cs +++ b/src/WorkflowFramework.Extensions.Integration/Endpoint/PollingConsumerStep.cs @@ -1,14 +1,18 @@ +using PatternKit.Messaging; +using PatternKit.Messaging.Consumers; using WorkflowFramework.Extensions.Integration.Abstractions; namespace WorkflowFramework.Extensions.Integration.Endpoint; /// /// Periodically polls an external source for new data. +/// Delegates the single-shot poll to . /// /// The type of data items. public sealed class PollingConsumerStep : IStep { - private readonly IPollingSource _source; + private readonly AsyncPollingConsumer> _consumer; + /// /// The property key used to store polled items. /// @@ -20,7 +24,15 @@ public sealed class PollingConsumerStep : IStep /// The polling source. public PollingConsumerStep(IPollingSource source) { - _source = source ?? throw new ArgumentNullException(nameof(source)); + if (source is null) throw new ArgumentNullException(nameof(source)); + + _consumer = AsyncPollingConsumer>.Create("PollingConsumer") + .WithSource(async (_, ct) => + { + var items = await source.PollAsync(ct).ConfigureAwait(false); + return new Message>(items); + }) + .Build(); } /// @@ -29,7 +41,12 @@ public PollingConsumerStep(IPollingSource source) /// public async Task ExecuteAsync(IWorkflowContext context) { - var items = await _source.PollAsync(context.CancellationToken).ConfigureAwait(false); - context.Properties[ResultKey] = items; + var message = await _consumer.PollOnceAsync(ct: context.CancellationToken) + .ConfigureAwait(false); + + // PollOnceAsync returns null only when the source delegate returns null. + // Our delegate always returns a Message (wrapping an empty list when there are no items), + // so message will not be null in practice. The null-coalescing guard is defensive. + context.Properties[ResultKey] = message?.Payload ?? (IReadOnlyList)Array.Empty(); } } diff --git a/src/WorkflowFramework.Extensions.Integration/Transformation/NormalizerStep.cs b/src/WorkflowFramework.Extensions.Integration/Transformation/NormalizerStep.cs index c8ed340..f2c74b2 100644 --- a/src/WorkflowFramework.Extensions.Integration/Transformation/NormalizerStep.cs +++ b/src/WorkflowFramework.Extensions.Integration/Transformation/NormalizerStep.cs @@ -1,13 +1,15 @@ +using PatternKit.Messaging.Transformation; + namespace WorkflowFramework.Extensions.Integration.Transformation; /// /// Routes different data formats through format-specific translators to produce a canonical model. +/// Delegates to for O(1) keyed dispatch. /// public sealed class NormalizerStep : IStep { private readonly Func _formatDetector; - private readonly IDictionary _translators; - private readonly IStep? _defaultTranslator; + private readonly KeyedNormalizer? _normalizer; /// /// Initializes a new instance of . @@ -21,8 +23,35 @@ public NormalizerStep( IStep? defaultTranslator = null) { _formatDetector = formatDetector ?? throw new ArgumentNullException(nameof(formatDetector)); - _translators = translators ?? throw new ArgumentNullException(nameof(translators)); - _defaultTranslator = defaultTranslator; + _ = translators ?? throw new ArgumentNullException(nameof(translators)); + + var builder = KeyedNormalizer.Create("Normalizer"); + + foreach (var kvp in translators) + { + var key = kvp.Key; + var captured = kvp.Value; + builder.When(key, async (ctx, ct) => + { + await captured.ExecuteAsync(ctx).ConfigureAwait(false); + return ctx; + }); + } + + if (defaultTranslator is not null) + { + var capturedDefault = defaultTranslator; + builder.Default(async (ctx, ct) => + { + await capturedDefault.ExecuteAsync(ctx).ConfigureAwait(false); + return ctx; + }); + } + + // Build only when there is at least one handler or a default; otherwise keep null + // so the empty-dict case falls through to our own exception with the original message. + if (translators.Count > 0 || defaultTranslator is not null) + _normalizer = builder.Build(); } /// @@ -33,17 +62,23 @@ public async Task ExecuteAsync(IWorkflowContext context) { var format = _formatDetector(context); - if (_translators.TryGetValue(format, out var translator)) + if (_normalizer is null) { - await translator.ExecuteAsync(context).ConfigureAwait(false); + // No handlers registered and no default — preserve the original error contract. + throw new InvalidOperationException( + $"No translator found for format '{format}' and no default translator configured."); } - else if (_defaultTranslator != null) + + try { - await _defaultTranslator.ExecuteAsync(context).ConfigureAwait(false); + await _normalizer.NormalizeAsync(format, context, context.CancellationToken).ConfigureAwait(false); } - else + catch (KeyNotFoundException) { - throw new InvalidOperationException($"No translator found for format '{format}' and no default translator configured."); + // PatternKit throws KeyNotFoundException on a miss; wrap to preserve the original + // InvalidOperationException contract that characterization tests assert on. + throw new InvalidOperationException( + $"No translator found for format '{format}' and no default translator configured."); } } } diff --git a/src/WorkflowFramework.Extensions.Integration/packages.lock.json b/src/WorkflowFramework.Extensions.Integration/packages.lock.json index db99d55..07e13b1 100644 --- a/src/WorkflowFramework.Extensions.Integration/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Integration/packages.lock.json @@ -23,9 +23,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", "dependencies": { "System.Threading.Tasks.Extensions": "4.6.3" } @@ -67,7 +67,7 @@ "workflowframework": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.integration.abstractions": { @@ -90,9 +90,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "PolySharp": { "type": "Direct", @@ -113,7 +113,7 @@ "workflowframework": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.integration.abstractions": { @@ -136,9 +136,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", @@ -185,7 +185,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.integration.abstractions": { @@ -246,9 +246,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", @@ -296,7 +296,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.integration.abstractions": { @@ -364,9 +364,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", @@ -414,7 +414,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.integration.abstractions": { diff --git a/src/WorkflowFramework.Extensions.Persistence.EntityFramework/packages.lock.json b/src/WorkflowFramework.Extensions.Persistence.EntityFramework/packages.lock.json index f8e5045..99dcbfc 100644 --- a/src/WorkflowFramework.Extensions.Persistence.EntityFramework/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Persistence.EntityFramework/packages.lock.json @@ -126,7 +126,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection": { @@ -175,6 +176,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -317,7 +324,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection": { @@ -368,6 +376,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -515,7 +529,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection": { @@ -566,6 +581,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Persistence.InMemory/packages.lock.json b/src/WorkflowFramework.Extensions.Persistence.InMemory/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Persistence.InMemory/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Persistence.InMemory/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Persistence.PostgreSQL/packages.lock.json b/src/WorkflowFramework.Extensions.Persistence.PostgreSQL/packages.lock.json index cbcf3d4..5359472 100644 --- a/src/WorkflowFramework.Extensions.Persistence.PostgreSQL/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Persistence.PostgreSQL/packages.lock.json @@ -113,7 +113,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence.entityframework": { @@ -197,6 +198,12 @@ "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "8.0.2" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -322,7 +329,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence.entityframework": { @@ -409,6 +417,12 @@ "Microsoft.Extensions.Logging.Abstractions": "8.0.2" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -549,7 +563,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence.entityframework": { @@ -636,6 +651,12 @@ "Microsoft.Extensions.Logging.Abstractions": "8.0.2" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Persistence.SqlServer/packages.lock.json b/src/WorkflowFramework.Extensions.Persistence.SqlServer/packages.lock.json index 5d47cb9..b7662eb 100644 --- a/src/WorkflowFramework.Extensions.Persistence.SqlServer/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Persistence.SqlServer/packages.lock.json @@ -303,7 +303,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence.entityframework": { @@ -378,6 +379,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -706,7 +713,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence.entityframework": { @@ -784,6 +792,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -1120,7 +1134,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence.entityframework": { @@ -1198,6 +1213,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Persistence.Sqlite/packages.lock.json b/src/WorkflowFramework.Extensions.Persistence.Sqlite/packages.lock.json index ff4425f..98afc4c 100644 --- a/src/WorkflowFramework.Extensions.Persistence.Sqlite/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Persistence.Sqlite/packages.lock.json @@ -108,7 +108,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -148,6 +149,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -272,7 +279,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -314,6 +322,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -443,7 +457,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -485,6 +500,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Persistence/packages.lock.json b/src/WorkflowFramework.Extensions.Persistence/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Persistence/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Persistence/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Plugins/packages.lock.json b/src/WorkflowFramework.Extensions.Plugins/packages.lock.json index a7eae5d..e6a46a3 100644 --- a/src/WorkflowFramework.Extensions.Plugins/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Plugins/packages.lock.json @@ -62,19 +62,31 @@ }, "System.Runtime.CompilerServices.Unsafe": { "type": "Transitive", - "resolved": "4.5.3", - "contentHash": "3TIsJhD1EiiT0w2CcDMN/iSSwnNnsrnbzeVHSKkaEgV85txMprmuO+Yq2AdSbeVGcg28pdNDTPK87tJhX7VFHw==" + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" }, "System.Threading.Tasks.Extensions": { "type": "Transitive", - "resolved": "4.5.4", - "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", "dependencies": { - "System.Runtime.CompilerServices.Unsafe": "4.5.3" + "System.Runtime.CompilerServices.Unsafe": "6.1.2" } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -111,7 +123,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -175,7 +196,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -209,6 +231,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -273,7 +301,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -309,6 +338,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -378,7 +413,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.Hosting.Abstractions": { @@ -414,6 +450,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Polly/packages.lock.json b/src/WorkflowFramework.Extensions.Polly/packages.lock.json index f433906..eef432e 100644 --- a/src/WorkflowFramework.Extensions.Polly/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Polly/packages.lock.json @@ -23,9 +23,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", "dependencies": { "System.Threading.Tasks.Extensions": "4.6.3" } @@ -100,7 +100,7 @@ "workflowframework": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } } }, @@ -117,9 +117,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "Direct", @@ -169,7 +169,7 @@ "workflowframework": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } } }, @@ -186,9 +186,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "Direct", @@ -241,7 +241,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -296,9 +296,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "Direct", @@ -352,7 +352,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -414,9 +414,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "Direct", @@ -470,7 +470,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { diff --git a/src/WorkflowFramework.Extensions.Reactive/packages.lock.json b/src/WorkflowFramework.Extensions.Reactive/packages.lock.json index 8442f8e..124aa76 100644 --- a/src/WorkflowFramework.Extensions.Reactive/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Reactive/packages.lock.json @@ -29,7 +29,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -87,7 +96,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -127,6 +137,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -185,7 +201,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -227,6 +244,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -290,7 +313,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -332,6 +356,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Scheduling/packages.lock.json b/src/WorkflowFramework.Extensions.Scheduling/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Scheduling/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Scheduling/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Extensions.Visualization/packages.lock.json b/src/WorkflowFramework.Extensions.Visualization/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Extensions.Visualization/packages.lock.json +++ b/src/WorkflowFramework.Extensions.Visualization/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Serialization/packages.lock.json b/src/WorkflowFramework.Serialization/packages.lock.json index f0028b7..27a3566 100644 --- a/src/WorkflowFramework.Serialization/packages.lock.json +++ b/src/WorkflowFramework.Serialization/packages.lock.json @@ -119,7 +119,19 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -185,7 +197,16 @@ } }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -243,7 +264,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -283,6 +305,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -341,7 +369,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -383,6 +412,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -446,7 +481,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -488,6 +524,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework.Testing/packages.lock.json b/src/WorkflowFramework.Testing/packages.lock.json index 654f038..c07646c 100644 --- a/src/WorkflowFramework.Testing/packages.lock.json +++ b/src/WorkflowFramework.Testing/packages.lock.json @@ -42,8 +42,33 @@ "resolved": "8.0.0", "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, + "System.Runtime.CompilerServices.Unsafe": { + "type": "Transitive", + "resolved": "6.1.2", + "contentHash": "2hBr6zdbIBTDE3EhK7NSVNdX58uTK6iHW/P/Axmm9sl1xoGSLqDvMtpecn226TNwHByFokYwJmt/aQQNlO5CRw==" + }, + "System.Threading.Tasks.Extensions": { + "type": "Transitive", + "resolved": "4.6.3", + "contentHash": "7sCiwilJLYbTZELaKnc7RecBBXWXA+xMLQWZKWawBxYjp6DBlSE3v9/UcvKBvr1vv2tTOhipiogM8rRmxlhrVA==", + "dependencies": { + "System.Runtime.CompilerServices.Unsafe": "6.1.2" + } + }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", + "dependencies": { + "System.Threading.Tasks.Extensions": "4.6.3" + } } }, ".NETStandard,Version=v2.1": { @@ -74,7 +99,16 @@ "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==" }, "workflowframework": { - "type": "Project" + "type": "Project", + "dependencies": { + "PatternKit.Core": "[0.113.0, )" + } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net10.0": { @@ -132,7 +166,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -172,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -230,7 +271,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -272,6 +314,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -335,7 +383,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -377,6 +426,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/src/WorkflowFramework/packages.lock.json b/src/WorkflowFramework/packages.lock.json index 2b5a5c6..a78940d 100644 --- a/src/WorkflowFramework/packages.lock.json +++ b/src/WorkflowFramework/packages.lock.json @@ -23,9 +23,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==", "dependencies": { "System.Threading.Tasks.Extensions": "4.6.3" } @@ -78,9 +78,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "PolySharp": { "type": "Direct", @@ -131,9 +131,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", @@ -227,9 +227,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", @@ -331,9 +331,9 @@ }, "PatternKit.Core": { "type": "Direct", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", diff --git a/tests/WorkflowFramework.Cli.Tests/packages.lock.json b/tests/WorkflowFramework.Cli.Tests/packages.lock.json index af8bb7a..831d27d 100644 --- a/tests/WorkflowFramework.Cli.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Cli.Tests/packages.lock.json @@ -153,7 +153,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.cli": { @@ -208,6 +209,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.CommandLine": { "type": "CentralTransitive", "requested": "[2.0.0-beta4.22272.1, )", diff --git a/tests/WorkflowFramework.Dashboard.Api.Tests/packages.lock.json b/tests/WorkflowFramework.Dashboard.Api.Tests/packages.lock.json index d152e66..fb8f93a 100644 --- a/tests/WorkflowFramework.Dashboard.Api.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Dashboard.Api.Tests/packages.lock.json @@ -656,7 +656,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.dashboard.api": { @@ -906,6 +907,12 @@ "OpenTelemetry.Api": "[1.12.0, 2.0.0)" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "Polly.Core": { "type": "CentralTransitive", "requested": "[8.6.0, )", diff --git a/tests/WorkflowFramework.Dashboard.Persistence.Tests/packages.lock.json b/tests/WorkflowFramework.Dashboard.Persistence.Tests/packages.lock.json index d152e66..fb8f93a 100644 --- a/tests/WorkflowFramework.Dashboard.Persistence.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Dashboard.Persistence.Tests/packages.lock.json @@ -656,7 +656,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.dashboard.api": { @@ -906,6 +907,12 @@ "OpenTelemetry.Api": "[1.12.0, 2.0.0)" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "Polly.Core": { "type": "CentralTransitive", "requested": "[8.6.0, )", diff --git a/tests/WorkflowFramework.Dashboard.Tests/packages.lock.json b/tests/WorkflowFramework.Dashboard.Tests/packages.lock.json index be730c9..f76728f 100644 --- a/tests/WorkflowFramework.Dashboard.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Dashboard.Tests/packages.lock.json @@ -723,7 +723,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.dashboard": { @@ -1019,6 +1020,12 @@ "OpenTelemetry.Api": "[1.12.0, 2.0.0)" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "Polly.Core": { "type": "CentralTransitive", "requested": "[8.6.0, )", @@ -1207,7 +1214,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.dashboard": { @@ -1264,6 +1272,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -1452,7 +1466,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.dashboard": { @@ -1509,6 +1524,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.AI.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.AI.Tests/packages.lock.json index 69ccb8f..fd999a6 100644 --- a/tests/WorkflowFramework.Extensions.AI.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.AI.Tests/packages.lock.json @@ -342,7 +342,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -411,9 +411,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -796,7 +796,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -866,9 +866,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -1267,7 +1267,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.ai": { @@ -1337,9 +1337,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Agents.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Agents.Tests/packages.lock.json index 3c86e54..420d381 100644 --- a/tests/WorkflowFramework.Extensions.Agents.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Agents.Tests/packages.lock.json @@ -351,7 +351,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -419,9 +419,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -813,7 +813,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -883,9 +883,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -1293,7 +1293,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -1363,9 +1363,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Approvals.Abstractions.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Approvals.Abstractions.Tests/packages.lock.json index 7b646eb..4166477 100644 --- a/tests/WorkflowFramework.Extensions.Approvals.Abstractions.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Approvals.Abstractions.Tests/packages.lock.json @@ -159,7 +159,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals.abstractions": { @@ -206,6 +207,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -367,7 +374,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals.abstractions": { @@ -416,6 +424,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -582,7 +596,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals.abstractions": { @@ -631,6 +646,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Approvals.Cli.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Approvals.Cli.Tests/packages.lock.json index 7b07c5e..2878968 100644 --- a/tests/WorkflowFramework.Extensions.Approvals.Cli.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Approvals.Cli.Tests/packages.lock.json @@ -190,7 +190,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -265,6 +266,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.CommandLine": { "type": "CentralTransitive", "requested": "[2.0.0-beta4.22272.1, )", @@ -462,7 +469,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -538,6 +546,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.CommandLine": { "type": "CentralTransitive", "requested": "[2.0.0-beta4.22272.1, )", @@ -741,7 +755,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -817,6 +832,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.CommandLine": { "type": "CentralTransitive", "requested": "[2.0.0-beta4.22272.1, )", diff --git a/tests/WorkflowFramework.Extensions.Approvals.Email.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Approvals.Email.Tests/packages.lock.json index 0cbd5c8..36de93c 100644 --- a/tests/WorkflowFramework.Extensions.Approvals.Email.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Approvals.Email.Tests/packages.lock.json @@ -203,7 +203,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -261,6 +262,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -466,7 +473,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -528,6 +536,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -738,7 +752,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -800,6 +815,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Approvals.Slack.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Approvals.Slack.Tests/packages.lock.json index a704fbd..75d7ed3 100644 --- a/tests/WorkflowFramework.Extensions.Approvals.Slack.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Approvals.Slack.Tests/packages.lock.json @@ -190,7 +190,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -261,6 +262,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -503,7 +510,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -593,6 +601,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -840,7 +854,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -930,6 +945,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Approvals.Teams.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Approvals.Teams.Tests/packages.lock.json index 77278d9..8256316 100644 --- a/tests/WorkflowFramework.Extensions.Approvals.Teams.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Approvals.Teams.Tests/packages.lock.json @@ -190,7 +190,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -261,6 +262,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -503,7 +510,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -593,6 +601,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -840,7 +854,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -930,6 +945,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Approvals.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Approvals.Tests/packages.lock.json index 62d7a55..6a4e8ba 100644 --- a/tests/WorkflowFramework.Extensions.Approvals.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Approvals.Tests/packages.lock.json @@ -52,6 +52,27 @@ "Castle.Core": "5.1.1" } }, + "TinyBDD": { + "type": "Direct", + "requested": "[0.19.16, )", + "resolved": "0.19.16", + "contentHash": "H9FEUkilavosn+wNDUItTPxOYRtQXzyt0dz+1wTyUKeijvois0FX2fkHEde08ockkOpebqffJxSleIH+7jZe7w==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection": "10.0.5", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5" + } + }, + "TinyBDD.Xunit": { + "type": "Direct", + "requested": "[0.19.16, )", + "resolved": "0.19.16", + "contentHash": "DgqB3Il3xiidn065cOga4HbyXWRV3hdgrKQKWThaXCWH40XkyWMt6ZttRuVs4LgFf73OSIsgxjrt3Tm7731O1g==", + "dependencies": { + "TinyBDD": "0.19.16", + "xunit.abstractions": "2.0.3", + "xunit.extensibility.core": "2.9.3" + } + }, "xunit": { "type": "Direct", "requested": "[2.9.3, )", @@ -190,7 +211,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -254,6 +276,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -307,6 +335,27 @@ "Castle.Core": "5.1.1" } }, + "TinyBDD": { + "type": "Direct", + "requested": "[0.19.16, )", + "resolved": "0.19.16", + "contentHash": "H9FEUkilavosn+wNDUItTPxOYRtQXzyt0dz+1wTyUKeijvois0FX2fkHEde08ockkOpebqffJxSleIH+7jZe7w==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection": "10.0.5", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5" + } + }, + "TinyBDD.Xunit": { + "type": "Direct", + "requested": "[0.19.16, )", + "resolved": "0.19.16", + "contentHash": "DgqB3Il3xiidn065cOga4HbyXWRV3hdgrKQKWThaXCWH40XkyWMt6ZttRuVs4LgFf73OSIsgxjrt3Tm7731O1g==", + "dependencies": { + "TinyBDD": "0.19.16", + "xunit.abstractions": "2.0.3", + "xunit.extensibility.core": "2.9.3" + } + }, "xunit": { "type": "Direct", "requested": "[2.9.3, )", @@ -446,7 +495,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -512,6 +562,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -570,6 +626,27 @@ "Castle.Core": "5.1.1" } }, + "TinyBDD": { + "type": "Direct", + "requested": "[0.19.16, )", + "resolved": "0.19.16", + "contentHash": "H9FEUkilavosn+wNDUItTPxOYRtQXzyt0dz+1wTyUKeijvois0FX2fkHEde08ockkOpebqffJxSleIH+7jZe7w==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection": "10.0.5", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5" + } + }, + "TinyBDD.Xunit": { + "type": "Direct", + "requested": "[0.19.16, )", + "resolved": "0.19.16", + "contentHash": "DgqB3Il3xiidn065cOga4HbyXWRV3hdgrKQKWThaXCWH40XkyWMt6ZttRuVs4LgFf73OSIsgxjrt3Tm7731O1g==", + "dependencies": { + "TinyBDD": "0.19.16", + "xunit.abstractions": "2.0.3", + "xunit.extensibility.core": "2.9.3" + } + }, "xunit": { "type": "Direct", "requested": "[2.9.3, )", @@ -709,7 +786,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.approvals": { @@ -775,6 +853,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Configuration.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Configuration.Tests/packages.lock.json index 5f60e21..263bf1d 100644 --- a/tests/WorkflowFramework.Extensions.Configuration.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Configuration.Tests/packages.lock.json @@ -212,7 +212,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.configuration": { @@ -263,9 +263,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "YamlDotNet": { "type": "CentralTransitive", @@ -496,7 +496,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.configuration": { @@ -549,9 +549,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -798,7 +798,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.configuration": { @@ -851,9 +851,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Connectors.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Connectors.Tests/packages.lock.json index db106a1..bd65a03 100644 --- a/tests/WorkflowFramework.Extensions.Connectors.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Connectors.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -269,9 +269,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -477,7 +477,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -544,9 +544,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -758,7 +758,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.connectors.abstractions": { @@ -825,9 +825,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.DataMapping.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.DataMapping.Tests/packages.lock.json index 8062ac7..7b18951 100644 --- a/tests/WorkflowFramework.Extensions.DataMapping.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.DataMapping.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -262,9 +262,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -480,7 +480,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -541,9 +541,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -775,7 +775,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.datamapping": { @@ -836,9 +836,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.DependencyInjection.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.DependencyInjection.Tests/packages.lock.json index 151ce37..fe44e98 100644 --- a/tests/WorkflowFramework.Extensions.DependencyInjection.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.DependencyInjection.Tests/packages.lock.json @@ -212,7 +212,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -262,9 +262,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -479,7 +479,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -530,9 +530,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -753,7 +753,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -804,9 +804,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Diagnostics.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Diagnostics.Tests/packages.lock.json index 4e7bdfc..b1bec64 100644 --- a/tests/WorkflowFramework.Extensions.Diagnostics.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Diagnostics.Tests/packages.lock.json @@ -212,7 +212,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -262,9 +262,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -480,7 +480,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -531,9 +531,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -755,7 +755,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.diagnostics": { @@ -806,9 +806,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Distributed.Redis.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Distributed.Redis.Tests/packages.lock.json index eaf311c..a088e6e 100644 --- a/tests/WorkflowFramework.Extensions.Distributed.Redis.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Distributed.Redis.Tests/packages.lock.json @@ -319,7 +319,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -384,9 +384,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -722,7 +722,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -790,9 +790,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -1140,7 +1140,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.distributed": { @@ -1208,9 +1208,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Events.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Events.Tests/packages.lock.json index c7b2d4d..5d831f6 100644 --- a/tests/WorkflowFramework.Extensions.Events.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Events.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.events": { @@ -261,9 +261,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -469,7 +469,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.events": { @@ -528,9 +528,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -742,7 +742,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.events": { @@ -801,9 +801,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Expressions.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Expressions.Tests/packages.lock.json index f644686..fc5b7b6 100644 --- a/tests/WorkflowFramework.Extensions.Expressions.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Expressions.Tests/packages.lock.json @@ -202,7 +202,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.expressions": { @@ -257,6 +258,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -461,7 +468,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.expressions": { @@ -518,6 +526,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -727,7 +741,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.expressions": { @@ -784,6 +799,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Hosting.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Hosting.Tests/packages.lock.json index 6d40131..7a99e4a 100644 --- a/tests/WorkflowFramework.Extensions.Hosting.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Hosting.Tests/packages.lock.json @@ -428,7 +428,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -503,9 +503,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -955,7 +955,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -1031,9 +1031,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -1499,7 +1499,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -1575,9 +1575,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Http.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Http.Tests/packages.lock.json index d36e510..d9fe95e 100644 --- a/tests/WorkflowFramework.Extensions.Http.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Http.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.http": { @@ -261,9 +261,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -469,7 +469,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.http": { @@ -528,9 +528,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -742,7 +742,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.http": { @@ -801,9 +801,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.HumanTasks.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.HumanTasks.Tests/packages.lock.json index 7306b61..703da48 100644 --- a/tests/WorkflowFramework.Extensions.HumanTasks.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.HumanTasks.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.humantasks": { @@ -261,9 +261,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -469,7 +469,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.humantasks": { @@ -528,9 +528,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -742,7 +742,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.humantasks": { @@ -801,9 +801,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Persistence.InMemory.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Persistence.InMemory.Tests/packages.lock.json index b9b212b..b5a2553 100644 --- a/tests/WorkflowFramework.Extensions.Persistence.InMemory.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Persistence.InMemory.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -267,9 +267,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -475,7 +475,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -540,9 +540,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -754,7 +754,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -819,9 +819,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Persistence.Sqlite.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Persistence.Sqlite.Tests/packages.lock.json index 2cac96e..c4d9618 100644 --- a/tests/WorkflowFramework.Extensions.Persistence.Sqlite.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Persistence.Sqlite.Tests/packages.lock.json @@ -249,7 +249,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -314,9 +314,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -578,7 +578,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -645,9 +645,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -925,7 +925,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -992,9 +992,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Persistence.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Persistence.Tests/packages.lock.json index ec4b038..861ffdf 100644 --- a/tests/WorkflowFramework.Extensions.Persistence.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Persistence.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -261,9 +261,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -469,7 +469,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -528,9 +528,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -742,7 +742,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.persistence": { @@ -801,9 +801,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Plugins.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Plugins.Tests/packages.lock.json index 90d15a2..f8ba15d 100644 --- a/tests/WorkflowFramework.Extensions.Plugins.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Plugins.Tests/packages.lock.json @@ -212,7 +212,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.plugins": { @@ -262,9 +262,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -479,7 +479,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.plugins": { @@ -530,9 +530,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -753,7 +753,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.plugins": { @@ -804,9 +804,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Polly.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Polly.Tests/packages.lock.json index 155f9e7..1f33a84 100644 --- a/tests/WorkflowFramework.Extensions.Polly.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Polly.Tests/packages.lock.json @@ -209,13 +209,13 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -269,9 +269,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -483,13 +483,13 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -544,9 +544,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -764,13 +764,13 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -825,9 +825,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Reactive.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Reactive.Tests/packages.lock.json index b1bfcf4..bd36c49 100644 --- a/tests/WorkflowFramework.Extensions.Reactive.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Reactive.Tests/packages.lock.json @@ -202,7 +202,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.reactive": { @@ -257,6 +258,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -461,7 +468,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.reactive": { @@ -518,6 +526,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -727,7 +741,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.reactive": { @@ -784,6 +799,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Extensions.Scheduling.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Scheduling.Tests/packages.lock.json index b4cd80c..70c7b75 100644 --- a/tests/WorkflowFramework.Extensions.Scheduling.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Scheduling.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.scheduling": { @@ -261,9 +261,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -469,7 +469,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.scheduling": { @@ -528,9 +528,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -742,7 +742,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.scheduling": { @@ -801,9 +801,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Extensions.Visualization.Tests/packages.lock.json b/tests/WorkflowFramework.Extensions.Visualization.Tests/packages.lock.json index 5565c4a..ff27435 100644 --- a/tests/WorkflowFramework.Extensions.Visualization.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Extensions.Visualization.Tests/packages.lock.json @@ -203,7 +203,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.visualization": { @@ -261,9 +261,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -469,7 +469,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.visualization": { @@ -528,9 +528,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -742,7 +742,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.visualization": { @@ -801,9 +801,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Tests.Common/packages.lock.json b/tests/WorkflowFramework.Tests.Common/packages.lock.json index e212491..ebe56d7 100644 --- a/tests/WorkflowFramework.Tests.Common/packages.lock.json +++ b/tests/WorkflowFramework.Tests.Common/packages.lock.json @@ -56,7 +56,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -96,6 +97,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -154,7 +161,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -196,6 +204,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", @@ -259,7 +273,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "Microsoft.Extensions.DependencyInjection.Abstractions": { @@ -301,6 +316,12 @@ "Microsoft.Extensions.Primitives": "10.0.5" } }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" + }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", "requested": "[10.0.5, )", diff --git a/tests/WorkflowFramework.Tests.E2E/packages.lock.json b/tests/WorkflowFramework.Tests.E2E/packages.lock.json index ffc8a48..d957893 100644 --- a/tests/WorkflowFramework.Tests.E2E/packages.lock.json +++ b/tests/WorkflowFramework.Tests.E2E/packages.lock.json @@ -342,7 +342,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -451,6 +452,12 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.5", "Microsoft.Extensions.Primitives": "10.0.5" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/tests/WorkflowFramework.Tests.Integration/packages.lock.json b/tests/WorkflowFramework.Tests.Integration/packages.lock.json index 84074fb..6652c09 100644 --- a/tests/WorkflowFramework.Tests.Integration/packages.lock.json +++ b/tests/WorkflowFramework.Tests.Integration/packages.lock.json @@ -169,7 +169,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -201,7 +201,7 @@ "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -252,9 +252,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "CentralTransitive", @@ -432,7 +432,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -465,7 +465,7 @@ "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -517,9 +517,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "CentralTransitive", @@ -703,7 +703,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.dependencyinjection": { @@ -736,7 +736,7 @@ "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -788,9 +788,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Tests.Samples/packages.lock.json b/tests/WorkflowFramework.Tests.Samples/packages.lock.json index 052403d..b0afd17 100644 --- a/tests/WorkflowFramework.Tests.Samples/packages.lock.json +++ b/tests/WorkflowFramework.Tests.Samples/packages.lock.json @@ -537,7 +537,8 @@ "type": "Project", "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", - "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )" + "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -749,6 +750,12 @@ "Microsoft.SemanticKernel.Core": "1.71.0", "OllamaSharp": "5.4.12" } + }, + "PatternKit.Core": { + "type": "CentralTransitive", + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } } } diff --git a/tests/WorkflowFramework.Tests.TinyBDD/Integration/Endpoint/IdempotentReceiverStepScenarios.cs b/tests/WorkflowFramework.Tests.TinyBDD/Integration/Endpoint/IdempotentReceiverStepScenarios.cs index d684781..8dd68cf 100644 --- a/tests/WorkflowFramework.Tests.TinyBDD/Integration/Endpoint/IdempotentReceiverStepScenarios.cs +++ b/tests/WorkflowFramework.Tests.TinyBDD/Integration/Endpoint/IdempotentReceiverStepScenarios.cs @@ -9,12 +9,12 @@ namespace WorkflowFramework.Tests.TinyBDD.Integration.Endpoint; -// Bespoke kept: IdempotentReceiverStep manages mutable state (a HashSet of processed IDs -// behind a lock) that has no direct analogue in PatternKit's structural/behavioural catalog. -// PatternKit does not expose an idempotency-filter primitive. Characterization-only coverage -// is provided here to lock in the current contract. +// Iteration 2: IdempotentReceiverStep now delegates to PatternKit IIdempotencyStore with +// claim → invoke → complete/fail semantics. The prior bespoke HashSet.Add-before-invoke +// behaviour permanently locked the key on failure (latent bug). PatternKit's model correctly +// allows retry after a failed attempt. See .plan/patternkit-iteration-2.md §4. -[Feature("IdempotentReceiverStep — characterization (Phase G.4)")] +[Feature("IdempotentReceiverStep — characterization (Phase G.4 / Iter2)")] public class IdempotentReceiverStepScenarios : TinyBddTestBase { public IdempotentReceiverStepScenarios(ITestOutputHelper output) : base(output) { } @@ -168,7 +168,7 @@ await Given("processed IDs after mixed sequence", () => processed) .AssertPassed(); } - [Scenario("Inner step exception propagates and does not mark the ID as seen"), Fact] + [Scenario("Inner step exception propagates to caller"), Fact] public async Task InnerExceptionPropagatesToCaller() { var callCount = 0; @@ -183,8 +183,6 @@ public async Task InnerExceptionPropagatesToCaller() var sut = new IdempotentReceiverStep(inner, _ => "err-id"); var ctx = new WorkflowContext(); - // NOTE: The ID is added to the set BEFORE calling inner, so a second call IS skipped - // even if inner threw. This characterizes the current bespoke implementation. Exception? caught = null; try { await sut.ExecuteAsync(ctx); } catch (InvalidOperationException ex) { caught = ex; } @@ -199,8 +197,13 @@ await Given("exception from inner step on first call", () => caught) .AssertPassed(); } - [Scenario("Re-attempt after exception is silently skipped (ID was already registered)"), Fact] - public async Task ReAttemptAfterExceptionIsSkipped() + // This is a deliberate bug fix in Iteration 2. Prior behavior was permanent dedup on failure + // (latent bug — failure should not lock future attempts). PatternKit's IIdempotencyStore + // provides claim/complete/fail semantics; the default RetryAfterFailureIdempotencyStore + // resets a Failed key to Processing on the next TryClaim, correctly allowing retry. + // See .plan/patternkit-iteration-2.md §4. + [Scenario("Re-attempt after exception is allowed (failure releases the idempotency key)"), Fact] + public async Task ReAttemptAfterExceptionIsAllowed() { var callCount = 0; var inner = Substitute.For(); @@ -211,16 +214,16 @@ public async Task ReAttemptAfterExceptionIsSkipped() throw new InvalidOperationException("boom"); }); - var sut = new IdempotentReceiverStep(inner, _ => "sticky-id"); + var sut = new IdempotentReceiverStep(inner, _ => "retry-id"); var ctx = new WorkflowContext(); - try { await sut.ExecuteAsync(ctx); } catch { /* expected */ } - try { await sut.ExecuteAsync(ctx); } catch { /* second attempt — should be skipped */ } + try { await sut.ExecuteAsync(ctx); } catch { /* expected — first attempt fails */ } + try { await sut.ExecuteAsync(ctx); } catch { /* second attempt — now allowed */ } await Given("call count after first-attempt failure then second attempt", () => callCount) - .Then("inner was called only once (ID was registered before the throw)", count => + .Then("inner was called twice (failure released the key, allowing retry)", count => { - count.Should().Be(1); + count.Should().Be(2); return true; }) .AssertPassed(); diff --git a/tests/WorkflowFramework.Tests.TinyBDD/packages.lock.json b/tests/WorkflowFramework.Tests.TinyBDD/packages.lock.json index 9f0f5dc..43b6cec 100644 --- a/tests/WorkflowFramework.Tests.TinyBDD/packages.lock.json +++ b/tests/WorkflowFramework.Tests.TinyBDD/packages.lock.json @@ -342,7 +342,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -377,7 +377,7 @@ "workflowframework.extensions.integration": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.112.0, )", + "PatternKit.Core": "[0.113.0, )", "WorkflowFramework": "[1.0.0, )", "WorkflowFramework.Extensions.Integration.Abstractions": "[1.0.0, )" } @@ -472,9 +472,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" } }, "net8.0": { @@ -857,7 +857,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -894,7 +894,7 @@ "workflowframework.extensions.integration": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.112.0, )", + "PatternKit.Core": "[0.113.0, )", "WorkflowFramework": "[1.0.0, )", "WorkflowFramework.Extensions.Integration.Abstractions": "[1.0.0, )" } @@ -990,9 +990,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", @@ -1391,7 +1391,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.112.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -1428,7 +1428,7 @@ "workflowframework.extensions.integration": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.112.0, )", + "PatternKit.Core": "[0.113.0, )", "WorkflowFramework": "[1.0.0, )", "WorkflowFramework.Extensions.Integration.Abstractions": "[1.0.0, )" } @@ -1524,9 +1524,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.112.0, )", - "resolved": "0.112.0", - "contentHash": "iy+Pb7E4Wv06rWF0QciwFvFVjDaT+b1svE4SqscA70vU05z1I8I+krqnKnG+hG7FZJ3NVrN5zZ+FpYJnoRziIw==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "System.Diagnostics.DiagnosticSource": { "type": "CentralTransitive", diff --git a/tests/WorkflowFramework.Tests/packages.lock.json b/tests/WorkflowFramework.Tests/packages.lock.json index 1fd6f4d..5e42b32 100644 --- a/tests/WorkflowFramework.Tests/packages.lock.json +++ b/tests/WorkflowFramework.Tests/packages.lock.json @@ -583,7 +583,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -728,7 +728,7 @@ "workflowframework.extensions.integration": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "WorkflowFramework": "[1.0.0, )", "WorkflowFramework.Extensions.Integration.Abstractions": "[1.0.0, )" } @@ -792,7 +792,7 @@ "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -953,9 +953,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "CentralTransitive", @@ -1602,7 +1602,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -1754,7 +1754,7 @@ "workflowframework.extensions.integration": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "WorkflowFramework": "[1.0.0, )", "WorkflowFramework.Extensions.Integration.Abstractions": "[1.0.0, )" } @@ -1820,7 +1820,7 @@ "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -1985,9 +1985,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "CentralTransitive", @@ -2645,7 +2645,7 @@ "dependencies": { "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.5, )", "Microsoft.Extensions.Hosting.Abstractions": "[10.0.5, )", - "PatternKit.Core": "[0.105.0, )" + "PatternKit.Core": "[0.113.0, )" } }, "workflowframework.extensions.agents": { @@ -2797,7 +2797,7 @@ "workflowframework.extensions.integration": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "WorkflowFramework": "[1.0.0, )", "WorkflowFramework.Extensions.Integration.Abstractions": "[1.0.0, )" } @@ -2863,7 +2863,7 @@ "workflowframework.extensions.polly": { "type": "Project", "dependencies": { - "PatternKit.Core": "[0.105.0, )", + "PatternKit.Core": "[0.113.0, )", "Polly.Core": "[8.6.0, )", "WorkflowFramework": "[1.0.0, )" } @@ -3026,9 +3026,9 @@ }, "PatternKit.Core": { "type": "CentralTransitive", - "requested": "[0.105.0, )", - "resolved": "0.105.0", - "contentHash": "ajdoXIVxeDeTi1NhS0ykTQHk4u/FpdvYrGx9DKvpwzc3z65rSBIWSOLn1vOG2O2tYnZQTxaDC3TSno1MyLhjBg==" + "requested": "[0.113.0, )", + "resolved": "0.113.0", + "contentHash": "gnHABPF+MK6UmTm3Q0q6UjN1ZLx+A260nDHdk8nq6BTL9m3oZXACmDDiBaYJV4lQjQj5Bg1uEUGqlzSLCBrX0Q==" }, "Polly.Core": { "type": "CentralTransitive",