@sincpro/client-framework 1.0.0 → 1.2.0

package/dist/event_driven/adapters/stored-queue.js

@@ -0,0 +1,193 @@
+import { failureOf } from "../../common/failures.js";
+import { readValues, rebuilt, valuesOf, } from "../../common/serialization.js";
+import { loggerAdapter } from "../../observability/services/logging.js";
+function rebuildEvent(type, payload) {
+    const values = readValues(payload);
+    if (typeof type.fromJSON === "function")
+        return rebuilt(values, type);
+    return Object.assign(Object.create(type.prototype), values);
+}
+function described(boundedContext, error) {
+    const failure = failureOf(error);
+    return {
+        boundedContext,
+        kind: failure.kind,
+        reason: failure.reason,
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+/**
+ * The queue that stores an event before delivering it, and delivers it until every bounded
+ * context that hears it has it — the backend's store-and-forward (`Forwarding`), over a store
+ * each platform plugs.
+ *
+ *     const queue = storedQueue({ store: sqliteEventStore(db), subscriber, ready: online });
+ *     shopBoundedContext.addDependency("publisher", new Publisher(queue));
+ *     connectivity.onBack(() => queue.drain());
+ *
+ * Context: what a phone did by hand in its event bus, the same on every platform. `publish`
+ * returns once the event is stored — nobody waits for the delivery. Then, one at a time and in
+ * the order stored:
+ *
+ * 1. An event not ready (`ready`) waits while the rest go on.
+ * 2. Nobody hears its name: delivered — a fact recorded, nobody's to act on.
+ * 3. Rebuilt as its class; one that cannot be is set aside.
+ * 4. Executed in every bounded context that hears it and does not have it yet (`reached`).
+ * 5. A failure every attempt would repeat (`PERMANENT_KINDS`: a refusal, invalid, not found) sets
+ *    that context aside; any other is tried again after the backoff — or what the failure asks
+ *    for (`retryAfter`, an open circuit's time left) —, and what comes after waits, so the
+ *    order holds; after `maxAttempts`, it is set aside too.
+ * Final: delivered when every context has it, set aside — the dead-letter queue — when one
+ *    refused it for good or ran out of attempts; `onSettled` hears either.
+ *
+ * Delivery is at least once: a process that stops after a context executed an event and before
+ * the store saved it executes it there again on the next drain. What must not act twice keys what
+ * it does by the envelope's id — `this.execution.causationId` in a use case of the event, or in an
+ * `EventSubscriber`, which hands it to the Command it executes — or by the entity the event names.
+ * And one process drains a store: two tabs over one IndexedDB claim it first (the Web Locks API).
+ */
+export function storedQueue(options) {
+    const { store, subscriber } = options;
+    const firstWait = options.wait ?? 1000;
+    const longestWait = options.longestWait ?? 60_000;
+    const maxAttempts = options.maxAttempts ?? 10;
+    if (!(maxAttempts >= 1))
+        throw new TypeError("A stored queue needs one attempt at least");
+    const rebuild = options.rebuild ?? rebuildEvent;
+    let draining;
+    let again = false;
+    let timer;
+    const settle = async (stored) => {
+        await store.save(stored);
+        try {
+            options.onSettled?.(stored);
+        }
+        catch {
+            // Telling a screen never changes a delivery.
+        }
+    };
+    const wakeAt = (at) => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            void queue.drain();
+        }, Math.max(0, at - Date.now()));
+        // A timer of its own must not keep a process alive that has nothing else to do.
+        timer.unref?.();
+    };
+    /** One pass over what waits; it stops at an event that must wait its turn. */
+    const pass = async () => {
+        const skip = new Set();
+        for (;;) {
+            const head = await store.next(skip);
+            if (head === undefined)
+                return;
+            const id = head.envelope.id;
+            if (head.retryAt !== null && Date.parse(head.retryAt) > Date.now()) {
+                wakeAt(Date.parse(head.retryAt));
+                return;
+            }
+            if (options.ready && !(await options.ready(head))) {
+                skip.add(id);
+                continue;
+            }
+            const attempts = head.attempts + 1;
+            const type = subscriber.eventTypeOf(head.envelope.name);
+            if (type === undefined) {
+                await settle({ ...head, state: "delivered", attempts, retryAt: null, failures: [] });
+                continue;
+            }
+            let event;
+            try {
+                event = rebuild(type, head.payload);
+            }
+            catch (error) {
+                await settle({
+                    ...head,
+                    state: "set_aside",
+                    attempts,
+                    retryAt: null,
+                    failures: [described("", error)],
+                });
+                continue;
+            }
+            const handled = await subscriber.handle(event, head.envelope, head.reached);
+            const reached = [...head.reached];
+            const failures = [];
+            let retryAfter = 0;
+            let repeat = false;
+            for (const one of handled) {
+                if (!("error" in one)) {
+                    reached.push(one.boundedContext);
+                    continue;
+                }
+                failures.push(described(one.boundedContext, one.error));
+                const failure = failureOf(one.error);
+                if (failure.permanent)
+                    reached.push(one.boundedContext);
+                else {
+                    repeat = true;
+                    retryAfter = Math.max(retryAfter, (failure.retryAfter ?? 0) * 1000);
+                }
+            }
+            if (repeat && attempts < maxAttempts) {
+                const backoff = Math.min(longestWait, firstWait * 2 ** (attempts - 1));
+                const at = Date.now() + Math.max(backoff, retryAfter);
+                await settle({
+                    ...head,
+                    state: "pending",
+                    attempts,
+                    retryAt: new Date(at).toISOString(),
+                    reached,
+                    failures,
+                });
+                wakeAt(at);
+                return;
+            }
+            await settle({
+                ...head,
+                state: failures.length === 0 ? "delivered" : "set_aside",
+                attempts,
+                retryAt: null,
+                reached,
+                failures,
+            });
+        }
+    };
+    const queue = {
+        async put(event, envelope) {
+            await store.add({
+                envelope,
+                payload: valuesOf(event),
+                state: "pending",
+                attempts: 0,
+                retryAt: null,
+                reached: [],
+                failures: [],
+            });
+            queue.drain().catch((error) => loggerAdapter.error("The stored queue could not deliver", {
+                reason: failureOf(error).reason,
+            }));
+        },
+        drain() {
+            if (draining !== undefined) {
+                again = true;
+                return draining;
+            }
+            draining = (async () => {
+                try {
+                    do {
+                        again = false;
+                        await pass();
+                    } while (again);
+                }
+                finally {
+                    draining = undefined;
+                }
+            })();
+            return draining;
+        },
+    };
+    return queue;
+}

