@ingenioz-it/caits 0.5.1 → 0.7.0

package/src/di/frontend.ts

@@ -1,3 +1,5 @@
+import type { EventPublisher } from "../messaging/EventPublisher.js";
+import { eventsFor, type Line } from "../messaging/FrontendContextMap.js";
 import { createFrontend } from "./createFrontend.js";
 import { discoveredFrontends } from "./discoveredFrontends.js";
 import type { Fetcher } from "./Fetcher.js";
@@ -6,7 +8,6 @@ import type { Fetcher } from "./Fetcher.js";
  * The frontends of the contexts, by name. Each context adds its own, next to its type:
  * `declare module "@ingenioz-it/caits/di/frontend" { interface Frontends { counter: CounterFrontend } }`.
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- the contexts fill it
 export interface Frontends {}
 
 const kept = Symbol("frontends");
@@ -17,17 +18,58 @@ export function frontendsOn($global: object): Map<string, unknown> {
   return ($global as Global)[kept] ??= new Map<string, unknown>();
 }
 
+/** The context whose bus is the shared bus: the context maps share its events there, and hear them. */
+const SHARED = "shared";
+
 /**
  * The frontend of a context, for the views of one $global: the server has one $global per request, the browser one per page.
  * It is built the first time a view asks. On the server, it reaches the API with the fetch of the request (Marko Run, in the
- * same process); in the browser, with the fetch of the browser.
+ * same process); in the browser, with the fetch of the browser. The bus of the context shared is the shared bus of the $global: the
+ * context map of a context shares there the events of shared that the events of its context give, and each of them goes to the
+ * contexts whose context map hears it.
  */
 export function frontendOf<Name extends keyof Frontends>($global: object, name: Name): Frontends[Name] {
+  return frontendNamed($global, name) as Frontends[Name];
+}
+
+/** The frontend of the context of this name on a $global, built the first time that something asks for it. */
+function frontendNamed($global: object, name: string): unknown {
   const frontends = frontendsOn($global);
   if (!frontends.has(name)) {
     const context = discoveredFrontends[name];
     if (!context) throw new Error(`No frontend context is named ${name}`);
-    frontends.set(name, createFrontend(context, ($global as Global).fetch ?? ((input, init) => fetch(input, init))));
+    const frontend = createFrontend(context, ($global as Global).fetch ?? ((input, init) => fetch(input, init)));
+    frontends.set(name, frontend);
+    if (name === SHARED) frontend.events.subscribe(event => { hear($global, event as object); });
+    frontend.events.subscribe(event => { tell($global, context.map, event as object); });
+  }
+  return frontends.get(name);
+}
+
+/** The lines of a map that hear the context shared, or those that share with it. */
+const lines = (map: readonly Line[], shares: boolean) => map.filter(line => line.shares === shares);
+
+/**
+ * An event of a context, on its bus: the events of shared that the lines of its map that share give go to the shared bus of the $global.
+ * The frontend of shared is built when a context first shares an event.
+ */
+function tell($global: object, map: readonly Line[], event: object): void {
+  const told = eventsFor(lines(map, true), event);
+  if (told.length === 0) return;
+  const { events: shared } = frontendNamed($global, SHARED) as { events: EventPublisher<object> };
+  for (const sharedEvent of told) shared.publish(sharedEvent);
+}
+
+/**
+ * An event of the context shared, on the shared bus of a $global: each context whose context map hears it publishes the events that
+ * the lines that hear it give on its own bus, its frontend built if no view asked for it yet. A context that does not hear it is not
+ * built.
+ */
+function hear($global: object, event: object): void {
+  for (const [name, context] of Object.entries(discoveredFrontends)) {
+    const events = eventsFor(lines(context.map, false), event);
+    if (events.length === 0) continue;
+    const { events: bus } = frontendNamed($global, name) as { events: EventPublisher<object> };
+    for (const own of events) bus.publish(own);
   }
-  return frontends.get(name) as Frontends[Name];
 }

package/src/messaging/BackendEventBus.ts

