# найбільш зрозуміле.невичерпнеM SK1повне ; дивна послідовна модель системи в LRU-каші.

<!--category-- mostlylucid-ephemeral -->
<datetime class="hidden">2025-12-14T13:35</datetime>

Це була моя одержимість протягом минулого тижня. [попередні частини](/blog/ephemeral-execution-library) і що призвело до цього[Що якби LRU був контекстом виконання.'](/blog/learning-lrus-when-capacity-makes-systems-better). Тепер це ' це набір пакетів Nuget МSK2 , що охоплюють більшість основних одночасних шаблонів виконання \ ( \ в TINY \ МSK4 \ лінійних пакетах \). \ Получите дивовижні адаптивні здібності за допомогою SIMPLE синтаксису

Найти джерело тут: httpsMSC1github.comM SK3scottgalMST4mostlylucidMSL5atomsMSR6blobMsl7mainM SL8Mostly LucidМSL9ephemeralMСЛ10srcM SR11mostslylucideMLS12efemeral M SSL13complete

# Прайор

Прочитайте [попередній розділ про сигнали ](/blog/ephemeral-signals)для певного розуміння цього'застосункиM SK1 Тут представлено Readme.md з найбільш зрозумілихMSC3необновлюванихМSK4довершеного пакету, який містить як ядро найбільш зрозмілих\.незновлювні пакети, так і всі шаблони , MST7атомиM ST8 \MST9координатори і т.д.Mst10 пакетів в одному зручному DLLM st11

## Коріння

Або використати ядро [більш-менш яскравий.нефемеральний](https://github.com/scottgal/mostlylucid.atoms/tree/main/mostlylucid.ephemeral/src/mostlylucid.ephemeral) TINY (літературно МSK1 класи МSK2 що дає вам всю сирову функцію .

## Attributes & DI

Або якщо ви хочете, щоб повний атрибут базувався на асинкному маршруті з простим `[EphemeralJob]` та послуги.Додавати<x>Координатор` запис стилю використовує [пакет mostlylucid.ephemeral.attributes](https://github.com/scottgal/mostlylucid.atoms/tree/main/mostlylucid.ephemeral/src/mostlylucid.ephemeral.attributes).

Це, скоріш за все, тема мого блогу, яка рухається вперед.

# Найяскравіший.ЕфемеральнийM SK1Довершений

[![NuGet](https://img.shields.io/nuget/v/mostlylucid.ephemeral.complete.svg)](https://www.nuget.org/packages/mostlylucid.ephemeral.complete)

**Meta-пакет, який відноситься до всіх Mostlylucid.Ефемерних пакетів** - обмежена асинхічна виконання з сигналом -орієнтована координація МSK2

```bash
dotnet add package mostlylucid.ephemeral.complete
```

Це мета-пакедж, який містить всі ядраM SK1 атоми , і шаблонні пакети в якості zależności. Ви можете легко змішати це з
індивідуальні відмітки пакетів - NuGet розв 'язує проблему в одній версії без зіткнення Namespaceсів

## Що нового в 2.0

### Зрушення змін

**Модель abonamentу SignalSink змінилася:**

```csharp
// OLD (1.x) - Event-based
sink.SignalRaised += handler;

// NEW (2.0) - Lock-free Subscribe() returning IDisposable
using var sub = sink.Subscribe(handler);
```

**Полний пакет тепер - мета-пакет:**

- До того ж, всі вихідні коди були компільовані в один DLL. (ризиковані зіткнення namespacesM SK1
- Тепер відносить окремі пакети до залежності
- Безпека для змішування з окремими описами пакетів у тому ж рішення

### Нові характеристики

- **Система ledger для виявлення** (`Mostlylucid.Ephemeral.Atoms.Taxonomy.Ledger`)
  
  - `DetectionLedger` - Об 'єднує вклади детекторів з сигмоїдною агрегацією
  - `DetectionContribution` - Фабрикові методиM SK1 `Bot()`, `Human()`, `Info()`, `VerifiedBot()`, `VerifiedGoodBot()`
  - `CategoryScore.TotalWeight` нерухомість ( переименована з `Weight`)

- **Прослідження поширення сигналу** - Виявление циклу та обмеження глибини сигналів

- **Ссылка на джерело** - Відладка в вихідних умовах бібліотеки прямо з вашого IDE

Подивіться [Docs/Taxonomy.md](https://github.com/scottgal/mostlylucid.atoms/blob/refs/heads/main/mostlylucid.ephemeral/docs/Taxonomy.md) для спільного словника навколо субстрату, лінзи, атомиM SK2 молекулиМSK3
і ескалація.

---


## Стосунок

- [Швидкий старт](#quick-start)
- [Центральні координатори](#core-coordinators)
- [Konfiguracja](#configuration-ephemeraloptions)
- [Сигнал](#signals)
- [Атоми](#atoms-building-blocks)
  - [Фиксований Атом](#fixedworkatom)
  - [KeyedSequentialAtom](#keyedsequentialatom)
  - [Сигнальний Атом](#signalawareatom)
  - [Атом-заряд](#batchingatom)
  - [Знову спробувати](#retryatom)
  - [TempoLimitAtom](#ratelimitatom)
  - [Атоми зберігання даних](#data-storage-atoms)
  - [Маршрутизатор молекул & AtomTrigger](#moleculerunner--atomtrigger)
  - [SlidingCacheAtom](#slidingcacheatom)
  - [Волатильна операція Атом](#volatileoperationatom)
  - [Ефемеральний LruCache](#ephemerallrucache)
  - [Атоми таксономії](#taxonomy-atoms)
  - [ЕскалаторАтом](#escalatoratom)
  - [Керівник ехо](#echo-maker)
- [Патерни](#patterns-ready-to-use)
  - [СигналBasedCircuitBreaker](#signalbasedcircuitbreaker)
  - [Сигнал керований зворотним тиском](#signaldrivenbackpressure)
  - [Контролований вентилятор](#controlledfanout)
  - [АдаптивнаRateService](#adaptiverateservice)
  - [Демонстрація динамічної конкуренції](#dynamicconcurrencydemo)
  - [KeyedPriorityFanOut](#keyedpriorityfanout)
  - [РеактивнийFanOutPipeline](#reactivefanoutpipeline)
  - [Сигнал-аномалічний детектор](#signalanomalydetector)
  - [СигнальнийКоординованийЧитання](#signalcoordinatedreads)
  - [СигналуванняHttpClient](#signalinghttpclient)
  - [Сенглог-навігатор](#signallogwatcher)
  - [Оператор сигналів телеметрії](#telemetrysignalhandler)
  - [ДовгийWindowDemo](#longwindowdemo)
  - [Сигналреакцію](#signalreactionshowcase)
  - [ПростаSignalWindow](#persistentsignalwindow)
- [Інгекція залежності](#dependency-injection)

---


## Швидкий старт

```csharp
using Mostlylucid.Ephemeral;

// Long-lived work coordinator
await using var coordinator = new EphemeralWorkCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8 });

