@sincpro/client-framework 0.6.0 → 1.1.0

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

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

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

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

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

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

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

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

package/dist/event_driven/domain/envelope.js

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

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

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

package/dist/event_driven/domain/queue.js

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

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

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

package/dist/event_driven/domain/store.js

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

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

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

package/dist/event_driven/entrypoint/publisher.js

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

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

@@ -0,0 +1,34 @@
+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. */
+export type HearingContext = {
+    readonly name: string;
+    handlerOf(dto: abstract new (...args: never[]) => DomainEvent): unknown;
+    eventTypeOf(name: string): EventClass<DomainEvent> | undefined;
+    execute(event: DomainEvent, cause?: Cause): Promise<unknown>;
+};
+/**
+ * Hands an event to every bounded context that hears it — the backend's `Subscriber(buses)`:
+ *
+ *     const subscriber = new Subscriber(shop, mail, stock);
+ *     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.
+ */
+export declare class Subscriber implements Subscribes {
+    private readonly contexts;
+    constructor(...contexts: HearingContext[]);
+    eventTypeOf(name: string): EventClass<DomainEvent> | undefined;
+    /**
+     * 1. Every bounded context registered for the event's class, in the order named — but those
+     *    `skip` names, which already have it.
+     * 2. Each executes it — continuing the envelope's flow when there is one —, and its answer or
+     *    failure is kept; a failure does not stop the next.
+     * Final: what each answered, or failed with.
+     */
+    handle(event: DomainEvent, envelope?: Envelope, skip?: readonly string[]): Promise<Handled[]>;
+}

package/dist/event_driven/entrypoint/subscriber.js

