@sincpro/client-framework 1.1.0 → 1.2.0

package/dist/core/domain/errors.d.ts

@@ -1,12 +1,12 @@
 /**
  * What answers a use case's failure instead of raising it — sincpro_framework's error handlers.
  *
- *     project.addFeatureErrorHandler((error) => {
+ *     projectBoundedContext.addFeatureErrorHandler((error) => {
  *       if (error instanceof IssueNotFound) return new ResponseEmpty();   // the answer
  *       throw error;                                                     // the next handler
  *     });
  *
- * Context: three chains per bounded context — global (around `project.execute`), feature and
+ * Context: three chains per bounded context — global (around `projectBoundedContext.execute`), feature and
  * application service —, each run first-registered-first. A handler that throws hands what it
  * threw to the next; the last one's throw reaches the caller. The failure was already recorded
  * where it happened (its span, its log line and, when unexpected, its report): a handler decides

package/dist/core/domain/pipeline.d.ts

@@ -8,11 +8,11 @@ import type { Outcome } from "../../observability/domain/tracing.js";
  *     control       interceptors   wrap the service: look, veto, adjust or answer
  *     observation   listeners      a run started, answered, or a failure escaped: heard, never changed
  *
- *     project.interceptor(CommandPay)(async (command, next, run) => {
+ *     projectBoundedContext.interceptor(CommandPay)(async (command, next, run) => {
  *       if (!credit.allows(command.customer_id)) throw new NoCredit();   // veto
  *       return next(command);                                             // the next, or the service
  *     });
- *     project.onCompletion((done) => activity.succeeded(done.execution.useCase));
+ *     projectBoundedContext.onCompletion((done) => activity.succeeded(done.execution.useCase));
  *
  * Context: the core owns the flow — context, span, log lines, outcome, report, handlers — and
  * these are the places an application changes it from outside, without touching a service. An
@@ -32,7 +32,7 @@ export type Cause = {
  * How a Command or an event is executed: what cancels it, and — for a delivered event — what
  * caused it.
  *
- *     await sales.execute(new CommandQuote(3), { signal: screen.signal });
+ *     await salesBoundedContext.execute(new CommandQuote(3), { signal: screen.signal });
  *
  * Context: a screen that closes, a navigation that leaves, a user who gives up stop waiting; the
  * run ends `aborted` (not reported), its Features inherit the signal, and the requests its

package/dist/core/domain/services.d.ts

@@ -9,7 +9,7 @@ import type { Span } from "../../observability/domain/tracing.js";
  * registered Command — or domain event, as its subscriber —; an ApplicationService composes its
  * context's Features.
  *
- *     @project.feature(CommandCancelIssue)
+ *     @projectBoundedContext.feature(CommandCancelIssue)
  *     class CancelIssue extends Feature<CommandCancelIssue, ResponseCancelIssue> {
  *       static readonly serviceName = "CancelIssue";
  *       async execute(command: CommandCancelIssue) {
@@ -32,9 +32,10 @@ export declare abstract class Feature<C extends Command<R> | DomainEvent, R, Con
     /** What cancels this run, when it was executed with one: check it in a long loop. */
     readonly signal: AbortSignal | undefined;
     /**
-     * This run: its id, use case, flow (`correlationId`) and cause. A subscriber of a delivered
-     * event finds the envelope's id as `causationId` — the key that makes executing it twice
-     * harmless.
+     * This run: its id, use case, flow (`correlationId`) and cause. A use case of a delivered event
+     * finds the envelope's id as `causationId` — the key that makes executing it twice harmless; a
+     * use case an `EventSubscriber` executes finds the subscriber's run, so the subscriber hands the
+     * envelope's id in the Command when the effect must not repeat.
      */
     readonly execution: Execution;
     abstract execute(command: C): R | Promise<R>;

package/dist/core/domain/services.js

@@ -3,7 +3,7 @@
  * registered Command — or domain event, as its subscriber —; an ApplicationService composes its
  * context's Features.
  *