await coordinator.EnqueueAsync(new WorkItem("data"));

// One-shot parallel processing
await items.EphemeralForEachAsync(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8 });
```

### Регистрация послуг

```csharp
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8, MaxTrackedOperations = 128 });

builder.Services.AddEphemeralSignalJobRunner<LogWatcherJobs>();

var app = builder.Build();
app.MapPost("/", async ([FromServices] IEphemeralCoordinatorFactory<WorkItem> factory, WorkItem item) =>
{
    var coordinator = factory.CreateCoordinator();
    await coordinator.EnqueueAsync(item);
    return Results.Accepted();
});

await app.RunAsync();
```

Знайомий `services.AddCoordinator<T>()` помічників та `AddEphemeralSignalJobRunner<T>()` підтримувати registraciю послуг
стисло кажучи, дозволити Ді володіти раковиною / бігачем МSK2 і зробити нову відповідальність

### Attribute-задібні роботи

`mostlylucid.ephemeral.complete` пакети `mostlylucid.ephemeral.attributes`, так що атрибути труб є частиною ядро
поверхня. ставтеся до бігача як до першого споживача сигналу Class 1 : оздоблені методи об 'єднуються в одну і ту ж камеру
і кожен атрибут може заявити `Priority`, робота `MaxConcurrency`, `Lane`, `Key` джерело, сигнал
викиди, pinM SK1expire overrides , and retries.

Клініці атрибуту:

- **Заказуванняเลน &**: Використовувати `Priority`, `MaxConcurrency`, і `Lane` зберігати роботу в детерміністичній послідовності, поки гарячі шляхи
  залишатися окремо.
- **Навігання &**: `OperationKey`, `KeyFromSignal`, `KeyFromPayload`, і `[KeySource]` допомогти вам працювати в групі
  значні ключі для журналізації, справедливого плануванняM SK1 та діагностики.
- **Pinning & повторює**: `Pin`, `ExpireAfterMs`, `AwaitSignals`, `MaxRetries`, і `RetryDelayMs` дозволити операторам розширити
  їх видимість, введення ворот, доки не прийде залежність , і не зцілиться відхиленням, випромінюючи сигнали невдачі МSK2
- **Сигнальна хореографія**: Emit `EmitOnStart`, `EmitOnComplete`, і `EmitOnFailure` для сигналізації наступних етапів, журнал
  годинники, або інші координатори без ручного підключенняM SK1

```csharp
var sink = new SignalSink();
await using var runner = new EphemeralSignalJobRunner(sink, new[] { new LogWatcherJobs(sink) });

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
    builder.AddProvider(new SignalLoggerProvider(new TypedSignalSink<SignalLogPayload>(sink)));
});

var logger = loggerFactory.CreateLogger("orders");
logger.LogError(new EventId(1001, "DbFailure"), "Order store failed");

// Later tasks or other services can also raise watcher-friendly signals directly:
sink.Raise("log.error.orders.dbfailure", key: "orders");
```

```csharp
public sealed class LogWatcherJobs
{
    private readonly SignalSink _sink;

    public LogWatcherJobs(SignalSink sink) => _sink = sink;

    [EphemeralJob("log.error.*", Priority = 1, MaxConcurrency = 2, Lane = "hot:4", EmitOnComplete = new[] { "incident.created" })]
    public Task EscalateAsync(SignalEvent signal)
    {
        Console.WriteLine($"escalating {signal.Signal} for {signal.Key}");
        _sink.Raise("incident.created", key: signal.Key);
        return Task.CompletedTask;
    }

    [EphemeralJob("incident.created", EmitOnStart = new[] { "incident.monitor.start" })]
    public Task NotifyAsync(SignalEvent signal)
    {
        Console.WriteLine($"notified incident for {signal.Key}");
        return Task.CompletedTask;
    }
}
```

Ця атлетка сидить на старті і реагує, коли `log.error.*` або будь-який випущений сигнал потрапляє в раковину. Attribute
обладначі можуть читати ключі від сигналів/заряди payloads, pin до зворотнього потоку, доки не закінчується випромінювання сигналів
розміщування на лінії для замовлення. Для DIM SK1перві встановлення `services.AddEphemeralSignalJobRunner<T>()` ( або масштабований
варіант) так, що бігač і сховище керуються контейнеромM SK1

[НевичерпніРаботи(Звіснопосадка M SK1 МSK2 стадія", По замовчуванню
публічний склеєний клас StageJobs
{
[Невичерпна робота(" найчастіша ", EmitOnComplete = нова[МSK0 МSK1 " стадія . найкращий мSK4 завершений M" МСК6
публічна задача IngestAsync(SignalEvent evt) M SK2 Консола .OutMSC4WriteLineAsynCMska5evtM Ska6SignaleMска7

    [EphemeralJob("finalize")]
    public Task FinalizeAsync(SignalEvent evt) => Console.Out.WriteLineAsync("final stage");

}

var StageSink = новий SignalSinkM SK1
чекати, використовуючи var stageRunner = новий EphemeralSignalJobRunnerM SK1stageSink, новий[МSK0 { нові etaпні робочі місця
StageSink.Raise ("stageM SK2ingest");

Pin-важкі роботи можуть залежати від `ResponsibilitySignalManager.PinUntilQueried` (លំនាំដើម `responsibility.ack.*`) до
зберігати їхні операції видимими, доки нижній читач не дістається вантажу,, поки `OperationEchoMaker`/
`OperationEchoAtom` продовжувати кінцевий потік сигналу, так що аудитори чи молекули можуть все ще “тастиM SK1 останній стан навіть після
атом помре.

### Заплановані завдання

`mostlylucid.ephemeral.complete` також містить `mostlylucid.ephemeral.atoms.scheduledtasks`. Визначати cron або JSON
календарі через `ScheduledTaskDefinition` (кронM SK1 сигнал, опціональний `key`, `payload`, `description`, `timeZone`, `format`,
`runOnStartup`, і т.д. `ScheduledTasksAtom` продовжувати тривалий цикл роботи `DurableTaskAtom`. Кожна запланована робота
підвищує конфігурований сигнал у вікні координатора, таким чином він успадкує зачіпленняM SK1 журналування, і семантику відповідальності
тоді як ваші молекули чи атрибути трубок реагують на випущену хвилю сигналу.

Кожного `DurableTask` веде календар `Name`, `Signal`, опціонально `Key`, навіть надрукований `Payload`, і `Description`, так
слухачі зворотнього потоку негайно знають, яка робота була проведена і які метаданні (імені файлівM SK1 URLs, і т.д.
`DurableTaskAtom.WaitForIdleAsync()` коли ви просто хочете чекати, щоб теперішній вибух запланованої роботи закінчився
без закінчення атому, зберігаючи регулятор готовий до наступного cron tick.

### Записywanie сигналів &

`mostlylucid.ephemeral.logging` дзеркала Microsoft.ПоширенняM SK1Вход в сигнали і навпаки. Почнемо з прив 'язування
`SignalLoggerProvider` до вашої фабрики логера, так що події журналу піднімаються `log.*` сигнали, і Hak `SignalToLoggerAdapter` якщо
ви хочете, щоб сигнали повертались до стандартної логової трубки.

```csharp
var sink = new SignalSink();
var typedSink = new TypedSignalSink<SignalLogPayload>(sink);

