@sincpro/client-framework 0.6.0 → 1.1.0

package/dist/core/entrypoint/bounded-context.js

@@ -0,0 +1,426 @@
+import { contextAt, } from "../../context/entrypoint/context.js";
+import { processContext, processStore, } from "../../context/infrastructure/process.js";
+import { FeatureBus, optionsOf, } from "../domain/bus.js";
+import { Command, DomainEvent, } from "../domain/dto.js";
+import { ApplicationService, Feature, RESERVED_MEMBERS, } from "../domain/services.js";
+import { processHearing } from "../infrastructure/listeners.js";
+import { handled } from "../services/error-handlers.js";
+import { executeService, failedAt } from "../services/execution.js";
+import { announceTo, concerns, listenIn, } from "../services/listening.js";
+import { observabilityNow } from "../../observability/infrastructure/registry.js";
+import { boundedContextLogger, logHandled, } from "../../observability/services/logging.js";
+function isExecutor(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "execute" in value &&
+        typeof value.execute === "function");
+}
+function isEventClass(dto) {
+    return dto.prototype instanceof DomainEvent;
+}
+function nameOf(Service) {
+    const named = Service;
+    return String(named?.serviceName ?? named?.name ?? Service);
+}
+/**
+ * A bounded context: the bus of its Commands and domain events, as sincpro_framework's
+ * `UseFramework`.
+ *
+ *     const project = new BoundedContext<ProjectDependencies>("project");
+ *     project.addDependency("client", clientOf(transport));
+ *     project.feature(CommandCancelIssue)(CancelIssue);          // or @project.feature(...)
+ *     project.feature(IssueClosed)(NotifyWatchers);              // a subscriber of an event
+ *     project.feature(CommandCancelIssue, { replaces: CancelIssue })(CancelAndArchive);
+ *     project.addFeatureErrorHandler(toEmptyWhenMissing);
+ *     project.expectErrors(IssueLocked);                         // refused, never reported
+ *     await project.execute(new CommandCancelIssue("x"));        // ResponseCancelIssue
+ *     await project.execute(new IssueClosed("x"));               // what its subscriber returns
+ *     project.logger.info("Catalog preloaded");
+ *
+ * Context: registrations, dependencies, handlers and expected errors are snapshotted per
+ * generation; a call keeps the generation it started with, and what is added later answers from
+ * the next call — as the backend's `build_root_bus`. A domain event is executed as a Command is:
+ * one subscriber per bounded context, through the same pipeline; carrying it to every bounded
+ * context that hears it (a queue, an outbox) is the platform's.
+ */
+export class BoundedContext {
+    name;
+    /** Its level of the context: what every use case of it runs with, under the process's. */
+    context;
+    /** Its own logger, named after it: for what it does outside a use case. */
+    logger;
+    registrations = new Map();
+    dependencyValues = new Map();
+    handlers = {
+        global: [],
+        feature: [],
+        application_service: [],
+    };
+    expected = [];
+    interceptors = [];
+    listeners = {
+        started: new Set(),
+        completed: new Set(),
+        failed: new Set(),
+    };
+    revision = 0;
+    builtRevision = -1;
+    built;
+    constructor(name) {
+        this.name = name;
+        if (name.trim() === "" || name.includes("/")) {
+            throw new TypeError("A bounded context needs a nonempty name without '/'");
+        }
+        this.context = contextAt(`bounded_context:${name}`, processStore);
+        this.logger = boundedContextLogger(name);
+    }
+    get deps() {
+        // The dependency interface is erased; the locator checks real registrations.
+        return new Proxy({}, {
+            get: (_target, key) => {
+                if (typeof key !== "string" || !this.dependencyValues.has(key)) {
+                    throw new Error(`Dependency is not registered: ${String(key)}`);
+                }
+                return this.dependencyValues.get(key);
+            },
+            set: () => {
+                throw new Error("Dependencies are read-only; use addDependency");
+            },
+            deleteProperty: () => {
+                throw new Error("Dependencies cannot be deleted");
+            },
+            defineProperty: () => {
+                throw new Error("Dependencies are read-only");
+            },
+            setPrototypeOf: () => {
+                throw new Error("Dependencies are read-only");
+            },
+        });
+    }
+    addDependency(name, dependency, options) {
+        if (RESERVED_MEMBERS.has(name)) {
+            throw new Error(`Reserved dependency name: ${name}`);
+        }
+        const registered = this.dependencyValues.has(name);
+        if (registered && options === undefined) {
+            throw new Error(`Dependency already registered: ${name}`);
+        }
+        if (options && (!registered || this.dependencyValues.get(name) !== options.replaces)) {
+            throw new Error(`Dependency replacement does not match the registration: ${name}`);
+        }
+        this.dependencyValues.set(name, dependency);
+        this.revision++;
+        return this;
+    }
+    feature(dto, options) {
+        return this.registrar(dto, "feature", options);
+    }
+    appService(dto, options) {
+        return this.registrar(dto, "application_service", options);
+    }
+    /** The service registered now for a Command or an event class — what a `replaces` names. */
+    handlerOf(dto) {
+        return this.registrations.get(dto)?.Service;
+    }
+    /**
+     * The event class registered here under a wire name, or `undefined` when nothing here hears it
+     * — what a platform's queue rebuilds a stored event as, as the backend's `event_type(name)`.
+     */
+    eventTypeOf(name) {
+        for (const dto of this.registrations.keys()) {
+            if (isEventClass(dto) && dto.eventName === name)
+                return dto;
+        }
+        return undefined;
+    }
+    /**
+     * Runs `interceptor` around every execution of these classes — of every one when none is
+     * named —, outermost first in the order registered. It may look, veto (throw), adjust what it
+     * passes on (of the same class) or answer by itself. Registered after a call, it wraps from
+     * the next one.
+     */
+    interceptor(...dtos) {
+        return (interceptor) => {
+            if (typeof interceptor !== "function")
+                throw new TypeError("An interceptor is a function");
+            // Registered for these classes only, it is called only with them.
+            this.interceptors.push({ what: interceptor, dtos });
+            this.revision++;
+            return interceptor;
+        };
+    }
+    /** Stops `interceptor` wherever it was registered; from the next call. */
+    withoutInterceptor(interceptor) {
+        const kept = this.interceptors.filter((one) => one.what !== interceptor);
+        this.interceptors.splice(0, this.interceptors.length, ...kept);
+        this.revision++;
+        return this;
+    }
+    /** Hears every run of these classes (every one when none is named) begin. Answers how to stop. */
+    onStart(listener, ...dtos) {
+        return listenIn(this.listeners.started, listener, dtos);
+    }
+    /** Hears every run of these classes whose service answered — not an answer a handler gave. */
+    onCompletion(listener, ...dtos) {
+        return listenIn(this.listeners.completed, listener, dtos);
+    }
+    /** Hears every failure that escapes a call — after every handler —, once, where it failed. */
+    onFailure(listener, ...dtos) {
+        return listenIn(this.listeners.failed, listener, dtos);
+    }
+    /**
+     * Wires a component into this bounded context — its dependencies, services, interceptors,
+     * listeners, handlers — in one place: a module of an application, a plugin. `fresh()` copies
+     * all it registered.
+     */
+    extend(extension) {
+        extension(this);
+        return this;
+    }
+    /** Answers a failure that reaches `execute` (or a scope's): after every layer's handlers. */
+    addGlobalErrorHandler(handler) {
+        return this.addErrorHandler("global", handler);
+    }
+    /** Answers a Feature's failure, wherever it was executed from. */
+    addFeatureErrorHandler(handler) {
+        return this.addErrorHandler("feature", handler);
+    }
+    /** Answers an ApplicationService's failure. */
+    addAppServiceErrorHandler(handler) {
+        return this.addErrorHandler("application_service", handler);
+    }
+    /**
+     * Errors of these classes are the business answering, not a fault: the run ends `refused`,
+     * its span is no error and nothing is reported. They are still thrown — or handled.
+     */
+    expectErrors(...types) {
+        for (const type of types) {
+            if (typeof type !== "function")
+                throw new TypeError("An expected error is a class");
+            if (!this.expected.includes(type))
+                this.expected.push(type);
+        }
+        this.revision++;
+        return this;
+    }
+    execute(executable, second) {
+        // As with Python's return_type, the answer is not validated at runtime.
+        return this.generation().root(executable, {}, optionsOf(second));
+    }
+    scoped(context) {
+        const scope = { ...context };
+        return new FeatureBus((executable, options) => this.generation().root(executable, scope, options));
+    }
+    buildRootBus() {
+        this.generation();
+    }
+    fresh() {
+        const fresh = new BoundedContext(this.name);
+        for (const [dto, registration] of this.registrations) {
+            fresh.registrations.set(dto, registration);
+        }
+        for (const [name, dependency] of this.dependencyValues) {
+            fresh.dependencyValues.set(name, dependency);
+        }
+        for (const where of ["global", "feature", "application_service"]) {
+            fresh.handlers[where].push(...this.handlers[where]);
+        }
+        fresh.expected.push(...this.expected);
+        fresh.interceptors.push(...this.interceptors);
+        for (const moment of ["started", "completed", "failed"]) {
+            for (const one of this.listeners[moment])
+                fresh.listeners[moment].add(one);
+        }
+        fresh.revision = this.revision;
+        return fresh;
+    }
+    /** What escaped a call, told once, from where it first failed. */
+    escaped(executable, error, expected) {
+        const at = failedAt(error);
+        let outcome = "failed";
+        try {
+            outcome =
+                at?.outcome ?? (expected(error) ? "refused" : observabilityNow().outcomeOf(error));
+        }
+        catch {
+            // An outcome that cannot be told is a failure.
+        }
+        const heard = {
+            executable: at?.executable ?? executable,
+            execution: at?.execution,
+            layer: at?.layer,
+            error,
+            outcome,
+        };
+        announceTo(this.listeners.failed, heard);
+        announceTo(processHearing().failed, heard);
+    }
+    addErrorHandler(where, handler) {
+        if (typeof handler !== "function")
+            throw new TypeError("An error handler is a function");
+        this.handlers[where].push(handler);
+        this.revision++;
+        return this;
+    }
+    registrar(dto, layer, options = {}) {
+        return (Service, decorator) => {
+            const register = () => this.registerService(dto, Service, layer, options.replaces);
+            // Standard decorators run before static fields have initialized.
+            if (decorator)
+                decorator.addInitializer(register);
+            else
+                register();
+            return Service;
+        };
+    }
+    /**
+     * 1. The service is of the layer it is registered in, for a Command or a domain event class.
+     * 2. The class has no service yet — or, with `replaces`, the one it has is that one.
+     * 3. Its `serviceName` is given and no other service has it; an event's `eventName` is given
+     *    and no other event class here has it — the name means one event.
+     * Final: registered, said on its spans when it replaced another; the next call answers with it.
+     */
+    registerService(dto, Service, layer, replaces) {
+        const Base = layer === "feature" ? Feature : ApplicationService;
+        if (!(Service.prototype instanceof Base) ||
+            (layer === "feature" && Service.prototype instanceof ApplicationService)) {
+            throw new TypeError(`The service is not an ${layer}`);
+        }
+        const event = isEventClass(dto);
+        if (!event && !(dto.prototype instanceof Command)) {
+            throw new TypeError("A service is registered for a Command or a DomainEvent class");
+        }
+        const current = this.registrations.get(dto);
+        if (replaces !== undefined && current?.Service !== replaces) {
+            throw new Error(`Replacement does not match the registration: ${nameOf(replaces)}`);
+        }
+        if (replaces === undefined && current) {
+            throw new Error("Command already registered: one executor across both layers");
+        }
+        const name = Service.serviceName;
+        if (typeof name !== "string" || name.trim() === "") {
+            throw new Error("A service needs a nonempty registered name");
+        }
+        for (const [other, registration] of this.registrations) {
+            if (registration !== current && registration.name === name) {
+                throw new Error(`Service name already registered: ${name}`);
+            }
+            if (event &&
+                other !== dto &&
+                isEventClass(other) &&
+                other.eventName === dto.eventName) {
+                throw new Error(`Event name already registered: ${dto.eventName}`);
+            }
+        }
+        if (event && (typeof dto.eventName !== "string" || dto.eventName.trim() === "")) {
+            throw new Error("A domain event needs a nonempty eventName");
+        }
+        this.registrations.set(dto, {
+            name,
+            layer,
+            Service,
+            ...(current ? { replaces: current.name } : {}),
+        });
+        this.revision++;
+    }
+    generation() {
+        if (this.built && this.builtRevision === this.revision)
+            return this.built;
+        const revision = this.revision;
+        const built = this.buildGeneration();
+        this.built = built;
+        this.builtRevision = revision;
+        return built;
+    }
+    buildGeneration() {
+        const registrations = new Map(this.registrations);
+        const dependencies = new Map(this.dependencyValues);
+        const handlers = {
+            global: [...this.handlers.global],
+            feature: [...this.handlers.feature],
+            application_service: [...this.handlers.application_service],
+        };
+        const expectedTypes = [...this.expected];
+        const expected = (error) => expectedTypes.some((type) => error instanceof type);
+        const interceptors = [...this.interceptors];
+        const everyContext = processHearing();
+        const announce = {
+            started: (heard) => {
+                announceTo(this.listeners.started, heard);
+                announceTo(everyContext.started, heard);
+            },
+            completed: (heard) => {
+                announceTo(this.listeners.completed, heard);
+                announceTo(everyContext.completed, heard);
+            },
+        };
+        const instances = new Map();
+        for (const registration of registrations.values()) {
+            const instance = new registration.Service();
+            if (!isExecutor(instance)) {
+                throw new Error(`Registered service is unavailable: ${registration.name}`);
+            }
+            instances.set(registration, instance);
+        }
+        const dispatch = async (executable, parent, featureOnly = false, scope = {}, options = {}) => {
+            // Exact constructor identity: a subclass of a registered class is another one.
+            const target = registrations.get(Object.getPrototypeOf(executable)?.constructor);
+            if (!target)
+                throw new Error("No executor registered for this command class");
+            if (featureOnly && target.layer !== "feature") {
+                throw new Error("An ApplicationService may compose only Features");
+            }
+            const service = instances.get(target);
+            if (!service) {
+                throw new Error(`Registered service is unavailable: ${target.name}`);
+            }
+            const attributes = {
+                ...(executable instanceof DomainEvent ? { "sincpro.event": executable.name } : {}),
+                ...(target.replaces ? { "sincpro.replaces": target.replaces } : {}),
+            };
+            return executeService(service, executable, {
+                boundedContext: this.name,
+                name: target.name,
+                layer: target.layer,
+                attributes,
+                dependencies,
+                context: () => ({ ...processContext.values, ...this.context.values, ...scope }),
+                ...(parent ? { parent } : {}),
+                // Only an event comes from outside with a cause; a child continues its parent.
+                ...(options.cause && executable instanceof DomainEvent && !parent
+                    ? { cause: options.cause }
+                    : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+                featureBus: (execution) => new FeatureBus((child, options) => dispatch(child, execution, true, {}, options)),
+                expected,
+                handlers: handlers[target.layer],
+                interceptors: interceptors
+                    .filter((one) => concerns(one.dtos, executable))
+                    .map((one) => one.what),
+                announce,
+            });
+        };
+        return {
+            root: async (executable, scope, options) => {
+                try {
+                    return await dispatch(executable, undefined, false, scope, options);
+                }
+                catch (error) {
+                    let escaping = error;
+                    if (handlers.global.length > 0) {
+                        try {
+                            const answer = await handled(handlers.global, error);
+                            logHandled("bounded_context", { boundedContext: this.name });
+                            return answer;
+                        }
+                        catch (thrown) {
+                            escaping = thrown;
+                        }
+                    }
+                    this.escaped(executable, escaping, expected);
+                    throw escaping;
+                }
+            },
+        };
+    }
+}

package/dist/core/entrypoint/screens.d.ts

@@ -0,0 +1,6 @@
+import type { Transport } from "../../client/domain/transport.js";
+/**
+ * Screen requests enter the same command pipeline as application services. A generated
+ * client injected into a Feature uses its raw transport instead, continuing that execution.
+ */
+export declare function screensTransport(transport: Transport, name?: string): Transport;

package/dist/core/entrypoint/screens.js

@@ -0,0 +1,136 @@
+import { Command } from "../domain/dto.js";
+import { Feature } from "../domain/services.js";
+import { BoundedContext } from "./bounded-context.js";
+class List extends Command {
+    route;
+    criteria;
+    signal;
+    options;
+    constructor(route, criteria, signal, options) {
+        super();
+        this.route = route;
+        this.criteria = criteria;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Get extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Read extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Export extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Send extends Command {
+    method;
+    route;
+    body;
+    signal;
+    options;
+    constructor(method, route, body, signal, options) {
+        super();
+        this.method = method;
+        this.route = route;
+        this.body = body;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class EntityList extends Feature {
+    static serviceName = "EntityReads.list";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        return this.transport.list(dto.route, dto.criteria, dto.signal, dto.options);
+    }
+}
+class EntityGet extends Feature {
+    static serviceName = "EntityReads.one";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        return this.transport.one(dto.route, dto.signal, dto.options);
+    }
+}
+class EntityRead extends Feature {
+    static serviceName = "EntityReads.read";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        const transport = this.transport;
+        if (!transport.read) {
+            return Promise.reject(new Error(`this transport cannot read ${dto.route}: it has no read()`));
+        }
+        return transport.read(dto.route, dto.signal, dto.options);
+    }
+}
+class EntityExport extends Feature {
+    static serviceName = "EntityReads.download";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        const transport = this.transport;
+        if (!transport.download) {
+            return Promise.reject(new Error(`this transport cannot download ${dto.route}: it has no download()`));
+        }
+        return transport.download(dto.route, dto.signal, dto.options);
+    }
+}
+class EntitySend extends Feature {
+    static serviceName = "EntityWrites.send";
+    execute(dto) {
+        this.span.set({ "http.method": dto.method, "http.route": dto.route });
+        return this.transport.send(dto.method, dto.route, dto.body, dto.signal, dto.options);
+    }
+}
+const MADE = new WeakSet();
+/**
+ * Screen requests enter the same command pipeline as application services. A generated
+ * client injected into a Feature uses its raw transport instead, continuing that execution.
+ */
+export function screensTransport(transport, name = "screens") {
+    if (MADE.has(transport))
+        return transport;
+    const screens = new BoundedContext(name);
+    screens.addDependency("transport", transport);
+    screens.feature(List)(EntityList);
+    screens.feature(Get)(EntityGet);
+    screens.feature(Read)(EntityRead);
+    screens.feature(Export)(EntityExport);
+    screens.feature(Send)(EntitySend);
+    const through = {
+        list: (route, criteria, signal, options) => screens.execute(new List(route, criteria, signal, options)),
+        one: (route, signal, options) => screens.execute(new Get(route, signal, options)),
+        send: (method, route, body, signal, options) => screens.execute(new Send(method, route, body, signal, options)),
+    };
+    if (transport.read) {
+        through.read = (route, signal, options) => screens.execute(new Read(route, signal, options));
+    }
+    if (transport.download) {
+        through.download = (route, signal, options) => screens.execute(new Export(route, signal, options));
+    }
+    MADE.add(through);
+    return through;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The application core (`./core`): the backend's application abstractions — class Commands and
+ * Responses, Features and ApplicationServices, a bounded context that is their bus, its error
+ * handlers — and the process they run in.
+ *
+ *   domain/          DTOs, the bus, the service bases, the error-handler contract
+ *   services/        the execution pipeline, dependency binding, the handler chain
+ *   entrypoint/      `BoundedContext`, `screensTransport`
+ *   infrastructure/  `configureProcess`, `configureLogger`
+ */
+export { type CommandBus, FeatureBus } from "./domain/bus.js";
+export { Command, DataTransferObject, DomainEvent, type EventClass, Response, } from "./domain/dto.js";
+export type { ErrorClass, ErrorHandler } from "./domain/errors.js";
+export type { CallNext, Cause, ExecuteOptions, ExecutionCompleted, ExecutionFailed, ExecutionStarted, Extension, InterceptedRun, Interceptor, Listener, PipelineLayer, } from "./domain/pipeline.js";
+export { ApplicationService, Feature } from "./domain/services.js";
+export { BoundedContext, type Registrar, type RegistrationOptions, } from "./entrypoint/bounded-context.js";
+export { screensTransport } from "./entrypoint/screens.js";
+export { processListeners } from "./infrastructure/listeners.js";
+export { configureLogger, configureProcess, type LoggerConfiguration, type ProcessOptions, } from "./infrastructure/process.js";

package/dist/core/index.js

@@ -0,0 +1,17 @@
+/**
+ * The application core (`./core`): the backend's application abstractions — class Commands and
+ * Responses, Features and ApplicationServices, a bounded context that is their bus, its error
+ * handlers — and the process they run in.
+ *
+ *   domain/          DTOs, the bus, the service bases, the error-handler contract
+ *   services/        the execution pipeline, dependency binding, the handler chain
+ *   entrypoint/      `BoundedContext`, `screensTransport`
+ *   infrastructure/  `configureProcess`, `configureLogger`
+ */
+export { FeatureBus } from "./domain/bus.js";
+export { Command, DataTransferObject, DomainEvent, Response, } from "./domain/dto.js";
+export { ApplicationService, Feature } from "./domain/services.js";
+export { BoundedContext, } from "./entrypoint/bounded-context.js";
+export { screensTransport } from "./entrypoint/screens.js";
+export { processListeners } from "./infrastructure/listeners.js";
+export { configureLogger, configureProcess, } from "./infrastructure/process.js";

package/dist/core/infrastructure/listeners.d.ts

@@ -0,0 +1,28 @@
+import type { ExecutionCompleted, ExecutionFailed, ExecutionStarted, Listener } from "../domain/pipeline.js";
+import { type ExecutableClass, type Hearing } from "../services/listening.js";
+/**
+ * Who hears every bounded context of this process — the backend's process listeners: an
+ * activity indicator, a toast, an audit that must not be wired into each context.
+ *
+ *     const stop = processListeners.onFailure((failed) => toast(failed.execution?.useCase));
+ *
+ * Context: a bounded context's own listeners (`project.onStart`) hear it alone; these hear all of
+ * them, after its own. They live as long as the process — `configureProcess` does not clear
+ * them —, so whoever adds one keeps the function that stops it.
+ */
+declare const hearing: {
+    started: Set<Hearing<Listener<ExecutionStarted>>>;
+    completed: Set<Hearing<Listener<ExecutionCompleted>>>;
+    failed: Set<Hearing<Listener<ExecutionFailed>>>;
+};
+/** @internal — what the bounded contexts announce to, besides their own listeners. */
+export declare function processHearing(): typeof hearing;
+export declare const processListeners: {
+    /** Hears every run of every bounded context begin. Answers how to stop. */
+    onStart(listener: Listener<ExecutionStarted>, ...dtos: ExecutableClass[]): () => void;
+    /** Hears every service that answered, in every bounded context. */
+    onCompletion(listener: Listener<ExecutionCompleted>, ...dtos: ExecutableClass[]): () => void;
+    /** Hears every failure that escapes a call, once, where it failed. */
+    onFailure(listener: Listener<ExecutionFailed>, ...dtos: ExecutableClass[]): () => void;
+};
+export {};

package/dist/core/infrastructure/listeners.js

@@ -0,0 +1,34 @@
+import { listenIn, } from "../services/listening.js";
+/**
+ * Who hears every bounded context of this process — the backend's process listeners: an
+ * activity indicator, a toast, an audit that must not be wired into each context.
+ *
+ *     const stop = processListeners.onFailure((failed) => toast(failed.execution?.useCase));
+ *
+ * Context: a bounded context's own listeners (`project.onStart`) hear it alone; these hear all of
+ * them, after its own. They live as long as the process — `configureProcess` does not clear
+ * them —, so whoever adds one keeps the function that stops it.
+ */
+const hearing = {
+    started: new Set(),
+    completed: new Set(),
+    failed: new Set(),
+};
+/** @internal — what the bounded contexts announce to, besides their own listeners. */
+export function processHearing() {
+    return hearing;
+}
+export const processListeners = {
+    /** Hears every run of every bounded context begin. Answers how to stop. */
+    onStart(listener, ...dtos) {
+        return listenIn(hearing.started, listener, dtos);
+    },
+    /** Hears every service that answered, in every bounded context. */
+    onCompletion(listener, ...dtos) {
+        return listenIn(hearing.completed, listener, dtos);
+    },
+    /** Hears every failure that escapes a call, once, where it failed. */
+    onFailure(listener, ...dtos) {
+        return listenIn(hearing.failed, listener, dtos);
+    },
+};