@satorio/machinery 0.2.1

package/dictionary/testing.json

@@ -0,0 +1,707 @@
+{
+  "package": "@satorio/machinery",
+  "version": "0.2.1",
+  "mechanism": {
+    "mechanism": "testing",
+    "import": "@satorio/machinery/testing",
+    "kind": "test kit",
+    "page": "mechanisms/testing",
+    "what": "Public entry to the testing mechanism: a stand-in for every port, a clock a test drives, and the scenario player.",
+    "whatUk": "Публічний вхід до механізму testing: замінник кожного порту, годинник, яким керує тест (test), і програвач сценаріїв (playScenario).",
+    "rows": [
+      {
+        "name": "AnswersByPath",
+        "kind": "value",
+        "signature": "Readonly<Record<string, unknown>>",
+        "fallback": "",
+        "caption": "What an in-memory client answers with: one already-decoded body per path.",
+        "captionUk": "Чим відповідає клієнт у пам'яті: одне вже декодоване тіло на кожен шлях.",
+        "anchor": "testing-AnswersByPath-value"
+      },
+      {
+        "name": "BlobsByKey",
+        "kind": "value",
+        "signature": "ReadonlyMap<string, StoredBlob>",
+        "fallback": "",
+        "caption": "What an in-memory blob store holds: every blob it was given, by key.",
+        "captionUk": "Що тримає сховище об'єктів у пам'яті: кожен об'єкт, який йому дали, за ключем.",
+        "anchor": "testing-BlobsByKey-value"
+      },
+      {
+        "name": "DispatchedMessageIds",
+        "kind": "value",
+        "signature": "ReadonlySet<string>",
+        "fallback": "",
+        "caption": "What an in-memory outbox holds on the read side: the ids a relay has already marked as sent.",
+        "captionUk": "Що тримає буфер трансмітера в пам'яті з боку читання: ідентифікатори, які трансмітер уже позначив надісланими.",
+        "anchor": "testing-DispatchedMessageIds-value"
+      },
+      {
+        "name": "DocumentCountsByClientAndMonth",
+        "kind": "value",
+        "signature": "ReadonlyMap<string, number>",
+        "fallback": "",
+        "caption": "What an in-memory counter holds: how many documents each client has been sent in each reporting month, keyed by the two together.",
+        "captionUk": "Що тримає лічильник у пам'яті: скільки документів дістав кожен клієнт у кожен звітний місяць, за ключем із них двох.",
+        "anchor": "testing-DocumentCountsByClientAndMonth-value"
+      },
+      {
+        "name": "InMemoryBlobStoreLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory blob store, mounted.",
+        "captionUk": "Змонтоване сховище об'єктів у пам'яті.",
+        "anchor": "testing-InMemoryBlobStoreLive-value"
+      },
+      {
+        "name": "InMemoryDocumentNumberCounterLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory counter, mounted.",
+        "captionUk": "Змонтований лічильник у пам'яті.",
+        "anchor": "testing-InMemoryDocumentNumberCounterLive-value"
+      },
+      {
+        "name": "InMemoryEventPublisherLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory publisher, mounted.",
+        "captionUk": "Змонтований публікатор у пам'яті.",
+        "anchor": "testing-InMemoryEventPublisherLive-value"
+      },
+      {
+        "name": "InMemoryIntegrationEventOutboxLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory outbox, mounted.",
+        "captionUk": "Змонтований буфер трансмітера в пам'яті.",
+        "anchor": "testing-InMemoryIntegrationEventOutboxLive-value"
+      },
+      {
+        "name": "InMemoryProcessedEventRegistryLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory registry, mounted.",
+        "captionUk": "Змонтований реєстр у пам'яті.",
+        "anchor": "testing-InMemoryProcessedEventRegistryLive-value"
+      },
+      {
+        "name": "InMemoryQueueMessageProducerLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory producer, mounted.",
+        "captionUk": "Змонтований відправник у пам'яті.",
+        "anchor": "testing-InMemoryQueueMessageProducerLive-value"
+      },
+      {
+        "name": "InMemoryQueueMessageSourceLive",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "The in-memory message source, mounted.",
+        "captionUk": "Змонтоване джерело повідомлень у пам'яті.",
+        "anchor": "testing-InMemoryQueueMessageSourceLive-value"
+      },
+      {
+        "name": "makeInMemoryBlobStore",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory blob store over a `Ref` of its own, empty at the start.",
+        "captionUk": "Сховище об'єктів у пам'яті над власним `Ref`, порожнє на початку.",
+        "anchor": "testing-makeInMemoryBlobStore-value"
+      },
+      {
+        "name": "makeInMemoryDocumentNumberCounter",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory counter over a `Ref` of its own, with every month at zero.",
+        "captionUk": "Лічильник у пам'яті над власним `Ref`, де кожен місяць стоїть на нулі.",
+        "anchor": "testing-makeInMemoryDocumentNumberCounter-value"
+      },
+      {
+        "name": "makeInMemoryEventPublisher",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory publisher over a `Ref` of its own, empty at the start.",
+        "captionUk": "Публікатор у пам'яті над власним `Ref`, порожній на початку.",
+        "anchor": "testing-makeInMemoryEventPublisher-value"
+      },
+      {
+        "name": "makeInMemoryIntegrationEventOutbox",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory outbox over `Ref`s of its own, empty at the start.",
+        "captionUk": "Буфер трансмітера в пам'яті над власними `Ref`, порожній на початку.",
+        "anchor": "testing-makeInMemoryIntegrationEventOutbox-value"
+      },
+      {
+        "name": "makeInMemoryProcessedEventRegistry",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory registry over a `Ref` of its own, empty at the start.",
+        "captionUk": "Реєстр у пам'яті над власним `Ref`, порожній на початку.",
+        "anchor": "testing-makeInMemoryProcessedEventRegistry-value"
+      },
+      {
+        "name": "makeInMemoryQueueMessageProducer",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory producer over a `Ref` of its own, whose messages nobody receives.",
+        "captionUk": "Відправник у пам'яті над власним `Ref`, чиїх повідомлень ніхто не отримує.",
+        "anchor": "testing-makeInMemoryQueueMessageProducer-value"
+      },
+      {
+        "name": "makeInMemoryQueueMessageSource",
+        "kind": "value",
+        "signature": "const",
+        "fallback": "",
+        "caption": "An in-memory message source over a `Ref` of its own, empty at the start.",
+        "captionUk": "Джерело повідомлень у пам'яті над власним `Ref`, порожнє на початку.",
+        "anchor": "testing-makeInMemoryQueueMessageSource-value"
+      },
+      {
+        "name": "nowAsDateTime",
+        "kind": "value",
+        "signature": "Effect.Effect<DateTime.Utc>",
+        "fallback": "",
+        "caption": "The moment the clock reads now, as a moment on the world's clock.",
+        "captionUk": "Мить, яку годинник читає зараз, як мить на світовому годиннику.",
+        "anchor": "testing-nowAsDateTime-value"
+      },
+      {
+        "name": "nowAsIsoString",
+        "kind": "value",
+        "signature": "Effect.Effect<string>",
+        "fallback": "",
+        "caption": "The moment the clock reads now, written the way it travels the wire.",
+        "captionUk": "Мить, яку годинник читає зараз, написана так, як вона мандрує дротом.",
+        "anchor": "testing-nowAsIsoString-value"
+      },
+      {
+        "name": "PendingQueueMessages",
+        "kind": "value",
+        "signature": "readonly RawQueueMessage[]",
+        "fallback": "",
+        "caption": "What an in-memory queue holds: the messages waiting to be received, in the order they were put there.",
+        "captionUk": "Що тримає черга в пам'яті: повідомлення, які чекають на отримання, у тому порядку, в якому їх туди поклали.",
+        "anchor": "testing-PendingQueueMessages-value"
+      },
+      {
+        "name": "ProcessedEventsById",
+        "kind": "value",
+        "signature": "ReadonlyMap<string, DateTime.Utc>",
+        "fallback": "",
+        "caption": "What an in-memory registry holds: the moment each event id was first claimed.",
+        "captionUk": "Що тримає реєстр у пам'яті: мить, коли кожен ідентифікатор події зарезервували вперше.",
+        "anchor": "testing-ProcessedEventsById-value"
+      },
+      {
+        "name": "PublishedMessages",
+        "kind": "value",
+        "signature": "readonly OutboxMessage[]",
+        "fallback": "",
+        "caption": "What an in-memory publisher holds: every message it was handed, in the order the batches arrived.",
+        "captionUk": "Що тримає публікатор у пам'яті: кожне повідомлення, яке йому подали, у порядку, в якому приходили пачки.",
+        "anchor": "testing-PublishedMessages-value"
+      },
+      {
+        "name": "QueuedOutboxMessages",
+        "kind": "value",
+        "signature": "readonly OutboxMessage[]",
+        "fallback": "",
+        "caption": "What an in-memory outbox holds on the write side: every message enqueued, in the order it arrived.",
+        "captionUk": "Що тримає буфер трансмітера в пам'яті з боку запису: кожне поставлене в чергу повідомлення, у порядку, в якому воно прийшло.",
+        "anchor": "testing-QueuedOutboxMessages-value"
+      },
+      {
+        "name": "QuietReporter",
+        "kind": "value",
+        "signature": "class",
+        "fallback": "",
+        "caption": "A test-runner reporter that prints one summary line for a whole run: how many files, how many tests, how long it took.",
+        "captionUk": "Репортер виконавця тестів (test runner), який друкує один підсумковий рядок на цілий прогін: скільки файлів, скільки тестів, скільки це тривало.",
+        "anchor": "testing-QuietReporter-value"
+      },
+      {
+        "name": "Scenario",
+        "kind": "value",
+        "signature": "interface",
+        "fallback": "",
+        "caption": "A story told as data: the steps a world walks through, and the numbers that world ends on.",
+        "captionUk": "Історія, розказана даними: кроки, якими проходить світ, і числа, на яких той світ спиняється.",
+        "anchor": "testing-Scenario-value"
+      },
+      {
+        "name": "ScenarioPlayback",
+        "kind": "value",
+        "signature": "interface",
+        "fallback": "",
+        "caption": "What one run of a scenario leaves behind: the label of every step, and the snapshot the run ended on.",
+        "captionUk": "Що лишає по собі один прогін сценарію (scenario): мітка кожного кроку і знімок, на якому прогін скінчився.",
+        "anchor": "testing-ScenarioPlayback-value"
+      },
+      {
+        "name": "ScenarioService",
+        "kind": "value",
+        "signature": "interface",
+        "fallback": "",
+        "caption": "What a service gives the scenario player: how to run a step, and how to snapshot what followed.",
+        "captionUk": "Що сервіс дає програвачеві сценаріїв: як виконати крок і як зняти знімок того, що з нього вийшло.",
+        "anchor": "testing-ScenarioService-value"
+      },
+      {
+        "name": "ScenarioStep",
+        "kind": "value",
+        "signature": "interface",
+        "fallback": "",
+        "caption": "One step in a scenario.",
+        "captionUk": "Один крок у сценарії.",
+        "anchor": "testing-ScenarioStep-value"
+      },
+      {
+        "name": "SUITES_THAT_START_A_STAND",
+        "kind": "value",
+        "signature": "readonly string[]",
+        "fallback": "",
+        "caption": "The suites that start a live stand, by the file name A11 gives them.",
+        "captionUk": "Сьюти, які піднімають живий стенд (live stand), за іменем файлу, яке дає їм `A11`.",
+        "anchor": "testing-SUITES-THAT-START-A-STAND-value"
+      },
+      {
+        "name": "TransactionalState",
+        "kind": "value",
+        "signature": "interface",
+        "fallback": "",
+        "caption": "One participant in an in-memory transaction: it can capture its own state now and hand back the effect that puts it back.",
+        "captionUk": "Один учасник транзакції в пам'яті: він уміє захопити власний стан зараз і подати назад ефект, який його повертає.",
+        "anchor": "testing-TransactionalState-value"
+      },
+      {
+        "name": "advanceBy",
+        "kind": "procedure",
+        "signature": "(duration: Duration.DurationInput) => Effect.Effect<void>",
+        "fallback": "",
+        "caption": "Moves the controlled test clock on by the span handed in, so a test reaches a later moment without waiting for it.",
+        "captionUk": "Рухає керований тестовий годинник на подану тривалість, тож тест доходить до пізнішої миті, не чекаючи на неї.",
+        "anchor": "testing-advanceBy-procedure"
+      },
+      {
+        "name": "atTheMoment",
+        "kind": "procedure",
+        "signature": "(isoTimestamp: string)",
+        "fallback": "",
+        "caption": "Runs the given work \"at\" the given moment: every clock read inside it sees `isoTimestamp`.",
+        "captionUk": "Виконує подану роботу «в» подану мить: кожне читання годинника всередині бачить `isoTimestamp`.",
+        "anchor": "testing-atTheMoment-procedure"
+      },
+      {
+        "name": "clockPinnedAt",
+        "kind": "procedure",
+        "signature": "(at: DateTime.Utc) => Clock.Clock",
+        "fallback": "",
+        "caption": "Builds a Clock pinned to one moment: every time read inside returns that moment, while `sleep` still waits on the real clock.",
+        "captionUk": "Будує `Clock`, пришпилений до однієї миті: кожне читання часу всередині повертає ту мить, а `sleep` і далі чекає за справжнім годинником.",
+        "anchor": "testing-clockPinnedAt-procedure"
+      },
+      {
+        "name": "contextOf",
+        "kind": "procedure",
+        "signature": "<Command, Snapshot, Context>(scenario: Scenario<Command, Snapshot, Context>) => Context",
+        "fallback": "",
+        "caption": "Reads the cross-cutting data of a scenario that declares some.",
+        "captionUk": "Читає наскрізні дані сценарію, який їх оголошує.",
+        "anchor": "testing-contextOf-procedure"
+      },
+      {
+        "name": "distinctMomentsIn",
+        "kind": "procedure",
+        "signature": "(table: string, column: string) => Effect.Effect<readonly string[], never, SqlClient.SqlClient>",
+        "fallback": "",
+        "caption": "Reads the distinct moments in one timestamp column, as sorted ISO strings in the same format `momentsOfSteps` returns for a scenario.",
+        "captionUk": "Читає різні миті з однієї колонки часових позначок як відсортовані рядки ISO в тому самому вигляді, який `momentsOfSteps` повертає для сценарію.",
+        "anchor": "testing-distinctMomentsIn-procedure"
+      },
+      {
+        "name": "emptiedTables",
+        "kind": "procedure",
+        "signature": "(tables: readonly string[]) => Effect.Effect<void, never, SqlClient.SqlClient>",
+        "fallback": "",
+        "caption": "Empties the given tables on the live stand so a scenario starts from zero, the way a freshly reset database does for the seeder.",
+        "captionUk": "Спорожнює подані таблиці на живому стенді, щоб сценарій починався з нуля так само, як щойно скинута база починається для сіяча (seeder).",
+        "anchor": "testing-emptiedTables-procedure"
+      },
+      {
+        "name": "ensureStepsAreInOrder",
+        "kind": "procedure",
+        "signature": "<C, S, X>(scenario: Scenario<C, S, X>) => Effect.Effect<void>",
+        "fallback": "",
+        "caption": "Fails loudly when a scenario's steps are not in strictly increasing time order — that is a broken scenario, not a run outcome.",
+        "captionUk": "Гучно валить, коли кроки сценарію стоять не в строго зростальному порядку часу: це зламаний сценарій, а не результат прогону.",
+        "anchor": "testing-ensureStepsAreInOrder-procedure"
+      },
+      {
+        "name": "firstPassLabelsOf",
+        "kind": "procedure",
+        "signature": "<C, S, X>(scenario: Scenario<C, S, X>) => readonly string[]",
+        "fallback": "",
+        "caption": "The labels a scenario expects the first time it runs, in order.",
+        "captionUk": "Мітки, яких сценарій чекає першого разу, по порядку.",
+        "anchor": "testing-firstPassLabelsOf-procedure"
+      },
+      {
+        "name": "labelOf",
+        "kind": "procedure",
+        "signature": "<R>(program: Effect.Effect<string, unknown, R>) => Effect.Effect<string, never, R>",
+        "fallback": "",
+        "caption": "Runs one step and labels it: what it returned, or the name of the failure it met.",
+        "captionUk": "Виконує один крок і ставить йому мітку: що він повернув або як зветься відмова, яку він зустрів.",
+        "anchor": "testing-labelOf-procedure"
+      },
+      {
+        "name": "labelOfFailure",
+        "kind": "procedure",
+        "signature": "(cause: Cause.Cause<unknown>) => string",
+        "fallback": "",
+        "caption": "Labels a failure, so a scenario reads the same on every run.",
+        "captionUk": "Ставить мітку відмові, тож сценарій читається однаково на кожному прогоні.",
+        "anchor": "testing-labelOfFailure-procedure"
+      },
+      {
+        "name": "makeInMemoryBlobStoreWith",
+        "kind": "procedure",
+        "signature": "(blobs: Ref.Ref<BlobsByKey>) => BlobStoreShape",
+        "fallback": "",
+        "caption": "An in-memory blob store over a `Ref` you keep, so a test can seed it before the run and read it after.",
+        "captionUk": "Сховище об'єктів у пам'яті над `Ref`, який ви тримаєте, тож тест засіває його перед прогоном і читає після.",
+        "anchor": "testing-makeInMemoryBlobStoreWith-procedure"
+      },
+      {
+        "name": "makeInMemoryDocumentNumberCounterWith",
+        "kind": "procedure",
+        "signature": "(counts: Ref.Ref<DocumentCountsByClientAndMonth>) => DocumentNumberCounterShape",
+        "fallback": "",
+        "caption": "An in-memory counter over a reference you keep, so a test can seed it and read it back.",
+        "captionUk": "Лічильник у пам'яті над посиланням, яке ви тримаєте, тож тест засіває його і читає назад.",
+        "anchor": "testing-makeInMemoryDocumentNumberCounterWith-procedure"
+      },
+      {
+        "name": "makeInMemoryEventPublisherWith",
+        "kind": "procedure",
+        "signature": "(published: Ref.Ref<PublishedMessages>) => EventPublisherShape",
+        "fallback": "",
+        "caption": "An in-memory publisher over a `Ref` you keep, so a test reads what was published after the run.",
+        "captionUk": "Публікатор у пам'яті над `Ref`, який ви тримаєте, тож тест читає опубліковане після прогону.",
+        "anchor": "testing-makeInMemoryEventPublisherWith-procedure"
+      },
+      {
+        "name": "makeInMemoryExternalHttpClient",
+        "kind": "procedure",
+        "signature": "(answers: AnswersByPath) => Effect.Effect<ExternalHttpClientShape>",
+        "fallback": "",
+        "caption": "An in-memory client over a `Ref` of its own, seeded with the answers you hand it.",
+        "captionUk": "Клієнт у пам'яті над власним `Ref`, засіяний відповідями, які ви йому подали.",
+        "anchor": "testing-makeInMemoryExternalHttpClient-procedure"
+      },
+      {
+        "name": "makeInMemoryExternalHttpClientWith",
+        "kind": "procedure",
+        "signature": "(answers: Ref.Ref<AnswersByPath>) => ExternalHttpClientShape",
+        "fallback": "",
+        "caption": "An in-memory client over a `Ref` you keep, so a test rewrites what the service answers between two calls of the same scenario.",
+        "captionUk": "Клієнт у пам'яті над `Ref`, який ви тримаєте, тож тест переписує відповідь сервісу між двома викликами одного сценарію.",
+        "anchor": "testing-makeInMemoryExternalHttpClientWith-procedure"
+      },
+      {
+        "name": "makeInMemoryIntegrationEventOutboxWith",
+        "kind": "procedure",
+        "signature": "(queued: Ref.Ref<QueuedOutboxMessages>, dispatched: Ref.Ref<DispatchedMessageIds>) => IntegrationEventOutboxShape",
+        "fallback": "",
+        "caption": "An in-memory outbox over two `Ref`s you keep, so a test can seed what is waiting and read back what the relay dispatched.",
+        "captionUk": "Буфер трансмітера в пам'яті над двома `Ref`, які ви тримаєте, тож тест засіває те, що чекає, і читає назад те, що трансмітер відправив.",
+        "anchor": "testing-makeInMemoryIntegrationEventOutboxWith-procedure"
+      },
+      {
+        "name": "makeInMemoryProcessedEventRegistryWith",
+        "kind": "procedure",
+        "signature": "(processed: Ref.Ref<ProcessedEventsById>) => ProcessedEventRegistryShape",
+        "fallback": "",
+        "caption": "An in-memory registry over a `Ref` you keep, so a test can seed what was already claimed and read back what the run added.",
+        "captionUk": "Реєстр у пам'яті над `Ref`, який ви тримаєте, тож тест засіває вже зарезервоване і читає назад додане прогоном.",
+        "anchor": "testing-makeInMemoryProcessedEventRegistryWith-procedure"
+      },
+      {
+        "name": "makeInMemoryQueueMessageProducerWith",
+        "kind": "procedure",
+        "signature": "(pending: Ref.Ref<PendingQueueMessages>) => QueueMessageProducerShape",
+        "fallback": "",
+        "caption": "An in-memory producer over the same reference an in-memory source reads.",
+        "captionUk": "Відправник у пам'яті над тим самим посиланням, яке читає джерело в пам'яті.",
+        "anchor": "testing-makeInMemoryQueueMessageProducerWith-procedure"
+      },
+      {
+        "name": "makeInMemoryQueueMessageSourceWith",
+        "kind": "procedure",
+        "signature": "(pending: Ref.Ref<PendingQueueMessages>) => QueueMessageSourceShape",
+        "fallback": "",
+        "caption": "An in-memory message source over a `Ref` you keep, so a test seeds the queue before the run and reads what is left after it.",
+        "captionUk": "Джерело повідомлень у пам'яті над `Ref`, який ви тримаєте, тож тест засіває чергу перед прогоном і читає, що лишилось після.",
+        "anchor": "testing-makeInMemoryQueueMessageSourceWith-procedure"
+      },
+      {
+        "name": "makeInMemoryTransactionBoundary",
+        "kind": "procedure",
+        "signature": "(participants: readonly TransactionalState[]) => TransactionBoundaryShape",
+        "fallback": "",
+        "caption": "Builds an in-memory transaction boundary: it captures each participant's state on entry and restores it if the work fails.",
+        "captionUk": "Будує межу транзакції в пам'яті: вона захоплює стан кожного учасника на вході і повертає його, коли робота падає.",
+        "anchor": "testing-makeInMemoryTransactionBoundary-procedure"
+      },
+      {
+        "name": "makeScriptedMessageSource",
+        "kind": "procedure",
+        "signature": "(script: readonly (readonly RawQueueMessage[])[]) => Effect.Effect<ScriptedQueue>",
+        "fallback": "",
+        "caption": "Builds the scripted source and the reader for what it acknowledged.",
+        "captionUk": "Будує джерело за сценарієм і читача того, що воно підтвердило.",
+        "anchor": "testing-makeScriptedMessageSource-procedure"
+      },
+      {
+        "name": "messageOf",
+        "kind": "procedure",
+        "signature": "(messageId: string, body: string) => RawQueueMessage",
+        "fallback": "",
+        "caption": "One raw message, built the way a queue hands it over: an id, the receipt an acknowledgement quotes, and the body.",
+        "captionUk": "Одне сире повідомлення, збудоване так, як його віддає черга: ідентифікатор, квитанція, яку цитує підтвердження, і тіло.",
+        "anchor": "testing-messageOf-procedure"
+      },
+      {
+        "name": "momentsOfSteps",
+        "kind": "procedure",
+        "signature": "<C, S, X>(scenario: Scenario<C, S, X>, chosen: (step: ScenarioStep<C>) => boolean) => readonly string[]",
+        "fallback": "",
+        "caption": "Returns the moments of the chosen steps as ISO strings, in the format a database round-trip returns them.",
+        "captionUk": "Повертає миті обраних кроків рядками ISO, у тому вигляді, в якому їх повертає похід у базу і назад.",
+        "anchor": "testing-momentsOfSteps-procedure"
+      },
+      {
+        "name": "mutationSettings",
+        "kind": "procedure",
+        "signature": "(options: MutationSettingsOptions) => MutationSettings",
+        "fallback": "",
+        "caption": "Everything a mutation run needs, with the waits bounded and the live stands kept out.",
+        "captionUk": "Усе, що потрібно мутаційному прогону, з обмеженим очікуванням і без живих стендів.",
+        "anchor": "testing-mutationSettings-procedure"
+      },
+      {
+        "name": "playScenario",
+        "kind": "procedure",
+        "signature": "<C, S, R, X>(scenario: Scenario<C, S, X>, service: ScenarioService<C, S, R, X>) => Effect.Effect<ScenarioPlayback<S>, never, R>",
+        "fallback": "",
+        "caption": "Plays a scenario: each step runs at its own moment, and the snapshot is taken at the last step's moment.",
+        "captionUk": "Програє сценарій: кожен крок біжить у власну мить, а знімок беруть у мить останнього кроку.",
+        "anchor": "testing-playScenario-procedure"
+      },
+      {
+        "name": "quietReporters",
+        "kind": "procedure",
+        "signature": "(options: QuietReporterOptions & { readonly verbose?: boolean } = {}) => ('default' | QuietReporter)[]",
+        "fallback": "",
+        "caption": "The `reporters` a test-runner configuration takes.",
+        "captionUk": "Значення `reporters`, яке бере конфігурація виконавця тестів.",
+        "anchor": "testing-quietReporters-procedure"
+      },
+      {
+        "name": "replayLabelsOf",
+        "kind": "procedure",
+        "signature": "<C, S, X>(scenario: Scenario<C, S, X>) => readonly string[]",
+        "fallback": "",
+        "caption": "The labels a scenario expects when the same steps run a second time, in order.",
+        "captionUk": "Мітки, яких сценарій чекає, коли ті самі кроки біжать удруге, по порядку.",
+        "anchor": "testing-replayLabelsOf-procedure"
+      },
+      {
+        "name": "setNowTo",
+        "kind": "procedure",
+        "signature": "(isoTimestamp: string) => Effect.Effect<void>",
+        "fallback": "",
+        "caption": "Sets the controlled test clock to the given ISO moment.",
+        "captionUk": "Ставить керований тестовий годинник на подану мить ISO.",
+        "anchor": "testing-setNowTo-procedure"
+      },
+      {
+        "name": "stateOfRef",
+        "kind": "procedure",
+        "signature": "<A>(ref: Ref.Ref<A>) => TransactionalState",
+        "fallback": "",
+        "caption": "Makes a `Ref` a participant, so an in-memory boundary can put it back where it was when the work fails.",
+        "captionUk": "Робить `Ref` учасником, тож межа в пам'яті вміє повернути його туди, де він був, коли робота падає.",
+        "anchor": "testing-stateOfRef-procedure"
+      },
+      {
+        "name": "typedFailureOf",
+        "kind": "procedure",
+        "signature": "<A, E>(effect: Effect.Effect<A, E>) => Effect.Effect<E>",
+        "fallback": "",
+        "caption": "Extracts a use case's typed failure (Fail) through `Effect.exit` and `Cause`, rather than by matching an error message string.",
+        "captionUk": "Дістає типізовану відмову (Data.TaggedError) процедури через `Effect.exit` і `Cause`, а не звіркою тексту повідомлення про помилку.",
+        "anchor": "testing-typedFailureOf-procedure"
+      },
+      {
+        "name": "verboseOutputWanted",
+        "kind": "procedure",
+        "signature": "(environment: Readonly<Record<string, string | undefined>> = process.env) => boolean",
+        "fallback": "",
+        "caption": "Whether the runner should print everything.",
+        "captionUk": "Чи має виконавець друкувати все.",
+        "anchor": "testing-verboseOutputWanted-procedure"
+      },
+      {
+        "name": "BlobStoreUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<BlobStore>",
+        "fallback": "",
+        "caption": "A blob store that answers nothing: every operation fails with `BlobStoreUnavailableError`.",
+        "captionUk": "Сховище об'єктів, яке ні на що не відповідає: кожна операція падає з `BlobStoreUnavailableError`.",
+        "anchor": "testing-BlobStoreUnavailableLive-adapter"
+      },
+      {
+        "name": "DocumentNumberCounterUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<DocumentNumberCounter>",
+        "fallback": "",
+        "caption": "A counter that counts nothing: every request comes back as a refusal.",
+        "captionUk": "Лічильник, який нічого не рахує: кожен запит повертається відмовою.",
+        "anchor": "testing-DocumentNumberCounterUnavailableLive-adapter"
+      },
+      {
+        "name": "EventPublisherUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<EventPublisher>",
+        "fallback": "",
+        "caption": "A publisher that takes nothing: every publish fails with `EventPublisherUnavailableError`.",
+        "captionUk": "Публікатор, який нічого не бере: кожна публікація падає з `EventPublisherUnavailableError`.",
+        "anchor": "testing-EventPublisherUnavailableLive-adapter"
+      },
+      {
+        "name": "ExternalHttpClientUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<ExternalHttpClient>",
+        "fallback": "",
+        "caption": "A client that reaches nothing: every call fails with `ExternalServiceUnavailableError`.",
+        "captionUk": "Клієнт, який нікуди не дістає: кожен виклик падає з `ExternalServiceUnavailableError`.",
+        "anchor": "testing-ExternalHttpClientUnavailableLive-adapter"
+      },
+      {
+        "name": "inMemoryExternalHttpClientLive",
+        "kind": "adapter",
+        "signature": "(answers: AnswersByPath) => Layer.Layer<ExternalHttpClient>",
+        "fallback": "",
+        "caption": "The in-memory client, mounted, answering the paths you seeded it with.",
+        "captionUk": "Змонтований клієнт у пам'яті, який відповідає на шляхи, якими ви його засіяли.",
+        "anchor": "testing-inMemoryExternalHttpClientLive-adapter"
+      },
+      {
+        "name": "InMemoryReadinessProbeLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<ReadinessProbe>",
+        "fallback": "",
+        "caption": "The in-memory probe, mounted.",
+        "captionUk": "Змонтована проба готовності в пам'яті.",
+        "anchor": "testing-InMemoryReadinessProbeLive-adapter"
+      },
+      {
+        "name": "inMemoryTransactionBoundaryLive",
+        "kind": "adapter",
+        "signature": "(participants: readonly TransactionalState[]) => Layer.Layer<TransactionBoundary>",
+        "fallback": "",
+        "caption": "The in-memory transaction boundary, mounted over the participants you name.",
+        "captionUk": "Змонтована межа транзакції в пам'яті, над названими вами учасниками.",
+        "anchor": "testing-inMemoryTransactionBoundaryLive-adapter"
+      },
+      {
+        "name": "IntegrationEventOutboxUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<IntegrationEventOutbox>",
+        "fallback": "",
+        "caption": "An outbox that accepts nothing: `enqueue` refuses, so a use case's write and its message go down together.",
+        "captionUk": "Буфер трансмітера, який нічого не приймає: `enqueue` відмовляє, тож запис процедури і її повідомлення падають разом.",
+        "anchor": "testing-IntegrationEventOutboxUnavailableLive-adapter"
+      },
+      {
+        "name": "IntegrationEventOutboxUnreadableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<IntegrationEventOutbox>",
+        "fallback": "",
+        "caption": "An outbox that takes messages and then refuses to hand them back: `pending` fails while `enqueue` succeeds.",
+        "captionUk": "Буфер трансмітера, який бере повідомлення і потім відмовляється їх віддати: `pending` падає, а `enqueue` вдається.",
+        "anchor": "testing-IntegrationEventOutboxUnreadableLive-adapter"
+      },
+      {
+        "name": "ProcessedEventRegistryUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<ProcessedEventRegistry>",
+        "fallback": "",
+        "caption": "A registry that claims nothing: every claim comes back as a refusal.",
+        "captionUk": "Реєстр, який нічого не резервує: кожна резервація повертається відмовою.",
+        "anchor": "testing-ProcessedEventRegistryUnavailableLive-adapter"
+      },
+      {
+        "name": "QueueMessageProducerUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<QueueMessageProducer>",
+        "fallback": "",
+        "caption": "A producer that answers nothing: every send fails with `QueueMessageProducerUnavailableError`.",
+        "captionUk": "Відправник, який ні на що не відповідає: кожне надсилання падає з `QueueMessageProducerUnavailableError`.",
+        "anchor": "testing-QueueMessageProducerUnavailableLive-adapter"
+      },
+      {
+        "name": "QueueMessageSourceUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<QueueMessageSource>",
+        "fallback": "",
+        "caption": "A message source that answers nothing: every operation fails with `QueueMessageSourceUnavailableError`.",
+        "captionUk": "Джерело повідомлень, яке ні на що не відповідає: кожна операція падає з `QueueMessageSourceUnavailableError`.",
+        "anchor": "testing-QueueMessageSourceUnavailableLive-adapter"
+      },
+      {
+        "name": "ReadinessProbeUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<ReadinessProbe>",
+        "fallback": "",
+        "caption": "A probe whose database never answers.",
+        "captionUk": "Проба, чия база ніколи не відповідає.",
+        "anchor": "testing-ReadinessProbeUnavailableLive-adapter"
+      },
+      {
+        "name": "scriptedQueueMessageSourceLive",
+        "kind": "adapter",
+        "signature": "(script: readonly (readonly RawQueueMessage[])[]) => Layer.Layer<QueueMessageSource>",
+        "fallback": "",
+        "caption": "The scripted source, mounted: each `receive` answers with the next batch of the script.",
+        "captionUk": "Змонтоване джерело за сценарієм: кожен `receive` відповідає наступною пачкою сценарію.",
+        "anchor": "testing-scriptedQueueMessageSourceLive-adapter"
+      },
+      {
+        "name": "TransactionBoundaryUnavailableLive",
+        "kind": "adapter",
+        "signature": "Layer.Layer<TransactionBoundary>",
+        "fallback": "",
+        "caption": "A transaction boundary that opens nothing: the work never runs and the caller reads the refusal.",
+        "captionUk": "Межа транзакції, яка нічого не відкриває: робота ніколи не біжить, і викликач читає відмову.",
+        "anchor": "testing-TransactionBoundaryUnavailableLive-adapter"
+      }
+    ]
+  }
+}