using var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
    builder.AddProvider(new SignalLoggerProvider(typedSink));
});

using var watcher = new EphemeralSignalJobRunner(sink, new[] { new LogWatcherJobs(sink) });

var logger = loggerFactory.CreateLogger("orders");
logger.LogError(new EventId(1001, "DbFailure"), "Order store failed");
```

```csharp
public sealed class LogWatcherJobs
{
    private readonly SignalSink _sink;

    public LogWatcherJobs(SignalSink sink) => _sink = sink;

    [EphemeralJob("log.error.*")]
    public Task EscalateAsync(SignalEvent signal)
    {
        _sink.Raise("incident.created", key: signal.Key);
        return Task.CompletedTask;
    }

    [EphemeralJob("incident.created")]
    public Task NotifyAsync(SignalEvent signal)
    {
        Console.WriteLine($"Incident for {signal.Key}");
        return Task.CompletedTask;
    }
}
```

Використовувати `SignalToLoggerAdapter` для відображання результатів сигналів назад у стандартні журнали, щоб ваш стег спостережень бачив обидві
боки мосту.

---


## Центральні координатори

> **Пакет:** [більш-менш яскравий.нефемеральний](https://www.nuget.org/packages/mostlylucid.ephemeral)

### Ефемеральний координатор роботи&lt;Т&gt;

Довгий-жива робоча черга з обмеженим співпадінням і видимим вікном

```csharp
await using var coordinator = new EphemeralWorkCoordinator<Request>(
    async (req, ct) => await HandleAsync(req, ct),
    new EphemeralOptions
    {
        MaxConcurrency = 8,
        MaxTrackedOperations = 200,
        MaxOperationLifetime = TimeSpan.FromMinutes(5)
    });

await coordinator.EnqueueAsync(request);

// Observe state
var running = coordinator.GetRunning();
var failed = coordinator.GetFailed();
var pending = coordinator.PendingCount;

// Graceful shutdown
coordinator.Complete();
await coordinator.DrainAsync();
```

### Ефемеральний координатор роботи з ключем&lt;TKey, T&gt;

Per-key sequential processing - items with same key processed in orderM SK2

```csharp
await using var coordinator = new EphemeralKeyedWorkCoordinator<Order, string>(
    order => order.CustomerId,  // Key selector
    async (order, ct) => await ProcessOrder(order, ct),
    new EphemeralOptions
    {
        MaxConcurrency = 16,      // Total parallel
        MaxConcurrencyPerKey = 1  // Sequential per customer
    });

await coordinator.EnqueueAsync(order);
```

### Ефемеральний координатор результату&lt;Результат&gt;

Результати захоплення від асинхічних операцій.

```csharp
await using var coordinator = new EphemeralResultCoordinator<Request, Response>(
    async (req, ct) => await FetchAsync(req, ct),
    new EphemeralOptions { MaxConcurrency = 4 });

var id = await coordinator.EnqueueAsync(request);
var snapshot = await coordinator.WaitForResult(id);
if (snapshot.HasResult)
    Console.WriteLine(snapshot.Result);
```

### Рабочий координатор пріоритетів&lt;Т&gt;

Багато priorytetних смуг з конфігурованим співпадінням на each lane.

```csharp
var coordinator = new PriorityWorkCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new PriorityWorkCoordinatorOptions<WorkItem>(
        Lanes: new[] { new PriorityLane("high"), new PriorityLane("normal"), new PriorityLane("low") }
    ));

await coordinator.EnqueueAsync(item, "high");
```

---


## Konfiguracja (ЕфемерніOptionsM SK1

```csharp
new EphemeralOptions
{
    // Concurrency
    MaxConcurrency = 8,                    // Max parallel operations
    MaxConcurrencyPerKey = 1,              // For keyed coordinators
    EnableDynamicConcurrency = false,      // Allow runtime adjustment

    // Memory
    MaxTrackedOperations = 200,            // Window size (LRU eviction)
    MaxOperationLifetime = TimeSpan.FromMinutes(5),

    // Fair scheduling (keyed only)
    EnableFairScheduling = false,          // Prevent hot key starvation
    FairSchedulingThreshold = 10,

    // Signals
    Signals = sharedSink,                  // Shared signal sink
    OnSignal = evt => { },                 // Sync callback
    OnSignalAsync = async (evt, ct) => { }, // Async callback
    CancelOnSignals = new HashSet<string> { "circuit-open" },
    DeferOnSignals = new HashSet<string> { "backpressure" },
    DeferCheckInterval = TimeSpan.FromMilliseconds(100),
    MaxDeferAttempts = 50,

    // Signal handler limits
    MaxConcurrentSignalHandlers = 4,
    MaxQueuedSignals = 1000
}
```

---


## Сигнал

Операції emitують сигнали для креслення-видатливості розрізуM SK1

```csharp
// Query signals
bool hasError = coordinator.HasSignal("error");
int count = coordinator.CountSignals("error");
var errors = coordinator.GetSignalsByPattern("error.*");

// Shared sink across coordinators
var sink = new SignalSink();
var c1 = new EphemeralWorkCoordinator<A>(body, new EphemeralOptions { Signals = sink });
var c2 = new EphemeralWorkCoordinator<B>(body, new EphemeralOptions { Signals = sink });
sink.Raise("system.busy");  // Both see it
```

---


## Сигнали відповідальності & Завершення

Потрібно, щоб результати були помітні досить довго для споживачів на зворотньому шляху? `ResponsibilitySignalManager` дозволяє вам закріпити
операцій, доки сигнал ack не прийде (поганий шаблон `responsibility.ack.*` з ключем=`operationId`). Додайте
опціонально `description` щоб операція могла описати свою відповідальність, і визначити `maxPinDuration` граційно
себе-розбірливо, якщо споживач ніколи не з 'явиться

```csharp
var manager = new ResponsibilitySignalManager(coordinator, sink, maxPinDuration: TimeSpan.FromMinutes(5));
if (manager.PinUntilQueried(operationId, "file.ready", ackKey: fileId, description: "Awaiting fetch"))
{
    sink.Raise("file.ready", key: fileId);
}
// Consumer acknowledges the work
sink.Raise("file.ready.ack", key: fileId);
```

```csharp
using Mostlylucid.Ephemeral.Patterns;