@@ -0,0 +1,51 @@
+/**
+ * Hands an event to every bounded context that hears it — the backend's `Subscriber(buses)`:
+ *
+ *     const subscriber = new Subscriber(shop, mail, stock);
+ *     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.
+ */
+export class Subscriber {
+    contexts;
+    constructor(...contexts) {
+        this.contexts = contexts;
+    }
+    eventTypeOf(name) {
+        for (const context of this.contexts) {
+            const found = context.eventTypeOf(name);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    /**
+     * 1. Every bounded context registered for the event's class, in the order named — but those
+     *    `skip` names, which already have it.
+     * 2. Each executes it — continuing the envelope's flow when there is one —, and its answer or
+     *    failure is kept; a failure does not stop the next.
+     * Final: what each answered, or failed with.
+     */
+    async handle(event, envelope, skip = []) {
+        const type = Object.getPrototypeOf(event)?.constructor;
+        const handled = [];
+        for (const context of this.contexts) {
+            if (type === undefined || context.handlerOf(type) === undefined)
+                continue;
+            if (skip.includes(context.name))
+                continue;
+            try {
+                handled.push({
+                    boundedContext: context.name,
+                    answer: await context.execute(event, envelope),
+                });
+            }
+            catch (error) {
+                handled.push({ boundedContext: context.name, error });
+            }
+        }
+        return handled;
+    }
+}

package/dist/event_driven/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Event-driven: the ports and the in-memory pieces that let every platform publish domain events
+ * and subscribe to them the same way — as sincpro_framework's `event_driven`. Delivering them
+ * durably (SQLite on a phone, IndexedDB in a browser, a broker) is each platform's, behind
+ * `EventQueue`.
+ *
+ *   domain/      the envelope and the ports: EventQueue, Subscribes, EventStore
+ *   adapters/    syncQueue (in the call), storedQueue (store, then deliver, retry, set aside),
+ *                memoryEventStore
+ *   entrypoint/  Publisher (what a Feature holds), Subscriber (every bounded context that hears)
+ */
+export { type MemoryEventStore, memoryEventStore, } from "./adapters/memory-event-store.js";
+export { type StoredQueue, storedQueue, type StoredQueueOptions, } from "./adapters/stored-queue.js";
+export { syncQueue } from "./adapters/sync-queue.js";
+export { type Envelope, envelopeOf, } from "./domain/envelope.js";
+export type { EventQueue, Handled, Subscribes, } from "./domain/queue.js";
+export type { DeliveryFailure, EventStore, StoredEvent, StoredState, } from "./domain/store.js";
+export { Publisher } from "./entrypoint/publisher.js";
+export { type HearingContext, Subscriber, } from "./entrypoint/subscriber.js";

package/dist/event_driven/index.js

@@ -0,0 +1,17 @@
+/**
+ * Event-driven: the ports and the in-memory pieces that let every platform publish domain events
+ * and subscribe to them the same way — as sincpro_framework's `event_driven`. Delivering them
+ * durably (SQLite on a phone, IndexedDB in a browser, a broker) is each platform's, behind
+ * `EventQueue`.
+ *
+ *   domain/      the envelope and the ports: EventQueue, Subscribes, EventStore
+ *   adapters/    syncQueue (in the call), storedQueue (store, then deliver, retry, set aside),
+ *                memoryEventStore
+ *   entrypoint/  Publisher (what a Feature holds), Subscriber (every bounded context that hears)
+ */
+export { memoryEventStore, } from "./adapters/memory-event-store.js";
+export { storedQueue, } from "./adapters/stored-queue.js";
+export { syncQueue } from "./adapters/sync-queue.js";
+export { envelopeOf, } from "./domain/envelope.js";
+export { Publisher } from "./entrypoint/publisher.js";
+export { Subscriber, } from "./entrypoint/subscriber.js";

package/dist/index.d.ts

@@ -3,45 +3,28 @@
  * service needs, on any platform.
  *
  * Context: one entry, not one per area — the package has no side effects at import
- * (`sideEffects: false`), so an application pays only for what it uses, and a use case, the
- * client it calls and the entity it reads come from the same place.
+ * (`sideEffects: false`), so an application pays only for what it uses. Each module is laid out
+ * as sincpro_framework's are — `domain/` (ports and rules), `adapters/` (their implementations),
+ * `services/`, `infrastructure/`, `entrypoint/` — and says what it offers in its own `index.ts`:
  *
- *   common/   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 (`EntityCollection`), and
- *             how any value is written and read (`valuesOf`, `rebuilt`)
- *   client/   the seam with a server: the transport and its REST and in-memory implementations,
- *             entities with typed commands, the service's client contract
- *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
- *             the process they run in (`configureProcess`), what each run carries
- *   context/  the context: one door (`Context`) over the store each platform plugs
- *   observability/  the ports a platform plugs: a tracer and an error reporter
+ *   common/         the values of the wire, as the backend writes them; what a failure is
+ *   circuit_breaker/  stop calling what keeps failing; try it again once it may be back
+ *   context/        the context's levels, where they live, what travels, the execution
+ *   observability/  tracing, error reporting and logging: ports, console, loggers
+ *   client/         the seam with a server: transports, entities, the client contract
+ *   model/          model definitions
+ *   core/           Commands, events, Features, ApplicationServices, BoundedContext, the
+ *                   pipeline's extension points, the process
+ *   event_driven/   publishing and subscribing to domain events: ports, Publisher, Subscriber
  *
- * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
+ * The generator is `@sincpro/client-framework/codegen`, and the in-memory observability
  * `@sincpro/client-framework/testing`: neither is part of what an application runs.
  */
-export { type ClientContract, entityKeyOf, kindOf, metasOf, versionsOf, } from "./client/contract.js";
-export { bodyFor, type CommandAnswers, type CommandBodies, type CommandRoute, type Entity, entity, type EntityRef, type EntityRoutes, type ExportFormat, exportRoute, listRoute, NEW_PARAM, pathFor, PICK_PARAM, QUERY_PARAM, SCOPE_PARAM, scopeOfRef, startingValuesOf, type SummaryFields, type SummaryPart, TRAIL_PARAM, WITH_PARAM, type WriteRoute, writeRoute, } from "./client/entity.js";
-export { type MemoryOptions, type MemoryTable, memoryTransport, } from "./client/memory.js";
-export { type RestOptions, restTransport, urlOf, type VersionDrift, } from "./client/rest.js";
-export { type RetryKeys, retryKeys, unanswered, } from "./client/retry.js";
-export { type CallOptions, type Decoder, type Download, downloadRoute, type Draft, type Method, type One, readRoute, type SendOptions, type Transport, TransportError, } from "./client/transport.js";
-export { collectionOf, type EntityCollection, type HeldCollection, isCollection, isPartial, relatedCriteria, type RelationKeys, totalOf, } from "./common/collection.js";
-export { Decimal, type DecimalLike } from "./common/decimal.js";
-export { isEntityId, momentOf, newEntityId } from "./common/ids.js";
-export { Money } from "./common/money.js";
-export { BYTES, type JsonValue, pack, readValues, type Rebuild, rebuilt, unpack, valuesOf, } from "./common/serialization.js";
-export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./common/time.js";
-export { CONTEXT_HEADER, type ContextCodec, plainCodec, travelling, travels, } from "./context/codec.js";
-export { type Context } from "./context/context.js";
-export { type ContextStore, type ContextValues, memoryContexts, } from "./context/store.js";
-export { defineMeta, field, type FieldOptions, type MetaSpec, type Words, } from "./model/meta.js";
-export { type MetaStore, metaStore } from "./model/metas.js";
-export { completeMeta, type JsonSchema, metaFromSchema, type SchemaComponents, } from "./model/schema.js";
-export { type Attributes, type ErrorAbout, type ErrorReporter, NO_TRACER, type Outcome, type Span, type Tracer, } from "./observability/ports.js";
-export { type BoundedContext, UseBoundedContext, } from "./services/bounded-context.js";
-export { BIND, type Bindable, bindable, bindDependency, bindTransport, type Execution, headersOf, } from "./services/execution.js";
-export { ApplicationService, Feature, type ServiceClasses, type ServiceMethods, type Services, } from "./services/feature.js";
-export { configureProcess, outcomeOf, processContext, type ProcessOptions, } from "./services/process.js";
-export { reportError } from "./services/report.js";
-export { screensTransport } from "./services/screens.js";
+export * from "./circuit_breaker/index.js";
+export * from "./client/index.js";
+export * from "./common/index.js";
+export * from "./context/index.js";
+export * from "./core/index.js";
+export * from "./event_driven/index.js";
+export * from "./model/index.js";
+export * from "./observability/index.js";