@sincpro/client-framework 0.6.0 → 1.1.0

package/dist/common/failures.js

@@ -0,0 +1,212 @@
+/** The kinds that fail the same way on every attempt — set aside at the first failure. */
+export const PERMANENT_KINDS = new Set([
+    "invalid",
+    "unauthenticated",
+    "permission_denied",
+    "not_found",
+    "key_reused",
+    "domain",
+]);
+/** What the caller does next, by kind — the backend's `NEXT_STEP_OF`. */
+const NEXT_STEP_OF = {
+    invalid: "fix_request",
+    unauthenticated: "authenticate",
+    permission_denied: "ask_for_access",
+    not_found: "do_not_retry",
+    conflict: "refresh_and_retry",
+    in_progress: "retry_later",
+    key_reused: "fix_request",
+    domain: "do_not_retry",
+    exhausted: "retry_later",
+    unavailable: "retry_later",
+    unknown_outcome: "verify_then_retry",
+    internal: "retry_later",
+};
+/** The kinds that are the system's problem: reported, never shown as the caller's answer. */
+const FAULTS = new Set([
+    "internal",
+    "unavailable",
+    "unknown_outcome",
+]);
+const RETRYABLE_STEPS = new Set([
+    "retry_later",
+    "refresh_and_retry",
+]);
+/** A retryable kind that says nothing waits a second, as the backend's `DEFAULT_RETRY_AFTER`. */
+const DEFAULT_RETRY_AFTER = 1;
+const KINDS = new Set(Object.keys(NEXT_STEP_OF));
+function isKind(value) {
+    return typeof value === "string" && KINDS.has(value);
+}
+/**
+ * The kind each wire's own code stands for, when an answer carries no `Problem` — the backend's
+ * tables, read back, so a transport of any wire (REST, JSON-RPC, gRPC, another backend's) builds
+ * errors that declare the same kinds:
+ *
+ *     class RpcError extends Error {
+ *       constructor(readonly code: number, message: string) { super(message); }
+ *       get failureKind() { return kindOfJsonRpcCode(this.code); }
+ *     }
+ */
+export function kindOfHttpStatus(status) {
+    if (status === 401)
+        return "unauthenticated";
+    if (status === 403)
+        return "permission_denied";
+    if (status === 404 || status === 410)
+        return "not_found";
+    if (status === 409 || status === 412)
+        return "conflict";
+    if (status === 429)
+        return "exhausted";
+    if (status === 502 || status === 503)
+        return "unavailable";
+    if (status === 504)
+        return "unknown_outcome";
+    if (status >= 500)
+        return "internal";
+    return "invalid";
+}
+/** The kind a gRPC status code stands for — the backend's gRPC table, read back. */
+export function kindOfGrpcCode(code) {
+    switch (code) {
+        case 3: // INVALID_ARGUMENT
+        case 11: // OUT_OF_RANGE
+            return "invalid";
+        case 16: // UNAUTHENTICATED
+            return "unauthenticated";
+        case 7: // PERMISSION_DENIED
+            return "permission_denied";
+        case 5: // NOT_FOUND
+        case 12: // UNIMPLEMENTED
+            return "not_found";
+        case 6: // ALREADY_EXISTS
+        case 10: // ABORTED — also an idempotent run in flight
+            return "conflict";
+        case 9: // FAILED_PRECONDITION — also a reused idempotency key
+            return "domain";
+        case 8: // RESOURCE_EXHAUSTED
+            return "exhausted";
+        case 14: // UNAVAILABLE
+            return "unavailable";
+        case 1: // CANCELLED
+        case 4: // DEADLINE_EXCEEDED
+            return "unknown_outcome";
+        default: // UNKNOWN, INTERNAL, DATA_LOSS
+            return "internal";
+    }
+}
+/** The kind a JSON-RPC error code stands for — the backend's catalogue, read back. */
+export function kindOfJsonRpcCode(code) {
+    switch (code) {
+        case -32700:
+        case -32600:
+        case -32602:
+            return "invalid";
+        case -32601:
+        case -32004:
+            return "not_found";
+        case -32000:
+            return "unavailable";
+        case -32001:
+            return "unauthenticated";
+        case -32003:
+            return "permission_denied";
+        case -32009:
+            return "conflict";
+        case -32010:
+            return "domain";
+        case -32022:
+            return "key_reused";
+        case -32024:
+            return "unknown_outcome";
+        case -32029: // an idempotent run in flight, or a limit spent — the problem says which
+            return "exhausted";
+        default:
+            return "internal";
+    }
+}
+function upperSnake(kind) {
+    return kind.toUpperCase();
+}
+/** What the error declares: on itself first, then on its class. */
+function declared(error) {
+    const own = error;
+    const type = (error.constructor ?? {});
+    return {
+        ...(isKind(own.failureKind ?? type.failureKind)
+            ? { failureKind: own.failureKind ?? type.failureKind }
+            : {}),
+        ...(typeof (own.reason ?? type.reason) === "string"
+            ? { reason: own.reason ?? type.reason }
+            : {}),
+        ...(typeof (own.retryAfter ?? type.retryAfter) === "number"
+            ? { retryAfter: own.retryAfter ?? type.retryAfter }
+            : {}),
+    };
+}
+function isProblem(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        isKind(value.kind) &&
+        typeof value.next_step === "string");
+}
+function failure(kind, said, aborted = false) {
+    const nextStep = said.nextStep ?? NEXT_STEP_OF[kind];
+    const retryable = RETRYABLE_STEPS.has(nextStep);
+    return {
+        kind,
+        reason: said.reason ?? upperSnake(kind),
+        nextStep,
+        retryable,
+        retryAfter: retryable ? (said.retryAfter ?? DEFAULT_RETRY_AFTER) : undefined,
+        permanent: !aborted && PERMANENT_KINDS.has(kind),
+        fault: !aborted && FAULTS.has(kind),
+        aborted,
+        problem: said.problem,
+    };
+}
+/**
+ * The failure `error` is.
+ *
+ * 1. Whoever asked stopped waiting (`AbortError`): aborted — a write may have run, so its kind is
+ *    `unknown_outcome`, but it is nobody's failure.
+ * 2. What the error declares (`failureKind`, `reason`, `retryAfter`), on itself or its class.
+ * 3. What the server said (`problem`, a `Problem` — the same over REST, JSON-RPC and gRPC): its
+ *    kind, reason, next step and wait.
+ * 4. A REST answer (`TransportError`) with a status and no problem: the kind its HTTP status
+ *    stands for. Another wire's transport declares its kind instead (`kindOfGrpcCode`,
+ *    `kindOfJsonRpcCode`).
+ * 5. A request that got no answer (`status: null`): `unknown_outcome` — it may have run.
+ * Final: anything else is `internal`, a fault.
+ */
+export function failureOf(error) {
+    if (error === null || typeof error !== "object")
+        return failure("internal", {});
+    const named = error.name;
+    if (named === "AbortError")
+        return failure("unknown_outcome", {}, true);
+    const own = declared(error);
+    if (own.failureKind !== undefined)
+        return failure(own.failureKind, {
+            ...(own.reason !== undefined ? { reason: own.reason } : {}),
+            ...(own.retryAfter !== undefined ? { retryAfter: own.retryAfter } : {}),
+        });
+    const answered = error;
+    if (isProblem(answered.problem)) {
+        const problem = answered.problem;
+        return failure(problem.kind, {
+            reason: problem.reason,
+            nextStep: problem.next_step,
+            ...(problem.retry_after !== undefined ? { retryAfter: problem.retry_after } : {}),
+            problem,
+        });
+    }
+    if ("problem" in answered && "status" in answered) {
+        if (typeof answered.status === "number")
+            return failure(kindOfHttpStatus(answered.status), {});
+        if (answered.status === null)
+            return failure("unknown_outcome", {});
+    }
+    return failure("internal", {});
+}