var notes = new LastWordsNoteAtom(async note => await noteRepository.SaveAsync(note));
coordinator.OperationFinalized += snapshot =>
{
    var note = new LastWordsNote(
        OperationId: snapshot.OperationId,
        Key: snapshot.Key,
        Signal: snapshot.Signals?.FirstOrDefault(),
        Timestamp: DateTimeOffset.UtcNow);

    _ = notes.EnqueueAsync(note);
};
```

`LastWordsNote` залишається крихітним (ID оператора МSK1 ключ МSK2 сигнал , тайм-станп \ ), так, що ви можете записувати будь-який мінімальний стан, який вам до вподоби
перед тим, як операція збирається.

Координатор також зберігає короткий -живий ехо кінцевих сигналів (, що доступний через `EnableOperationEcho`), що ви можете
перевіряти з `GetEchoes()` коли вам потрібно відтворити зрізану хвилю сигналу, не зберігаючи повної взаємодії навколо.

```csharp
var recentErrors = coordinator.GetEchoes(pattern: "error.*")
    .Where(e => e.Timestamp > DateTimeOffset.UtcNow - TimeSpan.FromMinutes(1))
    .ToList();

if (recentErrors.Any())
    logger.LogWarning("Trimmed errors: {Count}", recentErrors.Count);
```

`OperationEchoRetention` і `OperationEchoCapacity` дозвольте балансувати, скільки ехо ви зберігаєте і скільки вони тривають
так, що ви можете відтворити “ останні слова ” досить довго для поверхневого діагностування

Менеджер автоматично відчиняє ручку, коли з 'являється гума,, але ви можете зателефонувати `CompleteResponsibility(operationId)` щоб закінчити
відповідальність на ранній стадії (eM SK1g., на відпустках ). Операції досі зростають `OperationFinalized` коли вікно вирізає їх, то
або зареєструйтесь, якщо ви хочете видалити кінцевий сигнал

---


## Атоми (Збудові блокиM SK1

### Фиксований Атом

> **Пакет:
> ** [більш-менш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2встановлений](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.fixedwork)

Фиксований робочий фонд з статистикою. Minimal API wrapper around EphemeralWorkCoordinator.

```csharp
using Mostlylucid.Ephemeral.Atoms.FixedWork;

await using var atom = new FixedWorkAtom<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    maxConcurrency: 4,
    maxTracked: 200);

await atom.EnqueueAsync(item);

// Get stats
var (pending, active, completed, failed) = atom.Stats();
Console.WriteLine($"Completed: {completed}, Failed: {failed}");

// Get recent operations
var snapshot = atom.Snapshot();

// Graceful shutdown
await atom.DrainAsync();
```

---


### KeyedSequentialAtom

> **Пакет:
> ** [найбільш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2відмінний](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.keyedsequential)

Per-последовательне оброблення ключів з опціональною справедливою програмою

```csharp
using Mostlylucid.Ephemeral.Atoms.KeyedSequential;

await using var atom = new KeyedSequentialAtom<Order, string>(
    keySelector: order => order.CustomerId,
    body: async (order, ct) => await ProcessOrder(order, ct),
    maxConcurrency: 16,
    perKeyConcurrency: 1,           // Sequential per key
    enableFairScheduling: true);    // Prevent hot key starvation

await atom.EnqueueAsync(order1);  // Customer A
await atom.EnqueueAsync(order2);  // Customer A - waits for order1
await atom.EnqueueAsync(order3);  // Customer B - parallel with A

var (pending, active, completed, failed) = atom.Stats();
await atom.DrainAsync();
```

---


### Сигнальний Атом

> **Пакет:
> ** [найбільш яскраво зрозуміле.нефемеричнеM SK1атомні.signalaware](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.signalaware)

Зупинити або anulувати прийом на основі сигналів довкілля.

```csharp
using Mostlylucid.Ephemeral.Atoms.SignalAware;

var sink = new SignalSink();

await using var atom = new SignalAwareAtom<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    cancelOn: new HashSet<string> { "shutdown", "circuit-open" },
    deferOn: new HashSet<string> { "backpressure.*" },
    deferInterval: TimeSpan.FromMilliseconds(100),
    maxDeferAttempts: 50,
    signals: sink,
    maxConcurrency: 8);

// Enqueue work
await atom.EnqueueAsync(item);

// Raise ambient signals
atom.Raise("backpressure.downstream");  // New items defer
sink.Raise("shutdown");                  // New items rejected (returns -1)

await atom.DrainAsync();
```

---


### Атом-заряд

> **Пакет:
> ** [більш-менш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2перебор](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.batching)

Збирати товари в партії за розміром або відрізком часу.

```csharp
using Mostlylucid.Ephemeral.Atoms.Batching;

await using var atom = new BatchingAtom<LogEntry>(
    onBatch: async (batch, ct) =>
    {
        Console.WriteLine($"Flushing {batch.Count} entries");
        await FlushToDatabase(batch, ct);
    },
    maxBatchSize: 100,
    flushInterval: TimeSpan.FromSeconds(5));

// Items are batched automatically
atom.Enqueue(new LogEntry("User logged in"));
atom.Enqueue(new LogEntry("Request received"));
// ... batch flushes when full OR after 5 seconds
```

---


### Знову спробувати

> **Пакет:** [найбільш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2ретри](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.retry)

Екпоненційний зворотній відворот ретри упаковувач.

```csharp
using Mostlylucid.Ephemeral.Atoms.Retry;

await using var atom = new RetryAtom<ApiRequest>(
    async (req, ct) => await CallExternalApi(req, ct),
    maxAttempts: 3,
    backoff: attempt => TimeSpan.FromMilliseconds(100 * Math.Pow(2, attempt)),
    maxConcurrency: 4);

// Automatically retries on failure with exponential backoff
// Attempt 1: immediate
// Attempt 2: 200ms delay
// Attempt 3: 400ms delay
await atom.EnqueueAsync(new ApiRequest("https://api.example.com"));

await atom.DrainAsync();
```

---


### Атоми зберігання даних

> **Пакет:** [найбільш яскраві дані](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data)

Поширена конфігурація для зберігання атомів (`DataStorageConfig`, `IDataStorageAtom<TKey, TValue>`) плюс сигнал
звичаї, що приводять файли, SQLite , та адаптери PostgreSQL.

```csharp
using Mostlylucid.Ephemeral.Atoms.Data;
using Mostlylucid.Ephemeral.Atoms.Data.File;

var sink = new SignalSink();
var config = new DataStorageConfig
{
    DatabaseName = "orders",
    SignalPrefix = "save.data",
    LoadSignalPrefix = "load.data",
    DeleteSignalPrefix = "delete.data",
    MaxConcurrency = 1
};

await using var storage = new FileDataStorageAtom<string, Order>(sink, config, "./orders");