package/dist/event_driven/adapters/sync-queue.d.ts

@@ -0,0 +1,11 @@
+import type { EventQueue, Subscribes } from "../domain/queue.js";
+/**
+ * The queue that delivers in the call, in memory — the backend's `SyncQueue`: `publish` returns
+ * once every bounded context that hears the event executed it. What a web application starts
+ * with, and what a test proves a flow with.
+ *
+ * Context: nothing is stored, so nothing outlives the process — a phone's queue is durable and
+ * the platform's. Every subscriber runs; then the first failure, if any, reaches the publisher,
+ * as an in-process call would.
+ */
+export declare function syncQueue(subscriber: Subscribes): EventQueue;

package/dist/event_driven/adapters/sync-queue.js

@@ -0,0 +1,19 @@
+/**
+ * The queue that delivers in the call, in memory — the backend's `SyncQueue`: `publish` returns
+ * once every bounded context that hears the event executed it. What a web application starts
+ * with, and what a test proves a flow with.
+ *
+ * Context: nothing is stored, so nothing outlives the process — a phone's queue is durable and
+ * the platform's. Every subscriber runs; then the first failure, if any, reaches the publisher,
+ * as an in-process call would.
+ */
+export function syncQueue(subscriber) {
+    return {
+        async put(event, envelope) {
+            const handled = await subscriber.handle(event, envelope);
+            const failed = handled.find((one) => "error" in one);
+            if (failed && "error" in failed)
+                throw failed.error;
+        },
+    };
+}

package/dist/event_driven/domain/envelope.d.ts