@@ -1,6 +1,5 @@
 import type { DomainEvent } from "../DomainEvent.js";
 import type { ContextMap, Envelope } from "./ContextMap.js";
-import type { Input } from "./Input.js";
 import type { ReportError } from "./ReportError.js";
 
 export type Published = { readonly event: DomainEvent; readonly envelope: Envelope };
@@ -8,8 +7,9 @@ export type Published = { readonly event: DomainEvent; readonly envelope: Envelo
 const nextTurn = () => new Promise(resolve => { setTimeout(resolve, 0); });
 
 /**
- * Carries the events of the contexts. The context map turns each event into input DTOs, and each input goes to the context that
- * handles it. The publisher never waits for the reactions; every failure is reported.
+ * The shared bus: carries the events of shared that the context maps share. The context map of each context turns the events of shared
+ * that it hears into input DTOs of the context, and each input goes to it. The publisher never waits for the reactions; every failure is
+ * reported.
  */
 export class BackendEventBus {
   private inFlight = new Set<Promise<void>>();
@@ -17,7 +17,7 @@ export class BackendEventBus {
 
   constructor(private readonly options: {
     map: ContextMap;
-    send: (input: Input<unknown>, envelope: Envelope) => Promise<unknown>;
+    send: (input: object, envelope: Envelope) => Promise<unknown>;
     nextEventId: () => string;
     reportError: ReportError;
   }) {}
@@ -34,7 +34,7 @@ export class BackendEventBus {
     void delivery.then(() => { this.inFlight.delete(delivery); });
   }
 
-  /** Watches every event the contexts publish. */
+  /** Watches every event on the shared bus. */
   subscribe(listener: (published: Published) => void): () => void {
     this.listeners.add(listener);
     return () => { this.listeners.delete(listener); };
@@ -47,7 +47,7 @@ export class BackendEventBus {
 
   private async deliver(event: DomainEvent, envelope: Envelope): Promise<void> {
     await nextTurn();
-    let inputs: Input<unknown>[];
+    let inputs: object[];
     try {
       inputs = this.options.map.inputsFor(event, envelope);
     } catch (error) {

package/src/messaging/ContextMap.ts

@@ -1,22 +1,45 @@
 import type { DomainEvent } from "../DomainEvent.js";
-import type { Input } from "./Input.js";
 
 /** What the shared bus adds to an event it carries: an id of its own, and the correlation id of the request that published it. */
 export type Envelope = { readonly eventId: string; readonly correlationId: string };
 
 type EventClass<E> = abstract new (...args: never[]) => E;
 
-export type Translation = { readonly event: EventClass<DomainEvent>; readonly inputs: (event: never, envelope: Envelope) => Input<unknown>[] };
+/**
+ * One line of the context map of a backend context (its context-map.ts): an event of the context shared that it hears, which becomes
+ * input DTOs of the context, or an event of the context that it shares, which becomes events of the context shared.
+ */
+export type Translation =
+  | { readonly shares: false; readonly event: EventClass<DomainEvent>; readonly inputs: (event: never, envelope: Envelope) => object[] }
+  | { readonly shares: true; readonly event: EventClass<DomainEvent>; readonly events: (event: never) => DomainEvent[] };
 
-/** One line of the context map: an event of a context becomes input DTOs, for whichever contexts handle them. */
-export function when<E extends DomainEvent>(event: EventClass<E>, inputs: (event: E, envelope: Envelope) => Input<unknown>[]): Translation {
-  return { event, inputs };
+/**
+ * A line that hears the context shared: when this event of shared comes on the shared bus, the handlers of the context execute these
+ * input DTOs. A context map names only its own context and the context shared: two contexts never name each other.
+ */
+export function when<E extends DomainEvent>(event: EventClass<E>, inputs: (event: E, envelope: Envelope) => object[]): Translation {
+  return { shares: false, event, inputs };
+}
+
+/**
+ * A line that tells the other contexts: when a handler of the context publishes this event of its own, the context publishes these
+ * events of shared on the shared bus, and the context map of each context that hears them turns them into inputs of its own. The event
+ * of the context holds what the events of shared need.
+ */
+export function share<E extends DomainEvent>(event: EventClass<E>, events: (event: E) => DomainEvent[]): Translation {
+  return { shares: true, event, events };
 }
 
 export class ContextMap {
   constructor(private readonly translations: Translation[]) {}
 
-  inputsFor(event: DomainEvent, envelope: Envelope): Input<unknown>[] {
-    return this.translations.filter(translation => event instanceof translation.event).flatMap(translation => translation.inputs(event as never, envelope));
+  /** The input DTOs that the lines that hear this event of shared give, none when no line hears it. */
+  inputsFor(event: DomainEvent, envelope: Envelope): object[] {
+    return this.translations.flatMap(translation => !translation.shares && event instanceof translation.event ? translation.inputs(event as never, envelope) : []);
+  }
+
+  /** The events of shared that the lines that share this event of the context give, none when no line shares it. */
+  eventsFor(event: DomainEvent): DomainEvent[] {
+    return this.translations.flatMap(translation => translation.shares && event instanceof translation.event ? translation.events(event as never) : []);
   }
 }

package/src/messaging/Controller.ts

@@ -1,4 +1,3 @@
-import type { Input } from "./Input.js";
 import type { MessageBus } from "./MessageBus.js";
 import { reportToConsole, type ReportError } from "./ReportError.js";
 
@@ -68,7 +67,7 @@ export function problem(status: number, slug: string, title: string, detail?: st
 }
 
 /** Turns a request into an input DTO, sends it to the message bus of the request, and turns the output or the error into a response. */
-export abstract class Controller<Dto extends Input<Output>, Output> {
+export abstract class Controller<Dto extends object, Output> {
   constructor(private bus: MessageBus, private reportError: ReportError = reportToConsole) {}
 
   protected abstract toDto(request: Request): Dto | Promise<Dto>;
@@ -92,7 +91,7 @@ export abstract class Controller<Dto extends Input<Output>, Output> {
     try {
       let output: Output;
       try {
-        output = await this.bus.send(await this.toDto(request));
+        output = await this.bus.send(await this.toDto(request)) as Output;
       } catch (error) {
         return await this.toErrorResponse(error, request);
       }

package/src/messaging/EventPublisher.ts

@@ -2,8 +2,8 @@ import { Token } from "../Token.js";
 
 /**
  * Publishes the events of a context: the handlers get it, and the views of the frontend. It cannot subscribe, and it gives nothing back.
- * In the backend, the events go later to the other contexts, through the context map. In the frontend, they go at once to the store of
- * the same context.
+ * In the backend, the context map of the context shares them as events of shared, which go later to the other contexts. In the frontend,
+ * they go at once to the store of the same context, and its context map shares them.
  */
 export interface EventPublisher<E> {
   publish(event: E): void;

package/src/messaging/FrontendContextMap.ts

@@ -0,0 +1,33 @@
+type EventClass<E> = abstract new (...args: never[]) => E;
+
+/**
+ * One line of the context map of a frontend context: an event of the context shared that it hears, which becomes events of the context,
+ * or an event of the context that it shares, which becomes events of the context shared.
+ */
+export type Line = { readonly shares: boolean; readonly event: EventClass<object>; readonly events: (event: never) => object[] };
+
+/**
+ * A line that hears the context shared, in the context map of a frontend context (its context-map.ts): when this event of shared comes
+ * on the shared bus, the context publishes these events of its own on its own bus, and its store reads them. A context map names only
+ * its own context and the context shared: two contexts never name each other.
+ */
+export function when<E extends object>(event: EventClass<E>, events: (event: E) => object[]): Line {
+  return { shares: false, event, events };
+}
+
+/**
+ * A line that tells the other contexts: when a view, a component or a handler of the context publishes this event of its own on its
+ * bus, the context publishes these events of shared on the shared bus, and the context map of each context that hears them turns them
+ * into events of its own. The event of the context holds what the events of shared need.
+ */
+export function share<E extends object>(event: EventClass<E>, events: (event: E) => object[]): Line {
+  return { shares: true, event, events };
+}
+
+/**
+ * The events that a map gives for an event, line by line, none when no line reads it: for an event of shared that it hears, events of
+ * the context; for an event of the context that it shares, events of shared.
+ */
+export function eventsFor(map: readonly Line[], event: object): object[] {
+  return map.filter(line => event instanceof line.event).flatMap(line => line.events(event as never));
+}

package/src/messaging/InProcessMessageBus.ts

@@ -1,12 +1,10 @@
-import type { Input } from "./Input.js";
 import type { MessageBus } from "./MessageBus.js";
 
-export type OutputOf<I> = I extends Input<infer Output> ? Output : never;
-type InputClass<I extends Input<unknown>> = abstract new (...args: never[]) => I;
+type InputClass<I> = abstract new (...args: never[]) => I;
 
 export class UnknownInputError extends Error {
   constructor(readonly inputName: string) {
-    super(`No handler subscribes to ${inputName}`);
+    super(`No handler takes ${inputName}: write one next to its DTO, in <use-case>.handler.ts, with execute(input: ${inputName})`);
     this.name = "UnknownInputError";
   }
 }
@@ -22,14 +20,14 @@ export class DuplicateHandlerError extends Error {
 export class InProcessMessageBus implements MessageBus {
   private handlers = new Map<unknown, (input: never) => unknown>();
 
-  subscribe<I extends Input<unknown>>(input: InputClass<I>, handler: (input: I) => OutputOf<I> | Promise<OutputOf<I>>): void {
+  subscribe<I extends object>(input: InputClass<I>, handler: (input: I) => unknown): void {
     if (this.handlers.has(input)) throw new DuplicateHandlerError(input.name);
     this.handlers.set(input, handler);
   }
 
-  async send<Output>(input: Input<Output>): Promise<Output> {
+  async send(input: object): Promise<unknown> {
     const handler = this.handlers.get(input.constructor);
     if (!handler) throw new UnknownInputError(input.constructor.name);
-    return (await handler(input as never)) as Output;
+    return await handler(input as never);
   }
 }

package/src/messaging/MessageBus.ts

@@ -1,12 +1,11 @@
 import { Token } from "../Token.js";
-import type { Input } from "./Input.js";
 
 /**
  * Where a controller or a store sends an input DTO: the message bus gives it to the handler of its class, and gives back the output of
  * the handler.
  */
 export interface MessageBus {
-  send<Output>(input: Input<Output>): Promise<Output>;
+  send(input: object): Promise<unknown>;
 }
 
 export const MessageBus = new Token<MessageBus>();

package/src/state/createStore.ts

@@ -1,5 +1,4 @@
 import type { EventSubscriber } from "../messaging/EventSubscriber.js";
-import type { Input } from "../messaging/Input.js";
 import type { MessageBus } from "../messaging/MessageBus.js";
 import { reportToConsole, type ReportError } from "../messaging/ReportError.js";
 
@@ -9,7 +8,7 @@ export interface StoreDefinition<S, E> {
   /** The state after the event. */
   reduce(state: S, event: E): S;
   /** The input DTO that the event asks the store to send to the message bus, or undefined. It reads the state before the event. */
-  send(state: S, event: E): Input<unknown> | undefined;
+  send(state: S, event: E): object | undefined;
 }
 
 export interface Store<S> {

package/src/testing/backend/application.ts

@@ -2,7 +2,7 @@ import { test as base } from "vitest";
 import { createTestApplication, type TestApplication } from "./applications.js";
 
 /** Everything an application test of the backend imports: the test of a use case, written as a scenario. */
-export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, vi } from "vitest";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, vi } from "vitest";
 export { applicationScenario } from "./applicationScenario.js";
 export type { TestApplication } from "./applications.js";
 

package/src/testing/backend/applicationScenario.ts

@@ -1,19 +1,18 @@
 import { expect } from "vitest";
 import type { DomainEvent } from "../../DomainEvent.js";
-import type { Input } from "../../messaging/Input.js";
 import type { TestApplication } from "./applications.js";
 
-type Result<Output> = { output: Output } | { error: unknown };
+type Result = { output: unknown } | { error: unknown };
 
 /**
  * An application test, written as a presentation test: the input DTO, the events the handler publishes, then the output DTO or the error
  * that the message bus gives. The events are checked only when the test says which ones it expects.
  */
-export class ApplicationScenario<Output> {
+export class ApplicationScenario {
   private readonly expected: DomainEvent[] = [];
   private checksEvents = false;
 
-  constructor(private readonly app: TestApplication, private readonly dto: Input<Output>) {}
+  constructor(private readonly app: TestApplication, private readonly dto: object) {}
 
   expectItToPublish(event: DomainEvent): this {
     this.expected.push(event);
@@ -26,7 +25,7 @@ export class ApplicationScenario<Output> {
     return this;
   }
 
-  async expectTheOutputToBe(output: Output): Promise<void> {
+  async expectTheOutputToBe(output: object): Promise<void> {
     const from = this.app.published.length;
     const result = await this.run();
     if ("error" in result) throw result.error;
@@ -42,7 +41,7 @@ export class ApplicationScenario<Output> {
     expect(result.error).toStrictEqual(error);
   }
 
-  private async run(): Promise<Result<Output>> {
+  private async run(): Promise<Result> {
     try {
       return { output: await this.app.send(this.dto) };
     } catch (error) {
@@ -56,5 +55,5 @@ export class ApplicationScenario<Output> {
 }
 
 export const applicationScenario = (app: TestApplication) => ({
-  givenTheDto: <Output>(dto: Input<Output>) => new ApplicationScenario(app, dto)
+  givenTheDto: (dto: object) => new ApplicationScenario(app, dto)
 });

package/src/testing/backend/applications.ts

@@ -14,7 +14,7 @@ const testBindings: Record<string, readonly Binding[]> = Object.fromEntries(
 
 type EventType<E extends DomainEvent> = abstract new (...args: never[]) => E;
 
-/** The whole backend, built from the bindings of its contexts with their test.di.ts over them, and predictable ids. For the tests of the context map. */
+/** The whole backend, built from the bindings of its contexts with their test.di.ts over them, and predictable ids. For the tests of the context maps. */
 export function createTestBackendApplication() {
   const reportedErrors: unknown[] = [];
   const published: Published[] = [];
@@ -29,7 +29,7 @@ export function createTestBackendApplication() {
   return {
     ...backend,
     reportedErrors,
-    /** Every event the contexts published, in its envelope, in the order they were published. */
+    /** Every event of shared that the context maps shared, in its envelope, in the order they were published. */
     published,
     publishedNames: () => published.map(({ event }) => event.constructor.name),
     publishedOf: <E extends DomainEvent>(type: EventType<E>): E[] => published.flatMap(({ event }) => event instanceof type ? [event] : [])
@@ -37,13 +37,14 @@ export function createTestBackendApplication() {
 }
 
 /**
- * Every context, built from its di.ts with its test.di.ts over it, but alone: no event reaches another context. A test sends input DTOs
- * and reads the events the handlers published.
+ * Every context, built from its di.ts with its test.di.ts over it, but alone: no context map hears or shares an event. A test sends
+ * input DTOs and reads the events of their context that the handlers published.
  */
 export function createTestApplication() {
   const published: DomainEvent[] = [];
-  const backend = createBackend({ ...discovered, map: [] }, { replace: testBindings, reportError: () => undefined });
-  backend.subscribe(({ event }) => { published.push(event); });
+  const alone = Object.fromEntries(Object.entries(discovered.contexts).map(([name, context]) => [name, { ...context, map: [] }]));
+  const backend = createBackend({ ...discovered, contexts: alone }, { replace: testBindings, reportError: () => undefined });
+  backend.subscribeToContexts(event => { published.push(event); });
 
   return {
     /** Sends an input DTO to the message bus of the context that handles it. */

package/src/testing/backend/context-map.ts

@@ -1,8 +1,11 @@
 import { test as base } from "vitest";
 import { createTestBackendApplication, type TestBackendApplication } from "./applications.js";
 
-/** Everything a test of the context map imports. `test` checks the Input DTOs that the `ContextMap` gives for an Event. */
-export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+/**
+ * Everything a test of the context map imports. `test` checks what the `ContextMap` gives: the input DTOs for an event of shared
+ * (`inputsFor`), the events of shared for an event of the context (`eventsFor`).
+ */
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 export { ContextMap } from "../../messaging/ContextMap.js";
 export type { TestBackendApplication } from "./applications.js";
 

package/src/testing/backend/integration.ts

@@ -2,7 +2,7 @@ import { createBackend } from "../../di/createBackend.js";
 import { discovered } from "../../di/discovered.js";
 
 /** Everything an integration test imports: flows of the context map again, with the real infra implementations. */
-export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 
 /** The whole backend, built from the di.ts of the contexts only: the real infra implementations, as in production. */
 export const productionBackend = () => createBackend(discovered);

package/src/testing/frontend/applicationScenario.ts

@@ -1,5 +1,4 @@
 import { expect } from "vitest";
-import type { Input } from "../../messaging/Input.js";
 import type { TestApplication } from "./applications.js";
 
 /**
@@ -10,7 +9,7 @@ import type { TestApplication } from "./applications.js";
 export class ApplicationScenario implements PromiseLike<void> {
   private readonly expected: object[] = [];
 
-  constructor(private readonly app: TestApplication, private readonly dto: Input<void>) {}
+  constructor(private readonly app: TestApplication, private readonly dto: object) {}
 
   expectItToPublish(event: object): this {
     this.expected.push(event);
@@ -32,5 +31,5 @@ export class ApplicationScenario implements PromiseLike<void> {
 }
 
 export const applicationScenario = (app: TestApplication) => ({
-  givenTheDto: (dto: Input<void>) => new ApplicationScenario(app, dto)
+  givenTheDto: (dto: object) => new ApplicationScenario(app, dto)
 });

package/src/testing/frontend/applications.ts

@@ -4,7 +4,7 @@ import type { Binding } from "../../di/Container.js";
 import { createFrontendWithBus } from "../../di/createFrontend.js";
 import { discoveredFrontends } from "../../di/discoveredFrontends.js";
 import type { Fetcher } from "../../di/Fetcher.js";
-import type { Input } from "../../messaging/Input.js";
+import { UnknownInputError } from "../../messaging/InProcessMessageBus.js";
 import type { Token } from "../../Token.js";
 
 /** The test.di.ts of each context that has one: the bindings that replace, in tests, those that reach outside the browser. */
@@ -37,7 +37,7 @@ export function createTestApplication() {
 
   const ownerOf = (input: object): string => {
     const name = Object.keys(discoveredFrontends).find(context => discoveredFrontends[context].useCases.some(({ input: type }) => type === input.constructor));
-    if (name === undefined) throw new Error(`No context handles ${input.constructor.name}`);
+    if (name === undefined) throw new UnknownInputError(input.constructor.name);
     return name;
   };
 
@@ -50,7 +50,7 @@ export function createTestApplication() {
 
   return {
     /** Sends an input DTO to the message bus of the context that handles it. */
-    send: <Output>(input: Input<Output>): Promise<Output> => frontend(ownerOf(input)).bus.send(input),
+    send: (input: object): Promise<unknown> => frontend(ownerOf(input)).bus.send(input),
     /** The dependency with this token, built now if no handler needed it before. */
     get: <T>(token: Token<T>): T => {
       const found = holders(token);

package/src/testing/frontend/context-map.ts

@@ -0,0 +1,6 @@
+/**
+ * Everything a test of the context map of a frontend context imports: `eventsFor` gives the events of the context that an event of the
+ * context shared gives, and the events of shared that an event of the context gives.
+ */
+export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+export { eventsFor } from "../../messaging/FrontendContextMap.js";

package/src/testing/frontend/frontends.ts

@@ -1,23 +1,29 @@
 import { FrontendEventBus } from "../../messaging/FrontendEventBus.js";
-import type { Input } from "../../messaging/Input.js";
 import { createStore, type StoreDefinition } from "../../state/createStore.js";
-import type { Frontend } from "../../state/request.js";
+import type { EventPublisher } from "../../messaging/EventPublisher.js";
 import { discoveredFrontends } from "../../di/discoveredFrontends.js";
 import { frontendsOn, type Frontends } from "../../di/frontend.js";
 
-type StateOf<F> = F extends Frontend<infer S, unknown> ? S : never;
-type EventOf<F> = F extends Frontend<unknown, infer E> ? E : never;
+type EventOf<F> = F extends { events: EventPublisher<infer E> } ? E : never;
+type StoreOf<F> = F extends { store: infer S } ? S : undefined;
+
+/** The presentation of a context in a test: its frontend, the DTOs that its store sent, and the events that it published. */
+export type TestPresentation<F> = { events: EventPublisher<EventOf<F>>; store: StoreOf<F>; sent: object[]; published: EventOf<F>[] };
 
 /**
- * The presentation of a context, as its views get it: its EventPublisher and its store. The message bus of the store is a Fake: it
- * records the DTOs it receives, and answers nothing. A test publishes the events of the handlers itself.
+ * The presentation of a context, as its views and its components get it: its EventPublisher and its store (none, for a context
+ * without a store). The message bus of the store is a Fake: it records the DTOs it receives in `sent`, and answers nothing. A test
+ * publishes the events of the handlers itself. `published` records every event of the bus, in their order: those that the views and
+ * the components publish. The context map is left aside: its own test reads what it shares.
  */
-export function testPresentation<Name extends keyof Frontends>(name: Name): Frontend<StateOf<Frontends[Name]>, EventOf<Frontends[Name]>> & { sent: Input<unknown>[] } {
+export function testPresentation<Name extends keyof Frontends>(name: Name): TestPresentation<Frontends[Name]> {
   const events = new FrontendEventBus<EventOf<Frontends[Name]>>();
-  const sent: Input<unknown>[] = [];
-  const definition = discoveredFrontends[name].store as StoreDefinition<StateOf<Frontends[Name]>, EventOf<Frontends[Name]>>;
-  const store = createStore(definition, { events, bus: { send: <Output>(input: Input<Output>) => { sent.push(input); return Promise.resolve(undefined as Output); } } });
-  return { events, store, sent };
+  const sent: object[] = [];
+  const published: EventOf<Frontends[Name]>[] = [];
+  events.subscribe(event => { published.push(event); });
+  const definition = discoveredFrontends[name].store as StoreDefinition<unknown, EventOf<Frontends[Name]>> | undefined;
+  const store = definition && createStore(definition, { events, bus: { send: (input: object) => { sent.push(input); return Promise.resolve(undefined); } } });
+  return { events, store, sent, published } as unknown as TestPresentation<Frontends[Name]>;
 }
 
 /** A $global as Marko gives it to the views: the address of the page, and frontends already built. */

package/src/virtual-modules.d.ts

@@ -4,10 +4,9 @@ declare module "virtual:kernel/backend" {
   import type { Translation } from "@ingenioz-it/caits/messaging/ContextMap";
   type Modules = Record<string, Record<string, unknown>>;
   export const bindings: Record<string, readonly Binding[]>;
-  export const dtos: Modules;
   export const handlers: Modules;
   export const controllers: Modules;
-  export const map: Record<string, Translation[]>;
+  export const maps: Record<string, Translation[]>;
 }
 
 declare module "virtual:kernel/backend-test" {
@@ -17,12 +16,13 @@ declare module "virtual:kernel/backend-test" {
 
 declare module "virtual:kernel/frontend" {
   import type { Binding } from "@ingenioz-it/caits/di/Container";
+  import type { Line } from "@ingenioz-it/caits/messaging/FrontendContextMap";
   import type { StoreDefinition } from "@ingenioz-it/caits/state/createStore";
   type Modules = Record<string, Record<string, unknown>>;
   export const bindings: Record<string, readonly Binding[]>;
-  export const dtos: Modules;
   export const handlers: Modules;
   export const stores: Record<string, StoreDefinition<unknown, unknown>>;
+  export const maps: Record<string, readonly Line[]>;
 }
 
 declare module "virtual:kernel/frontend-test" {

package/src/vite.js

@@ -58,17 +58,16 @@ function dependencies(source) {
 const CONTEXT_MODULES = {
   "virtual:kernel/backend": [
     ["bindings", "backend/*/di.ts", true],
-    ["dtos", "backend/*/application/*/*/*.dto.ts"],
-    ["handlers", "backend/*/application/*/*/*.handler.ts"],
-    ["controllers", "backend/*/presentation/*/*.controller.ts"],
-    ["map", "backend/context-map.ts", true]
+    ["handlers", "backend/*/{command,query}/*/*.handler.ts"],
+    ["controllers", "backend/*/{command,query}/*/*.controller.ts"],
+    ["maps", "backend/*/context-map.ts", true]
   ],
   "virtual:kernel/backend-test": [["bindings", "backend/*/test.di.ts", true]],
   "virtual:kernel/frontend": [
     ["bindings", "frontend/*/di.ts", true],
-    ["dtos", "frontend/*/application/*/*/*.dto.ts"],
-    ["handlers", "frontend/*/application/*/*/*.handler.ts"],
-    ["stores", "frontend/*/presentation/store/*Store.ts", true]
+    ["handlers", "frontend/*/{command,query}/*/*.handler.ts"],
+    ["stores", "frontend/*/presentation/store/*Store.ts", true],
+    ["maps", "frontend/*/context-map.ts", true]
   ],
   "virtual:kernel/frontend-test": [["bindings", "frontend/*/test.di.ts", true]]
 };
@@ -86,9 +85,9 @@ function contexts(source) {
   /** @type {(pattern: string, onlyDefault?: boolean) => string} */
   const glob = (pattern, onlyDefault = false) =>
     `import.meta.glob(${JSON.stringify(`${source}/${pattern}`)}, { eager: true${onlyDefault ? `, import: "default"` : ""} })`;
-  /** A pattern as a regular expression: `*` is a part of a name, without "/". */
-  const matcherOf = (/** @type {string} */ pattern) =>
-    new RegExp(`^${`${source}/${pattern}`.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*")}$`);
+  /** A pattern as a regular expression: `*` is a part of a name, without "/", and `{command,query}` one of these names. */
+  const matcherOf = (/** @type {string} */ pattern) => new RegExp(`^${`${source}/${pattern}`.replace(/[.+?^$()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*")
+    .replace(/\{([^}]*)\}/g, (/** @type {string} */ _, /** @type {string} */ names) => `(?:${names.split(",").join("|")})`)}$`);
   const modules = Object.entries(CONTEXT_MODULES).map(([id, exports]) => ({
     id,
     code: exports.map(([name, pattern, onlyDefault]) => `export const ${name} = ${glob(pattern, onlyDefault)};`).join("\n"),
@@ -102,9 +101,15 @@ function contexts(source) {
       // Vite processes the package as the code of the project, also when it is installed: it holds TypeScript and imports these modules.
       ssr: { noExternal: [KERNEL] },
       optimizeDeps: { exclude: [KERNEL] },
-      // The shortcut #shared leads to the backend context shared from every file (the tsconfig.json of the project says it to TypeScript).
-      // Vite reads an alias before the "imports" of the package.json of a context (#context), which cannot lead out of the context.
-      resolve: { alias: [{ find: /^#shared\//, replacement: `${source}/backend/shared/` }] }
+      // The shortcut #shared leads to the backend context shared from every file, and #frontend-shared to the frontend context shared
+      // (the tsconfig.json of the project says it to TypeScript). Vite reads an alias before the "imports" of the package.json of a
+      // context (#context), which cannot lead out of the context.
+      resolve: {
+        alias: [
+          { find: /^#shared\//, replacement: `${source}/backend/shared/` },
+          { find: /^#frontend-shared\//, replacement: `${source}/frontend/shared/` }
+        ]
+      }
     }),
     configResolved: config => { root = config.root; },
     configureServer: server => {