storage.EnqueueSave("order-123", new Order { Id = "order-123", Total = 42.00m });
var loaded = await storage.LoadAsync("order-123");
```

Використовуйте те ж саме `DataStorageConfig` з [
`Mostlylucid.Ephemeral.Atoms.Data.Sqlite`](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data.sqlite) або [
`Mostlylucid.Ephemeral.Atoms.Data.Postgres`](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data.postgres)
implements for durable, signal-driven persistence powered by SQLite
`saved.data.{dbname}` сигнали, щоб розпочати роботу вниз, поки `load.data.{dbname}` спричиняє накопичення hydratу.

---


### Маршрутизатор молекул & AtomTrigger

> **Пакет:
> ** [найбільш яскраві молекули](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.molecules)

Плани, створені `MoleculeBlueprintBuilder` дозвольте визначити атоми
повідомлення), яке має запускатися, коли `order.placed` приходить. `MoleculeRunner` слухає триггер
шаблон, створює спільний `MoleculeContext`, і запускає кожен крок, поки ви подписуєтесь на запуск
`AtomTrigger` коли один атом, сигнал ', повинен запускати інший координатор або молекулу

```csharp
var sink = new SignalSink();
var blueprint = new MoleculeBlueprintBuilder("order", "order.placed")
    .AddAtom(async (ctx, ct) => await paymentCoordinator.EnqueueAsync(ctx.TriggerSignal.Key!, ct))
    .AddAtom(async (ctx, ct) =>
    {
        ctx.Raise("order.payment.complete", ctx.TriggerSignal.Key);
        await inventoryCoordinator.EnqueueAsync(ctx.TriggerSignal.Key!, ct);
    })
    .Build();

await using var runner = new MoleculeRunner(sink, new[] { blueprint }, serviceProvider);
using var trigger = new AtomTrigger(sink, "order.payment.complete", async (signal, ct) =>
{
    await notificationCoordinator.EnqueueAsync(signal.Key!, ct);
});

sink.Raise("order.placed", key: "order-42");
```

Молекульні кроки можуть викликати додаткові сигнали (`ctx.Raise("order.shipping.start")`) так, що решта системи сприймає
паличка.

---


### SlidingCacheAtom

> **Пакет:
> ** [більш-менш яскравий.нефемеральнийM SK1атомиМSK2похибка](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.slidingcache)

Кэш з знижуванням терміну закінчування -, доступ до результату, відтворює його TTLM SK1

```csharp
using Mostlylucid.Ephemeral.Atoms.SlidingCache;

await using var cache = new SlidingCacheAtom<string, UserProfile>(
    async (userId, ct) => await LoadUserProfileAsync(userId, ct),
    slidingExpiration: TimeSpan.FromMinutes(5),
    absoluteExpiration: TimeSpan.FromHours(1),
    maxSize: 1000);

// First call: computes and caches
var profile = await cache.GetOrComputeAsync("user-123");

// Second call within 5 minutes: returns cached, resets TTL
var cached = await cache.GetOrComputeAsync("user-123");

// Try get without computation (still resets TTL on hit)
if (cache.TryGet("user-123", out var profile))
    Console.WriteLine(profile.Name);

// Get stats
var stats = cache.GetStats();
Console.WriteLine($"Entries: {stats.TotalEntries}, Hot: {stats.HotEntries}");
```

### Волатильна операція Атом

> **Пакет:
> ** [переважно яскраві.нефемерніM SK1атомиМSK2вивільні](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.volatile)

Викидати операції, коли вони видають сигнал вбивства , так що вікно залишається легким навіть під дуже високою пропускною здатністю.
атом слухає налаштування шаблону (default `kill.*`) на спільному `SignalSink`Запроси , `IOperationEvictor.TryKill`
з зафіксованою операцією ID, і все ж дозволяє координатору реагувати на його ехоM SK1 підключення до входу
зникає.

```csharp
var sink = new SignalSink();
await using var coordinator = new EphemeralWorkCoordinator<JobItem>(
    async (job, ct) => await QuickProcessAsync(job, ct),
    new EphemeralOptions
    {
        Signals = sink,
        EnableOperationEcho = true,
        OperationEchoRetention = TimeSpan.FromSeconds(30)
    });

using var volatileAtom = new VolatileOperationAtom(sink, coordinator);

// inside the job: emitter.Emit("kill.job");
```

Порівняйте атом з `OperationEchoMaker`/`OperationEchoAtom` так надруковано `*.echo.*` сигнали переживають вбивство як крихітний TTL’d
запис.

### Ефемеральний LruCache

> **Пакет:** ядро (`mostlylucid.ephemeral`) — self МSK2 оптимізувати кэш з рухомим TTL на кожному ударі і розширеним ТТЛ для
> гарячі ключі.

```csharp
using Mostlylucid.Ephemeral;

var cache = new EphemeralLruCache<string, Widget>(new EphemeralLruCacheOptions
{
    DefaultTtl = TimeSpan.FromMinutes(5),
    HotKeyExtension = TimeSpan.FromMinutes(30),
    HotAccessThreshold = 3,
    MaxSize = 10_000,
    SampleRate = 5 // emit 1 in 5 signals
});

var widget = await cache.GetOrAddAsync("widget:42", async key =>
{
    var data = await LoadWidgetAsync(key);
    return data!;
});

// Stats and signals to see how the cache self-focuses on hot keys
var stats = cache.GetStats();              // hot/expired counts, size
var signals = cache.GetSignals("cache.*"); // cache.hot/evict/miss/hit
```

> Напис: `MemoryCache` може бути конфігурований для скольження вичерпування,, але він ніколи не випускає гарячихM SK1холодних сигналів або розширює TTL
> для гарячих ключів. `EphemeralLruCache` є автоoptimізуючою початковою функцією в ядром пакету ( і `SqliteSingleWriter`)
> коли ви хочете, щоб кэш зосередився на активному робочому наборі.

### Атом розміру вікна

> **Пакет:
> ** [найбільш яскраво зрозуміле.нефемеричнеM SK1атомніМSK2windowsize](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.windowsize)

Атом слухає `window.size.*` або `window.time.*` накази, закріплює запрошену пропускну спроможність
`SignalSink.UpdateWindowSize` тож ви можете розширити або зменшити розділене вікно від іншого координатора чи спостерігача сигналів.

```csharp
var sink = new SignalSink(maxCapacity: 250);
await using var atom = new WindowSizeAtom(sink);

sink.Raise("window.size.decrease:50");
sink.Raise("window.time.set:00:02:00");
```

### Атоми таксономії

> **Пакети:**
> 
> - База
>   контракти: [найбільш яскраво зрозумілий.фемемернийM SK1атоми.таксиномі](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.taxonomy) (
>   включає `MultiTaxonomyAtom`)
> - Різовики атомів: `mostlylucid.ephemeral.atoms.taxonomy.sensor`, `.extractor`, `.embedder`, `.retriever`, `.proposer`,
>   > `.constrainer`, `.ranker`, `.renderer`, `.coordinator`, `.feedback`, `.guard`

Геніальні види атомів, які підпорядковуються таксономії (сенсор МSK1 экстрактор МSK2 вміщувач , ретривер
рендерер, координаторM SK1 зворотній зв 'язок, охоронаMSC3 Кожен атом випускає надрукований сигнал при завершенні і несає AtomContract для
детермінізм та метадані про тривалість. Установити конкретний атомний пакет, який вам потрібен M SK1у прикладі, що зображено,
Використовувати `MultiTaxonomyAtom` з базового пакету, коли вам потрібно об 'єднати кілька видів в один контракт.

```csharp
using Mostlylucid.Ephemeral;
using Mostlylucid.Ephemeral.Atoms.Taxonomy;