@@ -0,0 +1,28 @@
+import type { DomainEvent } from "../../core/domain/dto.js";
+import type { Cause } from "../../core/domain/pipeline.js";
+/**
+ * What travels beside a published event: who it is, which flow it belongs to and what caused it
+ * — the backend's `Envelope` and the chain of its `DomainEvent` (`correlation_id`,
+ * `causation_id`), kept beside the event rather than in it, so an event class carries only what
+ * happened.
+ *
+ *     { name: "shop.order.v1.paid", id: "0193…", correlationId: "0193…", causationId: "0192…",
+ *       publishedAt: "2026-11-10T23:31:53.000Z" }
+ *
+ * Context: a queue stores it with the event and hands it back on delivery
+ * (`context.execute(event, envelope)`): the run that executes the event continues the flow —
+ * the same `correlationId`, caused by this event's `id` —, three services and two devices later.
+ */
+export type Envelope = Cause & {
+    /** The event's wire name (`eventName`). */
+    readonly name: string;
+    /** What directly caused it: the run that published it; `null` for the head of a flow. */
+    readonly causationId: string | null;
+    /** When it was published, ISO. */
+    readonly publishedAt: string;
+};
+/**
+ * The envelope of `event`, published by the run `cause` names — or the head of its own flow when
+ * nothing caused it (its `correlationId` is its own `id`).
+ */
+export declare function envelopeOf(event: DomainEvent, cause?: Cause): Envelope;

package/dist/event_driven/domain/envelope.js

@@ -0,0 +1,19 @@
+import { newEntityId } from "../../common/ids.js";
+/**
+ * The envelope of `event`, published by the run `cause` names — or the head of its own flow when
+ * nothing caused it (its `correlationId` is its own `id`).
+ */
+export function envelopeOf(event, cause) {
+    const name = event.name;
+    if (name.trim() === "") {
+        throw new Error(`${event.constructor.name} has no eventName: an event is published by its wire name`);
+    }
+    const id = newEntityId();
+    return {
+        name,
+        id,
+        correlationId: cause?.correlationId ?? id,
+        causationId: cause?.id ?? null,
+        publishedAt: new Date().toISOString(),
+    };
+}

package/dist/event_driven/domain/queue.d.ts

@@ -0,0 +1,40 @@
+import type { DomainEvent, EventClass } from "../../core/domain/dto.js";
+import type { Envelope } from "./envelope.js";
+/**
+ * What carries a published event to whoever hears it — the port each platform implements with
+ * its own technology, as the backend's `Queue`:
+ *
+ * - `syncQueue(subscriber)` — this package's: in the call, in memory (the web's default, tests).
+ * - a phone: SQLite, so an event outlives a restart, with retries, a dead-letter queue and the
+ *   connectivity it waits for.
+ * - a browser: IndexedDB to work offline, `BroadcastChannel` to tell the other tabs.
+ * - a server's broker, through the backend.
+ *
+ * Context: delivery is the platform's — when, how often, how durably —; what it delivers and to
+ * whom is the same everywhere: an event, its envelope, and a `Subscribes` that executes it in
+ * every bounded context that hears it.
+ */
+export interface EventQueue {
+    put(event: DomainEvent, envelope: Envelope): void | Promise<void>;
+}
+/** What one bounded context answered, or failed with, for a delivered event. */
+export type Handled = {
+    readonly boundedContext: string;
+    readonly answer: unknown;
+} | {
+    readonly boundedContext: string;
+    readonly error: unknown;
+};
+/**
+ * What a queue hands an event to — the backend's `Subscribes`: which class a stored name is
+ * rebuilt as, and the event executed by every subscriber.
+ */
+export interface Subscribes {
+    /** The class an event of that wire name is rebuilt as, or `undefined` when nobody hears it. */
+    eventTypeOf(name: string): EventClass<DomainEvent> | undefined;
+    /**
+     * The event executed in every bounded context that hears it — but those `skip` names, which
+     * already have it — and what each answered.
+     */
+    handle(event: DomainEvent, envelope?: Envelope, skip?: readonly string[]): Promise<Handled[]>;
+}

package/dist/event_driven/domain/queue.js

@@ -0,0 +1 @@
+export {};

package/dist/event_driven/domain/store.d.ts