package/dist/common/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The values of the wire, as the backend writes them: ids, a day and an instant, `Decimal`,
+ * `Money`, a to-many as a page of its records, and how any value is written and read.
+ */
+export { collectionOf, type EntityCollection, type HeldCollection, isCollection, isPartial, relatedCriteria, type RelationKeys, totalOf, } from "./collection.js";
+export { Decimal, type DecimalLike } from "./decimal.js";
+export { type DeclaredFailure, type Failure, failureOf, kindOfGrpcCode, kindOfHttpStatus, kindOfJsonRpcCode, PERMANENT_KINDS, } from "./failures.js";
+export { isEntityId, momentOf, newEntityId } from "./ids.js";
+export { Money } from "./money.js";
+export { BYTES, type JsonValue, pack, readValues, type Rebuild, rebuilt, unpack, valuesOf, } from "./serialization.js";
+export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./time.js";

package/dist/common/index.js

@@ -0,0 +1,11 @@
+/**
+ * The values of the wire, as the backend writes them: ids, a day and an instant, `Decimal`,
+ * `Money`, a to-many as a page of its records, and how any value is written and read.
+ */
+export { collectionOf, isCollection, isPartial, relatedCriteria, totalOf, } from "./collection.js";
+export { Decimal } from "./decimal.js";
+export { failureOf, kindOfGrpcCode, kindOfHttpStatus, kindOfJsonRpcCode, PERMANENT_KINDS, } from "./failures.js";
+export { isEntityId, momentOf, newEntityId } from "./ids.js";
+export { Money } from "./money.js";
+export { BYTES, pack, readValues, rebuilt, unpack, valuesOf, } from "./serialization.js";
+export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./time.js";