public sealed record Proposal(string Text, double Confidence);

var sink = new SignalSink();
var proposer = new ProposerAtom<string, Proposal>(
    sink,
    async (prompt, ct) => new Proposal($"Echo: {prompt}", 0.42),
    outputSignal: "proposal.created",
    keySelector: prompt => prompt);

await proposer.EnqueueAsync("hello");
```

### ЕскалаторАтом

> **Пакет:
> ** [більш-менш яскраво зрозумілий.фемемернийM SK1атоми.ескалатор](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.escalator)

Пропонувати встромлені, efeмерні сигнали у міцні раковиниM SK1 ЕскалаторАтоми - це найкращий спосіб
короткі-живі координаториM SK1

```csharp
using Mostlylucid.Ephemeral;
using Mostlylucid.Ephemeral.Atoms.Data.File;
using Mostlylucid.Ephemeral.Atoms.Escalator;

public sealed record EscalationPayload(string Kind, string? EvidenceId, double Confidence);

var sink = new SignalSink();
var typed = new TypedSignalSink<EscalationPayload>(sink);

await using var storage = new FileDataStorageAtom<string, EscalationPayload>(
    sink,
    new FileDataStorageConfig { DatabaseName = "signals" });

Func<SignalEvent<EscalationPayload>, CancellationToken, Task> audit = (evt, ct) =>
{
    Console.WriteLine($"audit: {evt.Signal} {evt.Key}");
    return Task.CompletedTask;
};

var targets = new[]
{
    new EscalationTarget<EscalationPayload>(
        "store",
        (evt, ct) => storage.SaveAsync(evt.Key ?? evt.OperationId.ToString(), evt.Payload, ct)),
    new EscalationTarget<EscalationPayload>("audit", audit)
};

await using var escalator = new EscalatorAtom<EscalationPayload>(
    sink,
    typed,
    targets,
    new EscalatorAtomOptions<EscalationPayload>
    {
        EscalateSignalPattern = "escalate.*",
        EmitOnSuccess = "escalation.persisted",
        EmitOnFailure = "escalation.failed"
    });

typed.Raise("escalate.signal", new EscalationPayload("risk", "file-42", 0.81), key: "order-123");
```

### Керівник ехо

> **Пакет:** [більш-менш яскраво зрозумілий.фемемернийM SK1атомиМSK2ехо](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.echo)

Зафіксувати задрукований “ останні слова ”, що операція випромінює перед тим, як її зрізатиM SK2 Атом зберігає обмежене вікно сигналу
вантажі (сбіг `ActivationSignalPattern` / `CaptureSignalPattern`) і коли `OperationFinalized` спалахи, які він виробляє
`OperationEchoEntry<TPayload>` записи, які можна зберігати за допомогою `OperationEchoAtom<TPayload>`.

```csharp
var sink = new SignalSink();
var typedSink = new TypedSignalSink<EchoPayload>(sink);
var echoAtom = new OperationEchoAtom<EchoPayload>(async echo => await repository.AppendAsync(echo));

await using var coordinator = new EphemeralWorkCoordinator<JobItem>(ProcessAsync);
using var maker = coordinator.EnableOperationEchoing(
    typedSink,
    echoAtom,
    new OperationEchoMakerOptions<EchoPayload>
    {
        ActivationSignalPattern = "echo.capture",
        CaptureSignalPattern = "echo.*",
        MaxTrackedOperations = 128
    });

typedSink.Raise("echo.capture", new EchoPayload("order-1", "archived"), key: "order-1");
```

Роботи з атрибутами просто піднімають надрукований сигнал в будь-якому стані, який вони вважають критичним,, і творець зберігає робочий набір
обмежені, поки ви продовжуєте ехо.

---


## Patterns (Ready -toM SK2Use)

### СигналBasedCircuitBreaker

> **Пакет:
> ** [переважно яскраві](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.circuitbreaker)

Стаціонарний блокатор, що використовує вікно історії сигналу.

```csharp
using Mostlylucid.Ephemeral.Patterns.CircuitBreaker;

var breaker = new SignalBasedCircuitBreaker(
    failureSignal: "api.failure",
    threshold: 5,
    windowSize: TimeSpan.FromSeconds(30));

// Check before making calls
if (breaker.IsOpen(coordinator))
{
    var retryAfter = breaker.GetTimeUntilClose(coordinator);
    throw new CircuitOpenException("Too many failures", retryAfter);
}

// Pattern matching variant
if (breaker.IsOpenMatching(coordinator, "error.*"))
    throw new CircuitOpenException("Error pattern detected");

// Get current failure count
int failures = breaker.GetFailureCount(coordinator);
```

---


### Сигнал керований зворотним тиском

> **Пакет:
> ** [переважно яскраві.нефемеральніM SK1patternи.задувний тиск](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.backpressure)

Менеджмент глибини черги з автоматичним відкладанням сигналів зворотнього тиску.

```csharp
using Mostlylucid.Ephemeral.Patterns.Backpressure;

var sink = new SignalSink();

await using var coordinator = SignalDrivenBackpressure.Create<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    sink,
    maxConcurrency: 4);

// Enqueue work
await coordinator.EnqueueAsync(item);

// When downstream is slow
sink.Raise("backpressure.downstream");  // New work auto-defers

// When recovered
sink.Retract("backpressure.downstream"); // Work resumes
```

---


### Контролований вентилятор

> **Пакет:
> ** [переважно яскраві patternи](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.controlledfanout)

Глобальна + на -похибка ключів для контрольованого паралелізмуM SK2

```csharp
using Mostlylucid.Ephemeral.Patterns.ControlledFanOut;

await using var fanout = new ControlledFanOut<string, Request>(
    keySelector: req => req.TenantId,
    body: async (req, ct) => await ProcessAsync(req, ct),
    maxGlobalConcurrency: 100,  // Total parallel across all tenants
    perKeyConcurrency: 5);      // Max 5 parallel per tenant

// Items for same tenant processed with limit
await fanout.EnqueueAsync(requestA);  // Tenant1
await fanout.EnqueueAsync(requestB);  // Tenant1 - waits if 5 already running
await fanout.EnqueueAsync(requestC);  // Tenant2 - parallel with Tenant1

await fanout.DrainAsync();
```

---


### АдаптивнаRateService

> **Пакет:
> ** [переважно яскраві patternи](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.adaptiverate)

Сигнал-limitering швидкості руху з автоматичним відхиленнямM SK1

```csharp
using Mostlylucid.Ephemeral.Patterns.AdaptiveRate;