@@ -0,0 +1,56 @@
+import type { JsonValue } from "../../common/serialization.js";
+import type { Envelope } from "./envelope.js";
+import type { FailureKind } from "@sincpro/criteria";
+/**
+ * Where a stored queue keeps what it was handed until every bounded context that hears it has
+ * executed it — the port each platform implements with its own technology:
+ *
+ * - `memoryEventStore()` — this package's: the process's memory (a browser tab, a test).
+ * - a phone: a SQLite table, so an event outlives a restart; the set-aside ones are its
+ *   dead-letter queue.
+ * - a browser: IndexedDB, to work offline.
+ *
+ * Context: storing is the platform's, deciding what to do with what is stored is not — when to
+ * try again, what to set aside, which contexts already have it (`storedQueue`). So the port only
+ * keeps records, in the order they came, and finds the next one waiting.
+ */
+export interface EventStore {
+    /** Keeps a published event, waiting. */
+    add(stored: StoredEvent): void | Promise<void>;
+    /**
+     * The oldest event still waiting (`pending`), in the order added — but those `skip` names by
+     * envelope id: not ready yet (no connection, no session), they wait while the rest go on.
+     */
+    next(skip: ReadonlySet<string>): StoredEvent | undefined | Promise<StoredEvent | undefined>;
+    /** What changed of a stored event — found by its envelope's id. */
+    save(stored: StoredEvent): void | Promise<void>;
+}
+/**
+ * - `pending`: waiting to be delivered — again, after `retryAt`, when it failed in a way a retry
+ *   may fix.
+ * - `delivered`: every bounded context that hears it executed it.
+ * - `set_aside`: a context failed in a way every attempt would repeat (`PERMANENT_KINDS`) — the
+ *   dead-letter queue; it never holds back what comes after.
+ */
+export type StoredState = "pending" | "delivered" | "set_aside";
+/** Why a bounded context did not execute it. */
+export type DeliveryFailure = {
+    readonly boundedContext: string;
+    readonly kind: FailureKind;
+    readonly reason: string;
+    readonly message: string;
+};
+/** A published event as a store keeps it: its envelope, its values and how its delivery goes. */
+export type StoredEvent = {
+    readonly envelope: Envelope;
+    /** The event's values (`valuesOf`): rebuilt as its class on delivery. */
+    readonly payload: JsonValue;
+    readonly state: StoredState;
+    readonly attempts: number;
+    /** When it may be tried again, ISO; `null` when it need not wait. */
+    readonly retryAt: string | null;
+    /** The bounded contexts done with it — executed, or set aside —: a retry never runs them again. */
+    readonly reached: readonly string[];
+    /** Why the last attempt did not reach every context. */
+    readonly failures: readonly DeliveryFailure[];
+};

package/dist/event_driven/domain/store.js

@@ -0,0 +1 @@
+export {};

package/dist/event_driven/entrypoint/publisher.d.ts

@@ -0,0 +1,26 @@
+import { BIND, type Execution } from "../../context/domain/execution.js";
+import type { DomainEvent } from "../../core/domain/dto.js";
+import type { Cause } from "../../core/domain/pipeline.js";
+import { type Envelope } from "../domain/envelope.js";
+import type { EventQueue } from "../domain/queue.js";
+/**
+ * Puts events into a queue — what a Feature holds to tell whoever listens, as the backend's
+ * `Publisher`:
+ *
+ *     shopBoundedContext.addDependency("publisher", new Publisher(queue));
+ *     // in a Feature:
+ *     await this.publisher.publish(new OrderPaid(order.id));   // its Envelope
+ *
+ * Context: a dependency of a bounded context is bound to each run (`BIND`), so what a Feature
+ * publishes joins that run's flow — the same `correlationId`, caused by the run — with nothing
+ * passed by hand. Outside a run, an event is the head of its own flow.
+ */
+export declare class Publisher {
+    private readonly queue;
+    private readonly cause?;
+    constructor(queue: EventQueue, cause?: Cause | undefined);
+    /** `event` into the queue, with its envelope; answers the envelope once the queue took it. */
+    publish(event: DomainEvent): Promise<Envelope>;
+    /** The same publisher, publishing as `execution`: its events join that run's flow. */
+    [BIND](execution: Execution): Publisher;
+}