package/dist/context/adapters/memory.d.ts

@@ -0,0 +1,6 @@
+import type { ContextStore } from "../domain/store.js";
+/**
+ * The context in this process's memory: the default, on every platform. A test gets a fresh one
+ * from `configureProcess()`.
+ */
+export declare function memoryContexts(): ContextStore;

package/dist/context/adapters/memory.js

@@ -0,0 +1,34 @@
+/**
+ * The context in this process's memory: the default, on every platform. A test gets a fresh one
+ * from `configureProcess()`.
+ */
+export function memoryContexts() {
+    const held = new Map();
+    const versions = new Map();
+    const listeners = new Map();
+    const changed = (key) => {
+        versions.set(key, (versions.get(key) ?? 0) + 1);
+        for (const listener of [...(listeners.get(key) ?? [])])
+            listener();
+    };
+    return {
+        load: (key) => held.get(key),
+        save(key, values) {
+            // A copy: whoever handed the values may keep changing their object.
+            held.set(key, { ...values });
+            changed(key);
+        },
+        delete(key) {
+            if (!held.delete(key))
+                return;
+            changed(key);
+        },
+        version: (key) => versions.get(key) ?? 0,
+        watch(key, listener) {
+            const own = listeners.get(key) ?? new Set();
+            listeners.set(key, own);
+            own.add(listener);
+            return () => void own.delete(listener);
+        },
+    };
+}

package/dist/context/adapters/plain-codec.d.ts

@@ -0,0 +1,3 @@
+import { type ContextCodec } from "../domain/codec.js";
+/** The codec for anything outside the codebase: only the values that travel, as JSON. */
+export declare const plainCodec: ContextCodec;

package/dist/context/adapters/plain-codec.js