await using var service = new AdaptiveRateService<ApiRequest>(
    async (req, ct) => await CallApiAsync(req, ct),
    maxConcurrency: 8);

// Process with automatic rate limit handling
await service.ProcessAsync(request);

// When API returns 429, emit signal with retry-after
// Signal: "rate-limit:500ms"
// Service auto-parses and delays

Console.WriteLine($"Pending: {service.PendingCount}, Active: {service.ActiveCount}");
```

---


### Демонстрація динамічної конкуренції

> **Пакет:
> ** [переважно яскраві.нефемеральніM SK1patternи.динамічнаконкуренція](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.dynamicconcurrency)

Скалування співпадіння в часі запуску на основі сигналів завантаження.

```csharp
using Mostlylucid.Ephemeral.Patterns.DynamicConcurrency;

var sink = new SignalSink();

await using var demo = new DynamicConcurrencyDemo<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    sink,
    minConcurrency: 2,
    maxConcurrency: 32,
    scaleUpPattern: "load.high",
    scaleDownPattern: "load.low");

await demo.EnqueueAsync(item);

// Concurrency adjusts automatically based on signals
sink.Raise("load.high");  // Concurrency doubles (up to max)
sink.Raise("load.low");   // Concurrency halves (down to min)

Console.WriteLine($"Current concurrency: {demo.CurrentMaxConcurrency}");

await demo.DrainAsync();
```

---


### KeyedPriorityFanOut

> **Пакет:
> ** [найбільш зрозумілий.нефемеральнийM SK1patternи.похибка до відміну пріоритетів](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.keyedpriorityfanout)

Приорієнтовані смуги з пер-при zachowaні ключові замовленняM SK1

```csharp
using Mostlylucid.Ephemeral.Patterns.KeyedPriorityFanOut;

await using var fanout = new KeyedPriorityFanOut<string, UserCommand>(
    keySelector: cmd => cmd.UserId,
    body: async (cmd, ct) => await HandleCommand(cmd, ct),
    maxConcurrency: 32,
    perKeyConcurrency: 1,  // Sequential per user
    maxPriorityDepth: 100);

// Normal lane
await fanout.EnqueueAsync(normalCommand);

// Priority lane - jumps the queue for that user
bool accepted = await fanout.EnqueuePriorityAsync(urgentCommand);

// Check lane depths
var counts = fanout.PendingCounts;
Console.WriteLine($"Priority: {counts.Priority}, Normal: {counts.Normal}");

await fanout.DrainAsync();
```

---


### РеактивнийFanOutPipeline

> **Пакет:
> ** [переважно яскраві. efeмерніM SK1 шаблони.реактивний спалах](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.reactivefanout)

Двоє-ступенча трубка з автоматичним підштовхуваннямM SK1

```csharp
using Mostlylucid.Ephemeral.Patterns.ReactiveFanOut;

await using var pipeline = new ReactiveFanOutPipeline<WorkItem>(
    stage2Work: async (item, ct) => await SlowProcessing(item, ct),
    preStageWork: async (item, ct) => await FastPreprocessing(item, ct),
    stage1MaxConcurrency: 8,
    stage1MinConcurrency: 1,
    stage2MaxConcurrency: 4,
    backpressureThreshold: 32,  // Throttle when stage2 has 32+ pending
    reliefThreshold: 8);        // Resume when stage2 drops below 8

await pipeline.EnqueueAsync(item);

// Stage1 auto-throttles when stage2 backs up
Console.WriteLine($"Stage1 concurrency: {pipeline.Stage1CurrentMaxConcurrency}");
Console.WriteLine($"Stage2 pending: {pipeline.Stage2Pending}");

await pipeline.DrainAsync();
```

---


### Сигнал-аномалічний детектор

> **Пакет:
> ** [переважно яскраві.нефемеральніM SK1patternи.аномалічний детектор](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.anomalydetector)

Переміщення-викриття аномали вікнаM SK1

```csharp
using Mostlylucid.Ephemeral.Patterns.AnomalyDetector;

var sink = new SignalSink();

var detector = new SignalAnomalyDetector(
    sink,
    pattern: "error.*",
    threshold: 5,
    window: TimeSpan.FromSeconds(10));

// Check for anomalies
if (detector.IsAnomalous())
{
    Console.WriteLine("Anomaly detected! Too many errors.");
    TriggerAlert();
}

// Get current match count
int errorCount = detector.GetMatchCount();
Console.WriteLine($"Errors in window: {errorCount}");
```

---


### СигнальнийКоординованийЧитання

> **Пакет:
> ** [більш-менш яскраві.нефемеральніM SK1patterns.signalcoordinatedreads](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalcoordinatedreads)

Промовка читається під час оновлень без жорстких замків.

```csharp
using Mostlylucid.Ephemeral.Patterns.SignalCoordinatedReads;

// Run demo: readers pause when update signal is present
var result = await SignalCoordinatedReads.RunAsync(
    readCount: 10,
    updateCount: 1);

Console.WriteLine($"Reads: {result.ReadsCompleted}, Updates: {result.UpdatesCompleted}");
Console.WriteLine($"Signals: {string.Join(", ", result.Signals)}");

// Manual implementation:
var sink = new SignalSink();

await using var readers = new EphemeralWorkCoordinator<Query>(
    body,
    new EphemeralOptions
    {
        DeferOnSignals = new HashSet<string> { "update.in-progress" },
        Signals = sink
    });

// Readers auto-defer when update is running
sink.Raise("update.in-progress");  // Readers wait
sink.Raise("update.done");         // Readers resume
```

---


### СигналуванняHttpClient

> **Пакет:
> ** [більш-менш яскраво.нефемеральноM SK1patterns.signalinghttp](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalinghttp)

HTTP-клиент з сигналами прогресу.

```csharp
using Mostlylucid.Ephemeral.Patterns.SignalingHttp;

var httpClient = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://example.com/large-file");

// Create an emitter from your coordinator
// (emitter is any ISignalEmitter - operations implement this)

byte[] data = await SignalingHttpClient.DownloadWithSignalsAsync(
    httpClient,
    request,
    emitter);

// Signals emitted during download:
// - stage.starting
// - progress:0
// - stage.request
// - stage.headers
// - stage.reading
// - progress:25, progress:50, progress:75, progress:100
// - stage.completed
```

---


### Сенглог-навігатор

> **Пакет:
> ** [найбільш зрозуміле.нефемеричнеM SK1patterns.signallogwatcher](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signallogwatcher)

Дивіться на вікно сигналу для шаблонів та викидів дзвінків.

```csharp
using Mostlylucid.Ephemeral.Patterns.SignalLogWatcher;

var sink = new SignalSink();

await using var watcher = new SignalLogWatcher(
    sink,
    onMatch: evt =>
    {
        Console.WriteLine($"Error detected: {evt.Signal} at {evt.Timestamp}");
        AlertOps(evt);
    },
    pattern: "error.*",
    pollInterval: TimeSpan.FromMilliseconds(200));