package/dist/event_driven/entrypoint/publisher.js

@@ -0,0 +1,35 @@
+import { BIND } from "../../context/domain/execution.js";
+import { envelopeOf, } from "../domain/envelope.js";
+/**
+ * Puts events into a queue — what a Feature holds to tell whoever listens, as the backend's
+ * `Publisher`:
+ *
+ *     shopBoundedContext.addDependency("publisher", new Publisher(queue));
+ *     // in a Feature:
+ *     await this.publisher.publish(new OrderPaid(order.id));   // its Envelope
+ *
+ * Context: a dependency of a bounded context is bound to each run (`BIND`), so what a Feature
+ * publishes joins that run's flow — the same `correlationId`, caused by the run — with nothing
+ * passed by hand. Outside a run, an event is the head of its own flow.
+ */
+export class Publisher {
+    queue;
+    cause;
+    constructor(queue, cause) {
+        this.queue = queue;
+        this.cause = cause;
+    }
+    /** `event` into the queue, with its envelope; answers the envelope once the queue took it. */
+    async publish(event) {
+        const envelope = envelopeOf(event, this.cause);
+        await this.queue.put(event, envelope);
+        return envelope;
+    }
+    /** The same publisher, publishing as `execution`: its events join that run's flow. */
+    [BIND](execution) {
+        return new Publisher(this.queue, {
+            id: execution.id,
+            correlationId: execution.correlationId,
+        });
+    }
+}

package/dist/event_driven/entrypoint/subscriber.d.ts

@@ -0,0 +1,42 @@
+import type { DomainEvent, EventClass } from "../../core/domain/dto.js";
+import type { Cause } from "../../core/domain/pipeline.js";
+import type { Envelope } from "../domain/envelope.js";
+import type { Handled, Subscribes } from "../domain/queue.js";
+/**
+ * What the subscriber needs of whoever hears events — a bounded context (a use case of the event)
+ * or `Subscriptions` (an `EventSubscriber` of it): its name, whether it hears an event, and
+ * running it.
+ */
+export type HearingContext = {
+    readonly name: string;
+    handlerOf(dto: abstract new (...args: never[]) => DomainEvent): unknown;
+    eventTypeOf(name: string): EventClass<DomainEvent> | undefined;
+    execute(event: DomainEvent, cause?: Cause): Promise<unknown>;
+};
+/**
+ * The door of a queue: hands an event to everyone who hears it — the backend's
+ * `Subscriber(buses)`:
+ *
+ *     const subscriber = new Subscriber(shopBoundedContext, mailBoundedContext, ticketsSubscriptions);
+ *     const queue = syncQueue(subscriber);              // or a platform's durable queue
+ *
+ * Context: who hears an event is a bounded context with a use case of it (a Feature or an
+ * ApplicationService registered for its class) or `Subscriptions` with an `EventSubscriber` of
+ * it — the entrypoint that calls use cases. Several hearing one event is several executions, one
+ * each, in the order named; one that fails does not stop the others: each answer, or failure, is
+ * said under its name — which a stored queue keeps, so a redelivery never runs again one that
+ * already heard it. Two of them never share a name.
+ */
+export declare class Subscriber implements Subscribes {
+    private readonly contexts;
+    constructor(...contexts: HearingContext[]);
+    eventTypeOf(name: string): EventClass<DomainEvent> | undefined;
+    /**
+     * 1. Every bounded context registered for the event's class, in the order named — but those
+     *    `skip` names, which already have it.
+     * 2. Each executes it — continuing the envelope's flow when there is one —, and its answer or
+     *    failure is kept; a failure does not stop the next.
+     * Final: what each answered, or failed with.
+     */
+    handle(event: DomainEvent, envelope?: Envelope, skip?: readonly string[]): Promise<Handled[]>;
+}

package/dist/event_driven/entrypoint/subscriber.js