@@ -0,0 +1,16 @@
+import { travelling, } from "../domain/codec.js";
+/** The codec for anything outside the codebase: only the values that travel, as JSON. */
+export const plainCodec = {
+    dumps: (values) => JSON.stringify(travelling(values)),
+    loads(text) {
+        try {
+            const found = JSON.parse(text);
+            return found !== null && typeof found === "object" && !Array.isArray(found)
+                ? found
+                : {};
+        }
+        catch {
+            return {};
+        }
+    },
+};

package/dist/context/{codec.d.ts → domain/codec.d.ts}

@@ -23,4 +23,3 @@ export interface ContextCodec {
 export declare function travels(value: unknown): boolean;
 /** The values of `context` that travel; the rest stays in this process. */
 export declare function travelling(context: ContextValues): ContextValues;
-export declare const plainCodec: ContextCodec;

package/dist/context/{codec.js → domain/codec.js}

@@ -28,17 +28,3 @@ export function travels(value) {
 export function travelling(context) {
     return Object.fromEntries(Object.entries(context).filter(([, value]) => travels(value)));
 }
-export const plainCodec = {
-    dumps: (values) => JSON.stringify(travelling(values)),
-    loads(text) {
-        try {
-            const found = JSON.parse(text);
-            return found !== null && typeof found === "object" && !Array.isArray(found)
-                ? found
-                : {};
-        }
-        catch {
-            return {};
-        }
-    },
-};

package/dist/context/domain/execution.d.ts

@@ -0,0 +1,45 @@
+import type { Span } from "../../observability/domain/tracing.js";
+/**
+ * One run of a use case: its span, what it runs with, and who ran it.
+ *
+ * Context: sincpro_framework keeps the running use case in a context variable; a browser has
+ * nothing like it that survives an `await` (AsyncContext is a proposal, Zone.js patches the
+ * world), and a global stack mixes the parents of two use cases running at once — which a
+ * screen with several windows does all the time. So an execution is a value, handed to what
+ * the use case calls: the Features its `featureBus` runs, and its dependencies (`BIND`).
+ */
+export type Execution = {
+    /** UUID v7, as 32 hex: this run. */
+    readonly id: string;
+    /** `<bounded context>.<Service>` — the use case's identity, as the backend names its own. */
+    readonly useCase: string;
+    /** The bounded context the use case belongs to. */
+    readonly boundedContext: string;
+    /** The run that executed this one: an ApplicationService, for its Features. */
+    readonly parent: Execution | undefined;
+    /**
+     * The chain it belongs to: the id of what started it all — the root run, or the first event
+     * of a flow it continues. Every run and event of one flow share it.
+     */
+    readonly correlationId: string;
+    /** What directly caused it: its parent run, or the event it executes; none for a root. */
+    readonly causationId: string | undefined;
+    /**
+     * What cancels it: the signal it was executed with, inherited by its Features — and by every
+     * request its bound transport sends.
+     */
+    readonly signal: AbortSignal | undefined;
+    readonly span: Span;
+    /** What it runs with, read once where the gesture started and inherited by every child. */
+    readonly context: Readonly<Record<string, unknown>>;
+};
+/**
+ * A dependency that has something to say about the execution it is used in: given that
+ * execution, it answers itself bound to it. The transport, every generated client and the
+ * predefined loggers are; any other dependency of a bounded context is handed as it is.
+ */
+export declare const BIND: unique symbol;
+export type Bindable<T> = {
+    [BIND]: (execution: Execution) => T;
+};
+export declare function isBindable<T>(value: T): value is T & Bindable<T>;

package/dist/context/domain/execution.js

@@ -0,0 +1,11 @@
+/**
+ * A dependency that has something to say about the execution it is used in: given that
+ * execution, it answers itself bound to it. The transport, every generated client and the
+ * predefined loggers are; any other dependency of a bounded context is handed as it is.
+ */
+export const BIND = Symbol.for("sincpro.client-framework.bind");
+export function isBindable(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[BIND] === "function");
+}

package/dist/context/{store.d.ts → domain/store.d.ts}

@@ -44,8 +44,3 @@ export interface ContextStore {
      */
     watch?(key: string, listener: () => void): () => void;
 }
-/**
- * The context in this process's memory: the default, on every platform. A test gets a fresh one
- * from `configureProcess()`.
- */
-export declare function memoryContexts(): ContextStore;

package/dist/context/{store.js → domain/store.js}

@@ -23,37 +23,4 @@
  * Reads are synchronous on purpose: a use case reads its context where a gesture starts, and an
  * asynchronous store would make every use case wait for it.
  */
-/**
- * The context in this process's memory: the default, on every platform. A test gets a fresh one
- * from `configureProcess()`.
- */
-export function memoryContexts() {
-    const held = new Map();
-    const versions = new Map();
-    const listeners = new Map();
-    const changed = (key) => {
-        versions.set(key, (versions.get(key) ?? 0) + 1);
-        for (const listener of [...(listeners.get(key) ?? [])])
-            listener();
-    };
-    return {
-        load: (key) => held.get(key),
-        save(key, values) {
-            // A copy: whoever handed the values may keep changing their object.
-            held.set(key, { ...values });
-            changed(key);
-        },
-        delete(key) {
-            if (!held.delete(key))
-                return;
-            changed(key);
-        },
-        version: (key) => versions.get(key) ?? 0,
-        watch(key, listener) {
-            const own = listeners.get(key) ?? new Set();
-            listeners.set(key, own);
-            own.add(listener);
-            return () => void own.delete(listener);
-        },
-    };
-}
+export {};

package/dist/context/{context.d.ts → entrypoint/context.d.ts}

@@ -1,4 +1,4 @@
-import type { ContextStore, ContextValues } from "./store.js";
+import type { ContextStore, ContextValues } from "../domain/store.js";
 /**
  * One level of the context: the process's (`processContext`) or a bounded context's
  * (`project.context`), read and written the same way on every platform.

package/dist/context/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The context: the levels a call sees (the process, its bounded context, a scope), where they
+ * live (`ContextStore`, a port each platform implements), what travels with a request, and the
+ * execution a run carries.
+ *
+ *   domain/          the ports and rules: `ContextStore`, `ContextCodec`, what travels, `Execution`
+ *   adapters/        the implementations this package gives: memory, the plain codec
+ *   entrypoint/      `Context`: one door over a level
+ *   infrastructure/  the process's store and its level (`processContext`)
+ */
+export { memoryContexts } from "./adapters/memory.js";
+export { plainCodec } from "./adapters/plain-codec.js";
+export { CONTEXT_HEADER, type ContextCodec, travelling, travels, } from "./domain/codec.js";
+export { BIND, type Bindable, type Execution, } from "./domain/execution.js";
+export type { ContextStore, ContextValues, } from "./domain/store.js";
+export type { Context } from "./entrypoint/context.js";
+export { processContext } from "./infrastructure/process.js";

package/dist/context/index.js

@@ -0,0 +1,15 @@
+/**
+ * The context: the levels a call sees (the process, its bounded context, a scope), where they
+ * live (`ContextStore`, a port each platform implements), what travels with a request, and the
+ * execution a run carries.
+ *
+ *   domain/          the ports and rules: `ContextStore`, `ContextCodec`, what travels, `Execution`
+ *   adapters/        the implementations this package gives: memory, the plain codec
+ *   entrypoint/      `Context`: one door over a level
+ *   infrastructure/  the process's store and its level (`processContext`)
+ */
+export { memoryContexts } from "./adapters/memory.js";
+export { plainCodec } from "./adapters/plain-codec.js";
+export { CONTEXT_HEADER, travelling, travels, } from "./domain/codec.js";
+export { BIND, } from "./domain/execution.js";
+export { processContext } from "./infrastructure/process.js";

package/dist/context/infrastructure/process.d.ts

@@ -0,0 +1,13 @@
+import type { ContextStore } from "../domain/store.js";
+import { type Context, type StoreSource } from "../entrypoint/context.js";
+/** @internal — `configureProcess` is the way in. */
+export declare function replaceProcessStore(store: ContextStore): void;
+/** The process's store as every level of the context reads it — the process's and each bounded context's. */
+export declare const processStore: StoreSource;
+/**
+ * The process's level of the context: what every use case of every bounded context runs with —
+ * the tenant, the company, the language.
+ *
+ *     processContext.set({ tenant_id: "acme" });
+ */
+export declare const processContext: Context;

package/dist/context/infrastructure/process.js

@@ -0,0 +1,35 @@
+import { memoryContexts } from "../adapters/memory.js";
+import { contextAt, } from "../entrypoint/context.js";
+/**
+ * Where this process keeps its context: the store `configureProcess` chose (`memoryContexts()`
+ * until it chooses), read on every call, never at import.
+ *
+ * Context: a level made before `main` configures the process (`project` is defined when its
+ * module loads) still reads the store chosen later; whoever listens moves to the new store and
+ * hears the change.
+ */
+let current = memoryContexts();
+const replacing = new Set();
+/** @internal — `configureProcess` is the way in. */
+export function replaceProcessStore(store) {
+    const before = current;
+    current = store;
+    if (current !== before)
+        for (const listener of [...replacing])
+            listener();
+}
+/** The process's store as every level of the context reads it — the process's and each bounded context's. */
+export const processStore = {
+    current: () => current,
+    replaced(listener) {
+        replacing.add(listener);
+        return () => void replacing.delete(listener);
+    },
+};
+/**
+ * The process's level of the context: what every use case of every bounded context runs with —
+ * the tenant, the company, the language.
+ *
+ *     processContext.set({ tenant_id: "acme" });
+ */
+export const processContext = contextAt("process", processStore);

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

@@ -0,0 +1,27 @@
+import type { Command, DomainEvent, Executable, ResponseClass } from "./dto.js";
+import type { Cause, ExecuteOptions } from "./pipeline.js";
+/** What the second argument of `execute` is: options, a delivered event's cause, or a type. */
+export declare function optionsOf(second: unknown): ExecuteOptions;
+/**
+ * What executes a Command or a domain event: the bounded context, a scope of it, an
+ * ApplicationService's features. A Command answers its Response; an event, whatever its
+ * subscriber returns.
+ */
+export interface CommandBus {
+    execute<R>(command: Command<R>, returnType?: ResponseClass<NoInfer<R>>): Promise<R>;
+    execute<R>(command: Command<R>, options: ExecuteOptions): Promise<R>;
+    execute(event: DomainEvent, options?: ExecuteOptions | Cause): Promise<unknown>;
+}
+/** @internal — how a bus hands what it executes to its generation. */
+export type Dispatch = (executable: Executable, options: ExecuteOptions) => Promise<unknown>;
+/**
+ * What an ApplicationService composes its context's Features through (`this.featureBus`): the
+ * same pipeline, as a child of the running execution, and Features only.
+ */
+export declare class FeatureBus implements CommandBus {
+    private readonly dispatch;
+    constructor(dispatch: Dispatch);
+    execute<R>(command: Command<R>, returnType?: ResponseClass<NoInfer<R>>): Promise<R>;
+    execute<R>(command: Command<R>, options: ExecuteOptions): Promise<R>;
+    execute(event: DomainEvent, options?: ExecuteOptions | Cause): Promise<unknown>;
+}

package/dist/core/domain/bus.js

@@ -0,0 +1,26 @@
+/** What the second argument of `execute` is: options, a delivered event's cause, or a type. */
+export function optionsOf(second) {
+    if (second === null || typeof second !== "object")
+        return {};
+    const given = second;
+    if (typeof given.id === "string" && typeof given.correlationId === "string")
+        return { cause: { id: given.id, correlationId: given.correlationId } };
+    return {
+        ...(given.signal ? { signal: given.signal } : {}),
+        ...(given.cause ? { cause: given.cause } : {}),
+    };
+}
+/**
+ * What an ApplicationService composes its context's Features through (`this.featureBus`): the
+ * same pipeline, as a child of the running execution, and Features only.
+ */
+export class FeatureBus {
+    dispatch;
+    constructor(dispatch) {
+        this.dispatch = dispatch;
+    }
+    execute(executable, second) {
+        // As with Python's return_type, the answer is not validated at runtime.
+        return this.dispatch(executable, optionsOf(second));
+    }
+}

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

@@ -0,0 +1,62 @@
+/**
+ * The DTOs of the application layer, as sincpro_framework's `DataTransferObject`: a Command asks
+ * for work and names, by its type, the Response it answers.
+ *
+ *     class CommandCancelIssue extends Command<ResponseCancelIssue> {
+ *       constructor(readonly issue_id: string) { super(); }
+ *     }
+ *     const answer = await project.execute(new CommandCancelIssue("x"));   // ResponseCancelIssue
+ *
+ * Context: the backend asks `bus(dto, ResponseType)` for the type; here the Command carries it, so
+ * `execute` infers it with no second argument. The association is type-only: absent from a
+ * serialized DTO, not a runtime validator. A generated DTO is a remote contract (a type), not one
+ * of these: a local Command may implement it.
+ */
+export declare abstract class DataTransferObject {
+    protected readonly dtoBrand: void;
+}
+export declare abstract class Response extends DataTransferObject {
+}
+declare const responseType: unique symbol;
+export declare abstract class Command<R> extends DataTransferObject {
+    /** Type-only association: absent from serialized DTOs and not a runtime validator. */
+    readonly [responseType]: R;
+}
+/**
+ * A fact that already happened, as sincpro_framework's `DomainEvent`: executed like a Command, by
+ * the Feature or ApplicationService registered for its class — its subscriber in this bounded
+ * context —, through the same pipeline. Delivering it (a queue, an outbox) is the platform's.
+ *
+ *     class OrderPaid extends DomainEvent {
+ *       static readonly eventName = "shop.order.v1.paid";
+ *       constructor(readonly order_id: string) { super(); }
+ *     }
+ *     project.feature(OrderPaid)(NotifyCustomer);
+ *     await project.execute(new OrderPaid("o-1"));
+ *
+ * Context: the backend names an event on the wire by `name`, `<context>.<aggregate>.vN.<fact>`,
+ * and defaults it to the class's name; a client is minified, so the name is declared, as
+ * `serviceName` is. `name` is reserved, as the backend reserves it: every event reads its class's
+ * `eventName` there, and a subclass cannot make it a field.
+ */
+export declare abstract class DomainEvent extends DataTransferObject {
+    protected readonly eventBrand: void;
+    /** Its wire name: its class's `eventName`. */
+    get name(): string;
+}
+/** What an event class declares: the name it is known by on the wire. */
+type EventNamed = {
+    readonly eventName: string;
+};
+export type AnyCommand = Command<unknown>;
+/** What a service is registered for and executes: a Command, or a domain event. */
+export type Executable = AnyCommand | DomainEvent;
+/** What it answers: a Command's Response; whatever its subscriber returns, for an event. */
+export type Answer<T> = T extends Command<infer R> ? R : unknown;
+/** A Command's class: what a service is registered for, by exact constructor identity. */
+export type CommandClass<C extends AnyCommand> = abstract new (...args: never[]) => C;
+/** A domain event's class, with its wire name. */
+export type EventClass<E extends DomainEvent> = (abstract new (...args: never[]) => E) & EventNamed;
+/** A Response's class: the backend's `return_type`, accepted for the same reading. */
+export type ResponseClass<R> = abstract new (...args: never[]) => R;
+export {};