// Watcher runs in background, calling onMatch for each new error signal
sink.Raise("error.database");    // -> onMatch called
sink.Raise("error.timeout");     // -> onMatch called
sink.Raise("info.started");      // -> ignored (doesn't match pattern)
```

---


### Оператор сигналів телеметрії

> **Пакет:
> ** [переважно яскраві.нефемеральніM SK1patтерини.телеметрія](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.telemetry)

OpenTelemetry/ Інтеграція з інтегією aplikacjiM SK1

```csharp
using Mostlylucid.Ephemeral.Patterns.Telemetry;

// Use in-memory for testing, or implement ITelemetryClient for real telemetry
var telemetry = new InMemoryTelemetryClient();

await using var handler = new TelemetrySignalHandler(telemetry);

// Wire up to coordinator
var options = new EphemeralOptions
{
    OnSignal = signal => handler.OnSignal(signal)
};

// Signals are processed asynchronously
// - "error.*" signals -> TrackExceptionAsync
// - "perf.*" signals -> TrackMetricAsync
// - all signals -> TrackEventAsync

Console.WriteLine($"Queued: {handler.QueuedCount}");
Console.WriteLine($"Processed: {handler.ProcessedCount}");
Console.WriteLine($"Dropped: {handler.DroppedCount}");

// Check recorded events
var events = telemetry.GetEvents();
```

---


### ДовгийWindowDemo

> **Пакет:
> ** [найбільш зрозуміле.нефемеричнеM SK1patterns.longwindowdemo](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.longwindowdemo)

Демонструє велику конфігурацію вікна для слідів аудиту.

```csharp
using Mostlylucid.Ephemeral.Patterns.LongWindowDemo;

// Configure coordinator with large tracking window
var options = new EphemeralOptions
{
    MaxTrackedOperations = 10000,
    MaxOperationLifetime = TimeSpan.FromHours(24)
};
```

---


### Сигналреакцію

> **Пакет:
> ** [переважно яскраві. efeмерні . візерунки МSK2signalreactionshowcase](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalreactionshowcase)

Демонструє шаблони передачі сигналів та зворотньі зв 'язки.

```csharp
using Mostlylucid.Ephemeral.Patterns.SignalReactionShowcase;

// See source for signal dispatch examples
// Demonstrates OnSignal, OnSignalAsync, CancelOnSignals, DeferOnSignals
```

---


### ПростаSignalWindow

> **Пакет:
> ** [переважно яскраві patternи](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.persistentwindow)

Сигнальний вікно з тривалістю SQLite - виживає від розпочинку процесу .

```csharp
using Mostlylucid.Ephemeral.Patterns.PersistentWindow;

await using var window = new PersistentSignalWindow(
    "Data Source=signals.db",
    flushInterval: TimeSpan.FromSeconds(30));

// On startup: restore previous signals
await window.LoadFromDiskAsync(maxAge: TimeSpan.FromHours(24));

// Raise signals as normal
window.Raise("order.completed", key: "order-service");
window.Raise("payment.processed", key: "payment-service");

// Query signals
var recentOrders = window.Sense("order.*");

// Signals automatically flush every 30 seconds
// Also flushes on dispose

// Get stats
var stats = window.GetStats();
Console.WriteLine($"In memory: {stats.InMemoryCount}, Flushed: {stats.LastFlushedId}");
```

---


## Інгекція залежності

```csharp
// Register in Startup/Program.cs
services.AddEphemeralWorkCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8 });

// Named coordinators
services.AddEphemeralWorkCoordinator<WorkItem>("priority",
    async (item, ct) => await ProcessPriorityAsync(item, ct));

// Inject and use
public class MyService(IEphemeralCoordinatorFactory<WorkItem> factory)
{
    public async Task DoWork()
    {
        var coordinator = factory.CreateCoordinator();
        await coordinator.EnqueueAsync(new WorkItem());
    }
}
```

Сучасні коріння DI можуть використовувати кращі помічники, такі як `services.AddCoordinator<T>(...)`,
`services.AddScopedCoordinator<T>(...)`, або `services.AddKeyedCoordinator<T, TKey>(...)` тому що вони читають як нормальні
`AddX` rejestracji; вони просто делегують ЕфемеральнійМSK1конкретним помічникам під капюшономM SK2

## Лінія + Конфигурація ключів МSK1Проста конфігурація МSK2 приховані потужності )

`mostlylucid.ephemeral.complete` пакети `PriorityWorkCoordinator` і зашифровані варіанти, так само M SK1AddCoordinator”
поверхня, яку ви використовуєте на старті, може надіслати роботу через названі лінії. Konfigurувати декілька імен лініюM SK1 дати їм опцію `MaxDepth`,
і покладатися на координатора, щоб виділити “горячі МSK1 траси перед “повільні МSK3 трасами, поки він не спостерігає за будь-якими ключами для запитів

```csharp
var sink = new SignalSink();
var lanes = new[]
{
    new PriorityLane("hot:4", CancelOnSignals: new HashSet<string> { "maintenance" }),
    new PriorityLane("normal"),
    new PriorityLane("slow:2")
};

await using var coordinator = new PriorityWorkCoordinator<WorkItem>(
    new PriorityWorkCoordinatorOptions<WorkItem>(
        async (item, ct) => await processor.ProcessAsync(item, ct),
        lanes,
        new EphemeralOptions { Signals = sink }));

await coordinator.EnqueueAsync(new WorkItem("order-42"), laneName: "hot");
await coordinator.EnqueueAsync(new WorkItem("order-43"), laneName: "slow");
```

Використовувати `PriorityKeyedWorkCoordinator` якщо вам також потрібно за замовленням на ключі-,—,рішунки маршруту все ще відбуваються в насосі ,, але
збудований- вбірник ключів зберігає кожен відрізок послідовним

```csharp
var keyed = new PriorityKeyedWorkCoordinator<WorkItem, string>(
    new PriorityKeyedWorkCoordinatorOptions<WorkItem, string>(
        order => order.CustomerId,
        async (order, ct) => await processor.ProcessPerCustomerAsync(order, ct),
        lanes,
        new EphemeralOptions { Signals = sink }));

await keyed.EnqueueAsync(new WorkItem("order-42") { CustomerId = "A" }, laneName: "hot");
await keyed.EnqueueAsync(new WorkItem("order-44") { CustomerId = "B" }, laneName: "normal");
```

Подумайте про координатора як про шеф-повара, як про ланцюги, як bowls, ,, і ключі, як ложки, які зберігають замовлення кожного клієнта.
послідовний— прихована сила, яка зберігає роботу на замовленняM SK1 зруйнована , і сигналом- свідомим без додаткової церемоніїМSK4

---


## Цілові рамки

- МSK0NET 6.0, 7.0, \8.0, |

## Ліцензія

Неlicencjum (публікова доменаM SK1