@@ -0,0 +1,62 @@
+/**
+ * The door of a queue: hands an event to everyone who hears it — the backend's
+ * `Subscriber(buses)`:
+ *
+ *     const subscriber = new Subscriber(shopBoundedContext, mailBoundedContext, ticketsSubscriptions);
+ *     const queue = syncQueue(subscriber);              // or a platform's durable queue
+ *
+ * Context: who hears an event is a bounded context with a use case of it (a Feature or an
+ * ApplicationService registered for its class) or `Subscriptions` with an `EventSubscriber` of
+ * it — the entrypoint that calls use cases. Several hearing one event is several executions, one
+ * each, in the order named; one that fails does not stop the others: each answer, or failure, is
+ * said under its name — which a stored queue keeps, so a redelivery never runs again one that
+ * already heard it. Two of them never share a name.
+ */
+export class Subscriber {
+    contexts;
+    constructor(...contexts) {
+        const names = new Set();
+        for (const context of contexts) {
+            if (names.has(context.name)) {
+                throw new Error(`Two of those who hear events are named ${context.name}: the queue keeps who heard an event by its name`);
+            }
+            names.add(context.name);
+        }
+        this.contexts = contexts;
+    }
+    eventTypeOf(name) {
+        for (const context of this.contexts) {
+            const found = context.eventTypeOf(name);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    /**
+     * 1. Every bounded context registered for the event's class, in the order named — but those
+     *    `skip` names, which already have it.
+     * 2. Each executes it — continuing the envelope's flow when there is one —, and its answer or
+     *    failure is kept; a failure does not stop the next.
+     * Final: what each answered, or failed with.
+     */
+    async handle(event, envelope, skip = []) {
+        const type = Object.getPrototypeOf(event)?.constructor;
+        const handled = [];
+        for (const context of this.contexts) {
+            if (type === undefined || context.handlerOf(type) === undefined)
+                continue;
+            if (skip.includes(context.name))
+                continue;
+            try {
+                handled.push({
+                    boundedContext: context.name,
+                    answer: await context.execute(event, envelope),
+                });
+            }
+            catch (error) {
+                handled.push({ boundedContext: context.name, error });
+            }
+        }
+        return handled;
+    }
+}

package/dist/event_driven/entrypoint/subscriptions.d.ts

@@ -0,0 +1,110 @@
+import type { Execution } from "../../context/domain/execution.js";
+import type { ContextValues } from "../../context/domain/store.js";
+import { DomainEvent, type EventClass } from "../../core/domain/dto.js";
+import type { Cause, ExecuteOptions } from "../../core/domain/pipeline.js";
+import type { LayerLogger } from "../../observability/domain/logging.js";
+import type { Span } from "../../observability/domain/tracing.js";
+/**
+ * An entrypoint that hears one domain event and calls the use cases it starts — as a cron calls
+ * them on a tick, or a screen on a gesture:
+ *
+ *     class LoggedSuccessfully extends EventSubscriber<OdooLoggedIn> {
+ *       static readonly subscriberName = "LoggedSuccessfully";
+ *       declare readonly ticketsBoundedContext: BoundedContext<TicketsDependencies>;
+ *
+ *       async handle(event: OdooLoggedIn) {
+ *         await this.ticketsBoundedContext.execute(new CommandPrepareSession(event.uid));
+ *       }
+ *     }
+ *
+ * Context: a subscriber is not a use case. It reads the event, builds the Command — or the
+ * Commands — and executes them on a bounded context it was given; what to decide, and work of
+ * several steps, is a Feature or an ApplicationService it executes. While `handle` runs,
+ * `this.span`, `this.logger`, `this.signal`, `this.execution` and every dependency are that
+ * delivery's: a bounded context it was given executes as a child of it — the same flow, caused by
+ * it (`BIND`). `subscriberName` is stable metadata, never `constructor.name`. Like a service, a
+ * subscriber is one instance for every delivery: what belongs to one goes in its locals.
+ */
+export declare abstract class EventSubscriber<E extends DomainEvent, Context extends object = ContextValues> {
+    /** What this delivery runs with: the process's context. */
+    readonly context: Readonly<Partial<Context>>;
+    /** This delivery's span: the Commands it executes are its children. */
+    readonly span: Span;
+    /** This delivery's logger: every line carries its flow and trace. */
+    readonly logger: LayerLogger;
+    /** What cancels this delivery, when it was executed with one. */
+    readonly signal: AbortSignal | undefined;
+    /**
+     * This delivery: its id, flow (`correlationId`) and cause — the envelope's id, the key that
+     * makes hearing an event twice harmless.
+     */
+    readonly execution: Execution;
+    abstract handle(event: E): unknown;
+}
+type SubscriberClass<E extends DomainEvent> = {
+    new (): EventSubscriber<E>;
+    readonly subscriberName: string;
+};
+/** What a subscription takes the place of: the subscriber registered now for the event. */
+export type SubscriptionOptions = {
+    replaces?: abstract new (...args: never[]) => object;
+};
+/** What `subscribe(...)` answers: the function that registers the subscriber. */
+export type Subscribing<E extends DomainEvent> = <S extends SubscriberClass<NoInfer<E>>>(Subscriber: S, decorator?: ClassDecoratorContext<S>) => S;
+/**
+ * The subscribers of one part of an application — which `EventSubscriber` hears which event —,
+ * with the dependencies they call: what a queue's `Subscriber` hands an event to, beside the
+ * bounded contexts:
+ *
+ *     export const ticketsSubscriptions = new Subscriptions<TicketsEntrypoints>("tickets-subscriptions");
+ *     ticketsSubscriptions.addDependency("ticketsBoundedContext", ticketsBoundedContext);
+ *     ticketsSubscriptions.subscribe(OdooLoggedIn)(LoggedSuccessfully);
+ *
+ *     storedQueue({ store, subscriber: new Subscriber(odooBoundedContext, ticketsSubscriptions) });
+ *
+ * Context: the shape of a bounded context, and of the backend's `Crons`: a name that is its
+ * identity in spans, logs and the queue's record of who already heard an event — so it differs
+ * from every bounded context's —, dependencies by name, and a function (or a decorator) that
+ * registers. One subscriber per event here: several reactions to one event are one
+ * ApplicationService it executes, or subscribers of other registries. Each delivery is a run of
+ * its own (`<name>/<subscriberName>`, layer `entrypoint`), continuing the envelope's flow; it is
+ * not a use case, so interceptors and listeners do not see it — they see the use cases it calls.
+ */
+export declare class Subscriptions<D extends object = Record<never, never>> {
+    readonly name: string;
+    private readonly registrations;
+    private readonly dependencyValues;
+    constructor(name: string);
+    /** A dependency its subscribers find on `this`, bound to each delivery; `replaces` as a bounded context's. */
+    addDependency<K extends keyof D & string>(name: K, dependency: D[K], options?: {
+        replaces: D[K];
+    }): this;
+    /**
+     * Registers the subscriber that hears `event` here. With `replaces`, it takes the place of the
+     * one registered now.
+     */
+    subscribe<E extends DomainEvent>(event: EventClass<E>, options?: SubscriptionOptions): Subscribing<E>;
+    /** The subscriber registered now for an event class — what a `replaces` names. */
+    handlerOf(event: abstract new (...args: never[]) => DomainEvent): (abstract new (...args: never[]) => object) | undefined;
+    /** The event class registered here under a wire name, or `undefined` when nobody here hears it. */
+    eventTypeOf(name: string): EventClass<DomainEvent> | undefined;
+    /**
+     * `event` heard by its subscriber here — continuing the envelope's flow when it is given
+     * (`execute(event, envelope)`) — and what `handle` returned.
+     *
+     * 1. The subscriber registered for the event's exact class; none: an error.
+     * 2. A run `<name>/<subscriberName>`, layer `entrypoint`: its span, log lines and — when it
+     *    fails with a fault nothing reported yet — its report; its dependencies bound to it.
+     * Final: what `handle` returned; its failure, as it is, to the queue that delivered it.
+     */
+    execute(event: DomainEvent, options?: ExecuteOptions | Cause): Promise<unknown>;
+    /**
+     * 1. The subscriber is an `EventSubscriber`, for a domain event class with its `eventName`.
+     * 2. The event has no subscriber here yet — or, with `replaces`, the one it has is that one.
+     * 3. Its `subscriberName` is given and no other subscriber here has it; no other event class
+     *    here has the event's name.
+     * Final: registered, said on its spans when it replaced another; the next delivery hears it.
+     */
+    private register;
+}
+export {};