- *     @project.feature(CommandCancelIssue)
+ *     @projectBoundedContext.feature(CommandCancelIssue)
  *     class CancelIssue extends Feature<CommandCancelIssue, ResponseCancelIssue> {
  *       static readonly serviceName = "CancelIssue";
  *       async execute(command: CommandCancelIssue) {

package/dist/core/entrypoint/bounded-context.d.ts

@@ -1,3 +1,4 @@
+import { BIND, type Execution } from "../../context/domain/execution.js";
 import type { ContextValues } from "../../context/domain/store.js";
 import { type Context } from "../../context/entrypoint/context.js";
 import { type CommandBus } from "../domain/bus.js";
@@ -25,22 +26,24 @@ export type Registrar<T extends Executable> = <S extends ServiceClass<NoInfer<T>
  * 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");
+ *     const projectBoundedContext = new BoundedContext<ProjectDependencies>("project");
+ *     projectBoundedContext.addDependency("client", clientOf(operations));
+ *     projectBoundedContext.feature(CommandCancelIssue)(CancelIssue);   // or a decorator
+ *     projectBoundedContext.feature(IssueClosed)(ArchiveIssue);         // a use case of an event
+ *     projectBoundedContext.feature(CommandCancelIssue, { replaces: CancelIssue })(CancelAndArchive);
+ *     projectBoundedContext.addFeatureErrorHandler(toEmptyWhenMissing);
+ *     projectBoundedContext.expectErrors(IssueLocked);                  // refused, never reported
+ *     await projectBoundedContext.execute(new CommandCancelIssue("x")); // ResponseCancelIssue
+ *     await projectBoundedContext.execute(new IssueClosed("x"));        // what its use case returns
+ *     projectBoundedContext.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.
+ * the next call — as the backend's `build_root_bus`. A domain event may be the input of a use
+ * case, executed as a Command is: one per bounded context, through the same pipeline. Carrying
+ * it to whoever hears it (a queue, an outbox) is the platform's; an entrypoint that hears it and
+ * calls use cases is an `EventSubscriber`. Injected into another run — an `EventSubscriber`, a
+ * Feature of another bounded context — it is bound to that run (`BIND`).
  */
 export declare class BoundedContext<D extends object = Record<never, never>, C extends object = ContextValues> {
     readonly name: string;
@@ -119,6 +122,14 @@ export declare class BoundedContext<D extends object = Record<never, never>, C e
     execute<R>(command: Command<R>, options: ExecuteOptions): Promise<R>;
     execute(event: DomainEvent, options?: ExecuteOptions | Cause): Promise<unknown>;
     scoped(context: Partial<C>): CommandBus;
+    /**
+     * This bounded context as `execution` calls it — what it is as a dependency of another run (an
+     * `EventSubscriber`, a Feature of another bounded context): what it executes is a child of
+     * that run — its span under the caller's, the same flow (`correlationId`), caused by it,
+     * cancelled with it, its errors reported once along it. It still runs with its own
+     * dependencies, context, interceptors and handlers.
+     */
+    [BIND](execution: Execution): this;
     buildRootBus(): void;
     fresh(): BoundedContext<D, C>;
     /** What escaped a call, told once, from where it first failed. */

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

@@ -1,3 +1,4 @@
+import { BIND } from "../../context/domain/execution.js";
 import { contextAt, } from "../../context/entrypoint/context.js";
 import { processContext, processStore, } from "../../context/infrastructure/process.js";
 import { FeatureBus, optionsOf, } from "../domain/bus.js";
@@ -26,22 +27,24 @@ function nameOf(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");
+ *     const projectBoundedContext = new BoundedContext<ProjectDependencies>("project");
+ *     projectBoundedContext.addDependency("client", clientOf(operations));
+ *     projectBoundedContext.feature(CommandCancelIssue)(CancelIssue);   // or a decorator
+ *     projectBoundedContext.feature(IssueClosed)(ArchiveIssue);         // a use case of an event
+ *     projectBoundedContext.feature(CommandCancelIssue, { replaces: CancelIssue })(CancelAndArchive);
+ *     projectBoundedContext.addFeatureErrorHandler(toEmptyWhenMissing);
+ *     projectBoundedContext.expectErrors(IssueLocked);                  // refused, never reported
+ *     await projectBoundedContext.execute(new CommandCancelIssue("x")); // ResponseCancelIssue
+ *     await projectBoundedContext.execute(new IssueClosed("x"));        // what its use case returns
+ *     projectBoundedContext.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.
+ * the next call — as the backend's `build_root_bus`. A domain event may be the input of a use
+ * case, executed as a Command is: one per bounded context, through the same pipeline. Carrying
+ * it to whoever hears it (a queue, an outbox) is the platform's; an entrypoint that hears it and
+ * calls use cases is an `EventSubscriber`. Injected into another run — an `EventSubscriber`, a
+ * Feature of another bounded context — it is bound to that run (`BIND`).
  */
 export class BoundedContext {
     name;
@@ -211,6 +214,31 @@ export class BoundedContext {
         const scope = { ...context };
         return new FeatureBus((executable, options) => this.generation().root(executable, scope, options));
     }
+    /**
+     * This bounded context as `execution` calls it — what it is as a dependency of another run (an
+     * `EventSubscriber`, a Feature of another bounded context): what it executes is a child of
+     * that run — its span under the caller's, the same flow (`correlationId`), caused by it,
+     * cancelled with it, its errors reported once along it. It still runs with its own
+     * dependencies, context, interceptors and handlers.
+     */
+    [BIND](execution) {
+        const caller = execution;
+        const execute = (executable, second) => this.generation().root(executable, {}, { ...optionsOf(second), caller });
+        const scoped = (context) => {
+            const scope = { ...context };
+            return new FeatureBus((executable, options) => this.generation().root(executable, scope, { ...options, caller }));
+        };
+        return new Proxy(this, {
+            get(target, property) {
+                if (property === "execute")
+                    return execute;
+                if (property === "scoped")
+                    return scoped;
+                const value = Reflect.get(target, property, target);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        });
+    }
     buildRootBus() {
         this.generation();
     }
@@ -248,7 +276,8 @@ export class BoundedContext {
         const heard = {
             executable: at?.executable ?? executable,
             execution: at?.execution,
-            layer: at?.layer,
+            // Listeners hear use cases: a failure an entrypoint's run started says no layer.
+            layer: at?.layer === "entrypoint" ? undefined : at?.layer,
             error,
             outcome,
         };
@@ -386,7 +415,9 @@ export class BoundedContext {
                 dependencies,
                 context: () => ({ ...processContext.values, ...this.context.values, ...scope }),
                 ...(parent ? { parent } : {}),
-                // Only an event comes from outside with a cause; a child continues its parent.
+                // A root called from another run continues it; a child continues its parent.
+                ...(options.caller && !parent ? { caller: options.caller } : {}),
+                // Only an event comes from outside with a cause.
                 ...(options.cause && executable instanceof DomainEvent && !parent
                     ? { cause: options.cause }
                     : {}),

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

@@ -6,7 +6,7 @@ import { type ExecutableClass, type Hearing } from "../services/listening.js";
  *
  *     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
+ * Context: a bounded context's own listeners (`projectBoundedContext.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.
  */

package/dist/core/infrastructure/listeners.js

@@ -5,7 +5,7 @@ import { listenIn, } from "../services/listening.js";
  *
  *     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
+ * Context: a bounded context's own listeners (`projectBoundedContext.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.
  */

package/dist/core/services/execution.d.ts

@@ -4,10 +4,12 @@ import type { Executable } from "../domain/dto.js";
 import type { ErrorHandler } from "../domain/errors.js";
 import type { Cause, ExecutionCompleted, ExecutionStarted, Interceptor, PipelineLayer } from "../domain/pipeline.js";
 import { type Attributes, type Outcome } from "../../observability/domain/tracing.js";
-export interface RuntimeService {
-    execute(command: object): unknown;
-}
-type Layer = PipelineLayer;
+/**
+ * Where a run sits: a use case's layer (`PipelineLayer`), or an entrypoint that calls use cases —
+ * an `EventSubscriber`. Interceptors wrap and listeners hear use cases only.
+ */
+export type RunLayer = PipelineLayer | "entrypoint";
+type Layer = RunLayer;
 /** Where a failure first happened: the run, its executable, its layer and how it ended. */
 export type FailedAt = {
     readonly execution: Execution;
@@ -23,44 +25,58 @@ export interface Announcer {
     completed(heard: ExecutionCompleted): void;
 }
 export interface ExecutionOptions {
+    /** Its bounded context — or, for an entrypoint's run, the registry it belongs to. */
     readonly boundedContext: string;
     readonly name: string;
     readonly layer: Layer;
+    /** The method that runs it: a use case's `execute`, an entrypoint's `handle`. */
+    readonly method?: "execute" | "handle";
     /** What else its span says: the event it executes, the service it replaced. */
     readonly attributes?: Attributes;
     readonly dependencies: ReadonlyMap<string, unknown>;
     readonly context: () => ContextValues;
     readonly parent?: Execution;
+    /**
+     * The run that called this root from outside its bounded context — an `EventSubscriber`, a
+     * Feature of another bounded context — through a bounded context bound to it (`BIND`): its span
+     * is the parent, its flow continues, it is the cause and its signal cancels this one; the
+     * context, dependencies and handlers stay this bounded context's.
+     */
+    readonly caller?: Execution;
     /** What caused a root run from outside: a delivered event's envelope continues its chain. */
     readonly cause?: Cause;
     /** What cancels a root run; a child inherits its parent's. */
     readonly signal?: AbortSignal;
-    readonly featureBus: (execution: Execution) => object;
+    /** An ApplicationService's Features; no other layer has them. */
+    readonly featureBus?: (execution: Execution) => object;
     /** What runs around the service, outermost first. */
     readonly interceptors: readonly Interceptor[];
-    /** Who hears it start and answer. */
-    readonly announce: Announcer;
+    /** Who hears a use case start and answer; an entrypoint's run is not announced. */
+    readonly announce?: Announcer;
     /** The bounded context's expected errors: they end `refused`, never reported. */
     readonly expected: (error: unknown) => boolean;
     /** The bounded context's handlers for this layer: what answers a failure instead of raising it. */
     readonly handlers: readonly ErrorHandler[];
 }
 /**
- * One pipeline for every registered Feature and ApplicationService.
+ * One pipeline for every registered Feature and ApplicationService — and for every entrypoint's
+ * run that calls them (an `EventSubscriber`).
  *
- * 1. A span `<bounded context>/<serviceName>`, a child of the parent run when there is one, and
- *    the execution every dependency, `this.logger` and child Feature are bound to.
- *    Its chain: the parent's correlation (or the cause's, or its own id for a root), caused by
- *    the parent run or the delivered event.
- * 2. Its start is announced; the interceptors run around the service, which sees the
- *    execution through its own view of the instance.
+ * 1. A span `<bounded context>/<serviceName>`, a child of the run above it when there is one (its
+ *    parent, or the caller from outside), and the execution every dependency, `this.logger` and
+ *    child Feature are bound to. Its chain: the run above's correlation (or the cause's, or its
+ *    own id for a root), caused by the run above or the delivered event.
+ * 2. A use case's start is announced; the interceptors run around the service, which sees the
+ *    execution through its own view of the instance. An entrypoint's run is neither announced
+ *    nor intercepted.
  * 3. A failure is observed where it happened: its outcome (expected by the bounded context →
- *    `refused`, else the process's `outcomeOf`), the span closed with it, its log line,
- *    where it first failed and — when `failed`, and only once per error along the run — its
+ *    `refused`; else the outcome it already had where it first failed — another bounded
+ *    context's rules —; else the process's `outcomeOf`), the span closed with it, its log line,
+ *    where it first failed and — when `failed`, and only once per error along the flow — its
  *    report.
  * 4. Then the layer's error handlers answer it, in order; with none, or when the last throws,
  *    the error reaches the caller.
  * Final: the service's answer — announced —, or its handlers'.
  */
-export declare function executeService(target: RuntimeService, command: Executable, options: ExecutionOptions): Promise<unknown>;
+export declare function executeService(target: object, command: Executable, options: ExecutionOptions): Promise<unknown>;
 export {};

package/dist/core/services/execution.js

@@ -64,7 +64,9 @@ function serviceView(target, options, execution) {
                 return execution.signal;
             if (property === "execution")
                 return execution;
-            if (property === "featureBus" && options.layer === "application_service") {
+            if (property === "featureBus" &&
+                options.layer === "application_service" &&
+                options.featureBus) {
                 return (features ??= options.featureBus(execution));
             }
             if (typeof property === "string" && options.dependencies.has(property)) {
@@ -95,17 +97,20 @@ function serviceView(target, options, execution) {
     });
 }
 /**
- * One pipeline for every registered Feature and ApplicationService.
+ * One pipeline for every registered Feature and ApplicationService — and for every entrypoint's
+ * run that calls them (an `EventSubscriber`).
  *
- * 1. A span `<bounded context>/<serviceName>`, a child of the parent run when there is one, and
- *    the execution every dependency, `this.logger` and child Feature are bound to.
- *    Its chain: the parent's correlation (or the cause's, or its own id for a root), caused by
- *    the parent run or the delivered event.
- * 2. Its start is announced; the interceptors run around the service, which sees the
- *    execution through its own view of the instance.
+ * 1. A span `<bounded context>/<serviceName>`, a child of the run above it when there is one (its
+ *    parent, or the caller from outside), and the execution every dependency, `this.logger` and
+ *    child Feature are bound to. Its chain: the run above's correlation (or the cause's, or its
+ *    own id for a root), caused by the run above or the delivered event.
+ * 2. A use case's start is announced; the interceptors run around the service, which sees the
+ *    execution through its own view of the instance. An entrypoint's run is neither announced
+ *    nor intercepted.
  * 3. A failure is observed where it happened: its outcome (expected by the bounded context →
- *    `refused`, else the process's `outcomeOf`), the span closed with it, its log line,
- *    where it first failed and — when `failed`, and only once per error along the run — its
+ *    `refused`; else the outcome it already had where it first failed — another bounded
+ *    context's rules —; else the process's `outcomeOf`), the span closed with it, its log line,
+ *    where it first failed and — when `failed`, and only once per error along the flow — its
  *    report.
  * 4. Then the layer's error handlers answer it, in order; with none, or when the last throws,
  *    the error reaches the caller.
@@ -117,8 +122,12 @@ export async function executeService(target, command, options) {
     const useCase = `${options.boundedContext}.${options.name}`;
     const context = options.parent?.context ?? options.context();
     const id = newEntityId();
-    const correlationId = options.parent?.correlationId ?? options.cause?.correlationId ?? id;
-    const causationId = options.parent?.id ?? options.cause?.id;
+    // The run above this one: its parent in the bounded context, or the caller from outside.
+    const above = options.parent ?? options.caller;
+    const correlationId = above?.correlationId ?? options.cause?.correlationId ?? id;
+    const causationId = above?.id ?? options.cause?.id;
+    const layer = options.layer;
+    const useCaseLayer = layer === "entrypoint" ? undefined : layer;
     const attributes = {
         "sincpro.use_case": useCase,
         "sincpro.layer": options.layer,
@@ -129,32 +138,35 @@ export async function executeService(target, command, options) {
         ...options.attributes,
     };
     const span = observe(() => ports.tracer.start(`${options.boundedContext}/${options.name}`, {
-        ...(options.parent ? { parent: options.parent.span } : {}),
+        ...(above ? { parent: above.span } : {}),
         attributes,
     }), NO_TRACER.start(useCase, {}));
     const execution = {
         id,
         useCase,
         boundedContext: options.boundedContext,
-        parent: options.parent,
+        parent: above,
         correlationId,
         causationId,
-        signal: options.signal ?? options.parent?.signal,
+        signal: options.signal ?? above?.signal,
         span,
         context,
     };
-    const reported = options.parent
-        ? (REPORTED_BY_EXECUTION.get(options.parent) ?? new Set())
+    const reported = above
+        ? (REPORTED_BY_EXECUTION.get(above) ?? new Set())
         : new Set();
     REPORTED_BY_EXECUTION.set(execution, reported);
-    logExecution(options.layer, execution);
-    observe(() => options.announce.started({ executable: command, execution, layer: options.layer }), undefined);
+    logExecution(layer, execution);
+    if (useCaseLayer)
+        observe(() => options.announce?.started({ executable: command, execution, layer: useCaseLayer }), undefined);
     const finish = (error) => {
         const outcome = error
-            ? observe(() => (options.expected(error.value) ? "refused" : ports.outcomeOf(error.value)), "failed")
+            ? observe(() => options.expected(error.value)
+                ? "refused"
+                : (failedAt(error.value)?.outcome ?? ports.outcomeOf(error.value)), "failed")
             : "ok";
         observe(() => span.end(outcome, error?.value), undefined);
-        logExecution(options.layer, execution, {
+        logExecution(layer, execution, {
             outcome,
             durationMs: Math.max(0, Date.now() - startedAt),
         });
@@ -175,25 +187,28 @@ export async function executeService(target, command, options) {
             FAILED_AT.set(error.value, {
                 execution,
                 executable: command,
-                layer: options.layer,
+                layer,
                 outcome,
             });
         return outcome;
     };
     const view = serviceView(target, options, execution);
-    const service = (current) => Promise.resolve(Reflect.apply(target.execute, view, [current]));
+    const method = Reflect.get(target, options.method ?? "execute");
+    const service = (current) => Promise.resolve(Reflect.apply(method, view, [current]));
     let answer;
     try {
         const signal = execution.signal;
         if (signal?.aborted)
             throw abortedBy(signal);
-        const running = runAround(options.interceptors, service, command, {
-            boundedContext: options.boundedContext,
-            useCase,
-            layer: options.layer,
-            execution,
-            logger: executionLogger(options.layer, execution),
-        });
+        const running = useCaseLayer
+            ? runAround(options.interceptors, service, command, {
+                boundedContext: options.boundedContext,
+                useCase,
+                layer: useCaseLayer,
+                execution,
+                logger: executionLogger(useCaseLayer, execution),
+            })
+            : service(command);
         answer = signal === undefined ? await running : await untilAborted(running, signal);
     }
     catch (error) {
@@ -201,16 +216,17 @@ export async function executeService(target, command, options) {
         if (options.handlers.length === 0)
             throw error;
         const recovered = await handled(options.handlers, error);
-        logHandled(options.layer, { execution });
+        logHandled(layer, { execution });
         return recovered;
     }
     finish();
-    observe(() => options.announce.completed({
-        executable: command,
-        execution,
-        layer: options.layer,
-        answer,
-        durationMs: Math.max(0, Date.now() - startedAt),
-    }), undefined);
+    if (useCaseLayer)
+        observe(() => options.announce?.completed({
+            executable: command,
+            execution,
+            layer: useCaseLayer,
+            answer,
+            durationMs: Math.max(0, Date.now() - startedAt),
+        }), undefined);
     return answer;
 }

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

@@ -41,7 +41,7 @@ export type StoredQueue = EventQueue & {
  * each platform plugs.
  *
  *     const queue = storedQueue({ store: sqliteEventStore(db), subscriber, ready: online });
- *     shop.addDependency("publisher", new Publisher(queue));
+ *     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`
@@ -60,8 +60,9 @@ export type StoredQueue = EventQueue & {
  *    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. A subscriber that must not act
- * twice keys what it does by the envelope's id — `this.execution.causationId` in its run. And one
- * process drains a store: two tabs over one IndexedDB claim it first (the Web Locks API).
+ * 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 declare function storedQueue(options: StoredQueueOptions): StoredQueue;

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

@@ -22,7 +22,7 @@ function described(boundedContext, error) {
  * each platform plugs.
  *
  *     const queue = storedQueue({ store: sqliteEventStore(db), subscriber, ready: online });
- *     shop.addDependency("publisher", new Publisher(queue));
+ *     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`
@@ -41,9 +41,10 @@ function described(boundedContext, error) {
  *    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. A subscriber that must not act
- * twice keys what it does by the envelope's id — `this.execution.causationId` in its run. And one
- * process drains a store: two tabs over one IndexedDB claim it first (the Web Locks API).
+ * 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;

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

@@ -7,7 +7,7 @@ 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`:
  *
- *     shop.addDependency("publisher", new Publisher(queue));
+ *     shopBoundedContext.addDependency("publisher", new Publisher(queue));
  *     // in a Feature:
  *     await this.publisher.publish(new OrderPaid(order.id));   // its Envelope
  *

package/dist/event_driven/entrypoint/publisher.js

@@ -4,7 +4,7 @@ import { envelopeOf, } from "../domain/envelope.js";
  * Puts events into a queue — what a Feature holds to tell whoever listens, as the backend's
  * `Publisher`:
  *
- *     shop.addDependency("publisher", new Publisher(queue));
+ *     shopBoundedContext.addDependency("publisher", new Publisher(queue));
  *     // in a Feature:
  *     await this.publisher.publish(new OrderPaid(order.id));   // its Envelope
  *

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

@@ -2,7 +2,11 @@ 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 a bounded context: whether it hears an event, and running it. */
+/**
+ * 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;
@@ -10,14 +14,18 @@ export type HearingContext = {
     execute(event: DomainEvent, cause?: Cause): Promise<unknown>;
 };
 /**
- * Hands an event to every bounded context that hears it — the backend's `Subscriber(buses)`:
+ * The door of a queue: hands an event to everyone who hears it — the backend's
+ * `Subscriber(buses)`:
  *
- *     const subscriber = new Subscriber(shop, mail, stock);
+ *     const subscriber = new Subscriber(shopBoundedContext, mailBoundedContext, ticketsSubscriptions);
  *     const queue = syncQueue(subscriber);              // or a platform's durable queue
  *
- * Context: one subscriber per bounded context (its Feature or ApplicationService registered for
- * the event class); several contexts hearing one event is several executions, one each, in the
- * order named. A context that fails does not stop the others: each answer, or failure, is said.
+ * 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;