gemi 0.56.0 → 0.58.0

package/dist/services/events/EventManager.d.ts

@@ -0,0 +1,285 @@
+import type { Job } from "../queue/Job";
+import { type EventConfig } from "./config";
+import type { Event } from "./Event";
+import type { ListenerClass } from "./Listener";
+/**
+ * The registry a dispatch fans out through: event name -> the listeners bound
+ * to it.
+ *
+ * Shaped after `QueueManager` deliberately — constructed in `register()` from
+ * whatever the config slice declared, handed the discovered set in `boot()`,
+ * and reporting through a `registered*` getter what it was *given* rather than
+ * what it accepted, so a test can see a collision instead of having it tidied
+ * away.
+ *
+ * Three things are not `QueueManager`'s, and each is a decision rather than a
+ * detail:
+ *
+ * **Many listeners per key.** Two listeners for one event is the normal case
+ * here, where two jobs for one name is the pathological one. So the map holds
+ * arrays and `useListeners` appends. The collision it does refuse is two
+ * *listener classes* claiming one `static name`.
+ *
+ * **Registration order is the walk's order, and means nothing.** It is stable —
+ * `discoverClasses` sorts per directory and the module namespace sorts by name
+ * — so it is reproducible, but no listener may depend on running before
+ * another, because nothing about a filesystem layout was chosen to express
+ * that. What makes it safe to say is the rule below: nothing a listener does
+ * can stop the next one.
+ *
+ * **A dispatch nobody handles warns.** That is the entire early-warning system
+ * for the subsystem, and it is why it is not optional; see `dispatchAndWait`.
+ *
+ * A `queued` listener is not run here at all. It is registered with the
+ * `QueueManager` as a synthetic job and pushed to it on dispatch, so retries,
+ * `maxAttempts`, dead-lettering and worker threads are the queue's rather than
+ * a second implementation of the queue's — and nothing the request had (the
+ * current actor, the ambient transaction) is still promised by the time it
+ * runs. See `Listener.queued`.
+ *
+ * **A dispatch does not always fan out at the dispatch.** An event declaring
+ * `static afterCommit` has the whole of it — queued listeners included — held
+ * on the ORM's transaction scope and drained when that transaction commits, or
+ * dropped when it rolls back. That is the only thing in this file that reads
+ * ambient state, and `deferToCommit` is where it happens.
+ */
+export declare class EventManager {
+    static token: string;
+    /** Event name -> every listener bound to it, in registration order. */
+    private listeners;
+    /**
+     * Event name -> the class to rebuild it from, for a listener coming back off
+     * the queue.
+     *
+     * Read from each listener's `static event` at registration, which is the one
+     * place in the subsystem an event class is dereferenced. An event nobody
+     * listens for is never in here, and that is exactly right: nothing can have
+     * been queued for it.
+     */
+    private events;
+    /**
+     * Event names already warned about. Per-manager, and the manager is per
+     * application, so a test that builds a fresh kernel gets a fresh set.
+     */
+    private warnedFor;
+    /**
+     * Event names already warned about for the `dispatchAndWait` + `afterCommit`
+     * pairing. A second set rather than a second entry in the one above: the two
+     * warnings are about different mistakes, and sharing the set would mean a
+     * dispatch that legitimately has no listeners silences the one that says a
+     * caller is awaiting nothing.
+     */
+    private warnedAboutWaiting;
+    readonly config: Required<EventConfig>;
+    constructor(config?: EventConfig);
+    /**
+     * Replaces the registered set, for the provider to hand over what it found
+     * under `app/listeners`.
+     *
+     * Two phases, for the reason `QueueManager.useJobs` documents: the manager is
+     * constructed in `register()`, which is synchronous and must resolve nothing,
+     * while reading a directory and importing what is in it is neither. So the
+     * manager is built from whatever the config slice declared — nothing, when
+     * the app left `listeners` out — and the discovered set arrives in `boot()`.
+     *
+     * The consequence worth knowing: anything that constructs an application and
+     * skips phase two dispatches into an empty registry, and an empty registry is
+     * a legal steady state rather than an error. The development-only warning
+     * below is the only thing that says so.
+     *
+     * Every listener is **constructed once here**, to read the fields that decide
+     * where it runs — `queued`, and through it `maxAttempts` and `worker`. A
+     * listener's constructor therefore runs at boot as well as on every dispatch,
+     * so it wants to assign fields and nothing else. A queued one also has its
+     * synthetic job built here; `EventServiceProvider` hands those to the queue
+     * once boot reaches it, so calling this again *after* boot would leave the
+     * queue holding jobs for listeners this registry no longer has.
+     */
+    useListeners(listeners: ListenerClass[]): void;
+    /**
+     * The synthetic jobs the queue has to be told about — one per queued
+     * listener, named `listener:<name>`.
+     *
+     * `EventServiceProvider.boot()` is the only caller. It reads this rather than
+     * having the manager reach for the `QueueManager` itself, because
+     * registration happens in `register()`, where resolving another service is
+     * exactly what a provider must not do. A copy, so the caller cannot edit what
+     * a dispatch pushes.
+     */
+    get queuedListenerJobs(): ReadonlyArray<new () => Job>;
+    /**
+     * What the manager was handed, discovered or declared.
+     *
+     * "Is this listener registered?" is a question with a silent wrong answer —
+     * an unregistered listener is a side effect that does not happen, and nothing
+     * is waiting on it to notice. This is where a test asks it out loud.
+     *
+     * It reports what came in, not what the registry accepted, so a name claimed
+     * twice appears twice here — deliberately, the same way `QueueManager` and
+     * `Scheduler` do. A copy, so a walk over it cannot edit what dispatch reads.
+     */
+    get registeredListeners(): ReadonlyArray<ListenerClass>;
+    /**
+     * Fires the event and returns. The sync listeners run to completion after the
+     * caller has moved on.
+     *
+     * Nothing is awaited and nothing can reject: `runListeners` catches every
+     * listener's failure itself, so the floating promise here has no rejection to
+     * float.
+     *
+     * `args` is the event's constructor arguments; see `dispatchAndWait`.
+     *
+     * On an `afterCommit` event inside a transaction, "after the caller has moved
+     * on" becomes "after that transaction commits" — see `deferToCommit`.
+     */
+    dispatch(event: Event, args?: readonly unknown[]): void;
+    /**
+     * Fires the event and resolves once every **sync** listener has settled.
+     *
+     * On an `afterCommit` event inside an open transaction it resolves
+     * **immediately, having run nothing** — there is no listener to wait for yet,
+     * and the transaction it would be waiting on is the caller's own. That is the
+     * sharp edge `Event.afterCommit` documents and the reason the flag ships
+     * opt-in; it warns once per event name in development, because nothing else
+     * about the call site can show it.
+     */
+    dispatchAndWait(event: Event, args?: readonly unknown[]): Promise<void>;
+    /**
+     * Queues the fan-out on the open transaction when the event asked for that,
+     * and reports whether it did — `false` means the caller runs it now.
+     *
+     * Three cases, and only the third defers: an event without
+     * `static afterCommit` behaves exactly as it did before this existed; one
+     * with it, dispatched outside a transaction, has nothing to wait for; one
+     * with it, inside a transaction, runs when that transaction commits and not
+     * at all if it rolls back.
+     *
+     * `currentTransaction()` is not consulted directly, and the difference
+     * matters: `deferUntilCommit` also answers `false` for a scope carrying a
+     * handle that `withTransaction` did not open, which has no commit hook and
+     * therefore no list that will ever be drained. Reading the handle alone would
+     * queue the dispatch onto nothing and lose it silently.
+     *
+     * The whole fan-out is deferred, sync listeners and queued ones alike. A
+     * queued listener is *pushed* at commit rather than at dispatch, which is the
+     * only correct reading of `afterCommit`: the queue drains in-process and
+     * often synchronously from `push`, so pushing early is running early.
+     */
+    private deferToCommit;
+    /**
+     * Runs every **sync** listener bound to this event, in registration order,
+     * and resolves when the last of them has settled. Every queued one is handed
+     * to the `QueueManager` on the way past and is not waited for.
+     *
+     * The dispatch itself is `dispatch` and `dispatchAndWait` above; this is what
+     * they run, and what an `afterCommit` event's transaction runs later. Split
+     * out so that "when does the fan-out happen" is decided in exactly one place
+     * rather than in each entry point.
+     *
+     * ### Sync and queued in one pass
+     *
+     * A queued listener is pushed at the point in the order it occupies, so its
+     * *dispatch* is ordered with the rest and its *execution* is not: the queue
+     * decides when. What that costs is worth knowing — `dispatchAndWait`
+     * resolving says every sync listener has finished and says nothing at all
+     * about a queued one, which may not have started or may already have failed
+     * twice. Whether a listener is queued is therefore a decision about what the
+     * caller can rely on having happened, not only about latency.
+     *
+     * @param args the arguments the event's constructor was called with, which
+     * `Event.dispatch` forwards. Only a queued listener needs them: the event
+     * instance itself never crosses the queue, and what is rebuilt on the other
+     * side is `new EventClass(...args)`. Dispatching a hand-built instance
+     * straight at the manager therefore cannot queue, and says so on stderr
+     * rather than pushing a payload that would rehydrate into an event with
+     * `undefined` fields.
+     *
+     * ### One at a time, deliberately
+     *
+     * Each listener is awaited before the next one starts, rather than started
+     * together under a `Promise.allSettled`. Concurrency would make "registration
+     * order" a claim about start order only, and the order it is a claim about is
+     * the one `registeredListeners` reports and the discovery tests assert on.
+     *
+     * What it costs is worth knowing, because it is the one way listener
+     * independence is not total: a listener that *hangs* — an un-timed-out
+     * `fetch` to a host that never answers — delays every listener after it for
+     * as long as it hangs, and under `dispatch` the caller has already moved on,
+     * so an audit row a later listener writes simply is not there yet. A throw is
+     * not this: that is caught below and the next listener runs immediately. A
+     * listener that can block indefinitely is a listener that wants its own
+     * timeout, or a `Job`.
+     *
+     * ### Errors
+     *
+     * Each listener runs inside its own `try`. A throw is logged with the event
+     * name, the listener name, and the error, and the loop continues — listeners
+     * are independent side effects, and letting listener 2 cancel 3 through 5
+     * would make a filesystem walk's order load-bearing. Neither this nor
+     * `dispatch` ever rejects, for the same reason from the caller's side: a
+     * rejection would make listener 1's failure the dispatcher's problem while
+     * listener 5's silently is not.
+     *
+     * ### Why zero listeners is worth a line on stderr
+     *
+     * A registry keyed by the wrong string, a `static name` that does not survive
+     * a production build, a typo, and a listener directory that was never walked
+     * all produce the same single symptom: nobody handled it. Zero listeners is
+     * also a perfectly legal steady state, so the warning is development-only and
+     * fires once per event name — a dispatch in a loop would otherwise bury the
+     * terminal.
+     */
+    protected runListeners(event: Event, args?: readonly unknown[]): Promise<void>;
+    /**
+     * Rebuilds an event from what crossed the queue.
+     *
+     * The queue carries a name and an argument array, because that is all JSON
+     * can carry: **the constructor arguments are what is serialized, not the
+     * instance** — the same bargain `Job.dispatch` makes. So an event whose
+     * constructor does work beyond assigning fields does that work a second time
+     * here, in the worker, with none of the dispatching request around it.
+     *
+     * A name that resolves to nothing throws, and is the one place in this file
+     * that does. The payload is already off the queue by the time this runs and
+     * the listener is one line away from being handed `undefined`, so the
+     * alternative is a `handle` reading `event.email` off nothing, several frames
+     * further on, with the name that would have explained it no longer in scope.
+     * A throw here is caught by `QueueManager.run` and takes the queue's ordinary
+     * retry-then-dead-letter path.
+     */
+    rehydrate(eventName: string, args?: readonly unknown[]): Event;
+    /**
+     * Hands one queued listener to the queue, as `[eventName, args]`.
+     *
+     * Nothing is awaited: `push` returns as soon as the entry is on the queue,
+     * which is the whole of what `queued = true` buys. The event instance the
+     * sync listeners share does not go with it — only the name and the arguments
+     * do, so nothing that was resolved from the request's context can be smuggled
+     * across into an application that does not have it.
+     *
+     * Failing to queue is caught for the same reason a listener's throw is: it is
+     * one listener's problem, and the listeners after it in the walk did not do
+     * anything to deserve it. Two things reach that catch — an argument JSON
+     * cannot serialise, and an application with no queue bound — and both would
+     * otherwise reject `dispatchAndWait`, which is documented never to.
+     */
+    private enqueue;
+    /**
+     * The one warning for the pairing that reads as doing something and does not.
+     *
+     * `await UserRegistered.dispatchAndWait(...)` inside a transaction, on an
+     * event that defers to commit, resolves with nothing having run — the
+     * listeners are queued on a transaction the caller has not finished. There is
+     * no other symptom: the promise resolves, the listeners do run later, and the
+     * only thing that is wrong is that the caller's `await` bought it nothing.
+     * Code that reads what a listener wrote on the next line finds it missing,
+     * and nothing connects the two.
+     *
+     * Development only and once per event name, on the same terms as the
+     * zero-listener warning: both are legal steady states that are usually a
+     * mistake, and a dispatch in a loop must not bury the terminal.
+     */
+    private warnNothingIsWaitedFor;
+    private warnNothingIsListening;
+}
+//# sourceMappingURL=EventManager.d.ts.map

package/dist/services/events/EventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventManager.d.ts","sourceRoot":"","sources":["../../../services/events/EventManager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,SAAS,CAAC;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAkBhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,YAAY;IACvB,MAAM,CAAC,KAAK,SAAY;IAExB,uEAAuE;IACvE,OAAO,CAAC,SAAS,CAAsC;IAEvD;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAkC;IAEhD;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAqB;IAEtC;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB,CAAqB;IAE/C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;gBAE3B,MAAM,GAAE,WAAgB;IAKpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE;IA0DvC;;;;;;;;;OASG;IACH,IAAI,kBAAkB,IAAI,aAAa,CAAC,UAAU,GAAG,CAAC,CAIrD;IAED;;;;;;;;;;OAUG;IACH,IAAI,mBAAmB,IAAI,aAAa,CAAC,aAAa,CAAC,CAEtD;IAED;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAKvD;;;;;;;;;OASG;IACG,eAAe,CACnB,KAAK,EAAE,KAAK,EACZ,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,GACxB,OAAO,CAAC,IAAI,CAAC;IAKhB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,aAAa;IAoBrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8DG;cACa,YAAY,CAC1B,KAAK,EAAE,KAAK,EACZ,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,GACxB,OAAO,CAAC,IAAI,CAAC;IA2BhB;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,GAAE,SAAS,OAAO,EAAO,GAAG,KAAK;IAiBlE;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,OAAO;IA6Bf;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,sBAAsB;IAe9B,OAAO,CAAC,sBAAsB;CAY/B"}

package/dist/services/events/EventServiceProvider.d.ts

@@ -0,0 +1,46 @@
+import { ServiceProvider } from "../../support/ServiceProvider";
+export declare class EventServiceProvider extends ServiceProvider {
+    register(): void;
+    /**
+     * Fills in the listener registry when the app did not declare one.
+     *
+     * ### Why the raw slice and not the manager's config
+     *
+     * The decision here is whether the app said anything, and by the time the
+     * manager holds a config it can no longer tell: `withDefaults` treats an
+     * absent key and an `undefined` one alike and substitutes the default `[]`,
+     * which is the same value an app writes when it means "no listeners, and I
+     * mean it". Reading the slice before defaults are applied is the only place
+     * the difference still exists.
+     *
+     * So: `listeners` present, including `listeners: []`, is used verbatim and no
+     * directory is read. Absent or `undefined`, the classes under `listenersDir`
+     * are.
+     *
+     * ### Why phase two
+     *
+     * Discovery imports every file it walks, which is asynchronous, and
+     * `register()` is not. It also has to finish before the first dispatch rather
+     * than before the first request — a dispatch against an empty registry is not
+     * an error, it is a side effect that quietly does not happen — so the
+     * registry has to be complete by the end of boot.
+     *
+     * ### Why the queue is handed the listener jobs from here
+     *
+     * A queued listener is registered with the `QueueManager` as a synthetic job,
+     * and that registration cannot happen in `register()`: resolving another
+     * service is the one thing a `register()` must not do, and the jobs are not
+     * known until discovery has run anyway. It also cannot happen before
+     * `QueueServiceProvider.boot()` fills the queue's registry, which is why this
+     * provider sits after it in `frameworkProviders` — `useJobs` replaces that
+     * registry wholesale, so the queue has to be finished with it before
+     * `registerJob` starts adding to it.
+     *
+     * The declared-listeners path falls through to it rather than returning
+     * early: an app that lists its listeners in `app/config/events.ts` still has
+     * queued ones, and skipping the queue for them would make `queued = true` a
+     * field that silently does nothing depending on how the app registers.
+     */
+    boot(): Promise<void>;
+}
+//# sourceMappingURL=EventServiceProvider.d.ts.map

package/dist/services/events/EventServiceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventServiceProvider.d.ts","sourceRoot":"","sources":["../../../services/events/EventServiceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAOhE,qBAAa,oBAAqB,SAAQ,eAAe;IACvD,QAAQ;IAOR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACG,IAAI;CAoBX"}

package/dist/services/events/FakeEventManager.d.ts

@@ -0,0 +1,155 @@
+import type { Application } from "../../foundation/Application";
+import type { Event, EventClass } from "./Event";
+import { EventManager } from "./EventManager";
+/**
+ * One dispatch, as a fake saw it.
+ *
+ * Both halves are kept because neither is derivable from the other. The
+ * instance is what a predicate reads — `(e) => e.email === "…"` — and the
+ * arguments are what the failure message can print, because an instance cannot
+ * be asked what it was constructed with. A dispatch made straight at the
+ * manager carries no arguments at all, which is why they are optional here in
+ * exactly the way they are on `dispatch`.
+ */
+export interface DispatchedEvent {
+    event: Event;
+    args?: readonly unknown[];
+}
+/**
+ * An `EventManager` that records dispatches and runs nothing.
+ *
+ * Installed by `Event.fake()`, which is the only thing that constructs one —
+ * see there for what a fake is for and why `restore()` is not optional.
+ *
+ * It extends the real manager rather than reimplementing its shape, so a test
+ * holding one can still ask `registeredListeners` and get the honest answer
+ * (empty: a fake registers none). What it overrides is the two dispatch entry
+ * points, and everything downstream of them is unreachable as a result — no
+ * listener is constructed, no `handle` runs, nothing is pushed to the
+ * `QueueManager`, and no `afterCommit` event is queued on the open transaction.
+ * That last one is worth stating: a fake short-circuits *before* the
+ * transaction check, so a faked dispatch is recorded at the moment it is made
+ * whether or not the event defers, and a test does not have to commit a
+ * transaction to see it.
+ *
+ * The assertions throw plain `Error`s rather than going through a matcher, so
+ * this file depends on no test runner. Their messages name **what was
+ * dispatched**, because the common failure is not "nothing fired" but "that
+ * fired with a different payload", and printing the recorded dispatches ends
+ * that investigation where it starts.
+ */
+export declare class FakeEventManager extends EventManager {
+    private readonly application;
+    private readonly previous;
+    /**
+     * Every dispatch since the fake was installed, in order. Public and readable
+     * for the case the assertions do not cover — the last resort, rather than the
+     * intended surface.
+     */
+    readonly dispatched: DispatchedEvent[];
+    /**
+     * Installs a fake into `application`'s container, or returns the one already
+     * there.
+     *
+     * A second call returning the same recorder is the deliberate half: a fake
+     * set up by a shared test helper and a `Event.fake()` in the body of the test
+     * would otherwise be two recorders, and the one being asserted on would be
+     * the one that saw nothing. It is also why this is a static rather than a
+     * constructor — "make me one" and "make sure there is one" are different
+     * requests, and only the second is ever wanted.
+     *
+     * `resolved` rather than `make`: asking the container for the real manager
+     * merely to find out whether it exists would *build* it, and building it is
+     * what `restore()` then has to put back. The lazily-bound singleton stays
+     * lazy, and an application that never resolved an `EventManager` is left with
+     * one it never resolved.
+     *
+     * `instanceof` is safe here and nowhere else in this subsystem: the only
+     * thing that puts a `FakeEventManager` in a container is this method, so both
+     * sides of the comparison come from one module graph. The registry keys next
+     * door cannot make that assumption, because the dispatching code may have
+     * been bundled and minified separately from the listeners.
+     */
+    static install(application: Application): FakeEventManager;
+    private constructor();
+    /** Records the dispatch. No listener runs, and nothing reaches the queue. */
+    dispatch(event: Event, args?: readonly unknown[]): void;
+    /**
+     * Records the dispatch and resolves. Resolved rather than rejected-on-nothing
+     * for the same reason the real one never rejects: a caller awaiting a
+     * dispatch is awaiting side effects it does not name, and under a fake there
+     * are none to fail.
+     */
+    dispatchAndWait(event: Event, args?: readonly unknown[]): Promise<void>;
+    /**
+     * Puts the container back the way it was found.
+     *
+     * Restoring the *previous* instance rather than forgetting unconditionally:
+     * an application that had already resolved its `EventManager` — one that
+     * booted, discovered listeners and registered synthetic jobs with the queue —
+     * must get that same object back, not a second one built from the config
+     * slice with an empty registry and no jobs behind it.
+     *
+     * When there was none, the binding is forgotten instead, so the container's
+     * lazy singleton factory builds the real manager on next use.
+     *
+     * Calling it twice is harmless. Not calling it is the failure this method
+     * exists for: the fake stays in the container for every test after this one,
+     * and every listener in them silently does not run.
+     */
+    restore(): void;
+    /**
+     * Fails unless the event was dispatched at least once, optionally matching a
+     * predicate.
+     *
+     * The predicate takes the event instance and is typed off the class passed
+     * in, so `(e) => e.email` is checked against `UserRegistered` without a cast.
+     *
+     * Matched **by declared name**, never by class identity — the rule the whole
+     * subsystem is keyed on. A test importing its event from the same file as the
+     * code under test would not notice the difference; one asserting against a
+     * production build's bundled class would find `instanceof` false and this
+     * true, and this is the one that is right.
+     */
+    assertDispatched<T extends EventClass>(event: T, predicate?: (event: InstanceType<T>) => boolean): void;
+    /**
+     * Fails if the event was dispatched at all, or — with a predicate — if any
+     * dispatch of it matched.
+     *
+     * The predicate form is the useful one: "a welcome email is not sent to an
+     * invited user" is an assertion about one dispatch among several, and
+     * asserting the event never fired at all would be a stronger claim than the
+     * test means.
+     */
+    assertNotDispatched<T extends EventClass>(event: T, predicate?: (event: InstanceType<T>) => boolean): void;
+    /**
+     * Fails unless the event was dispatched exactly `times` times.
+     *
+     * Worth having beside `assertDispatched` because the failure it catches is
+     * the one that assertion cannot see: a dispatch that moved inside a loop, or
+     * a controller that fires the same event on both branches of a retry. "At
+     * least once" passes for all of those.
+     */
+    assertDispatchedTimes<T extends EventClass>(event: T, times: number, predicate?: (event: InstanceType<T>) => boolean): void;
+    /**
+     * Fails if anything at all was dispatched.
+     *
+     * The assertion for a path that should be inert — a request rejected by
+     * validation, an idempotent write that found nothing to do — where naming the
+     * events not to expect would mean listing every event the app has.
+     */
+    assertNothingDispatched(): void;
+    /** Recorded dispatches of `name`, narrowed by `predicate` when there is one. */
+    private matching;
+    /**
+     * The tail of a failure message: what *was* dispatched.
+     *
+     * Three cases, because they send the reader to three different places. An
+     * empty recorder means the code under test dispatched nothing — look at the
+     * controller. Dispatches of the same name that failed a predicate means the
+     * payload is not what the test expected, and printing them is usually the
+     * whole answer. Anything else means the wrong event, or none.
+     */
+    private summary;
+}
+//# sourceMappingURL=FakeEventManager.d.ts.map

package/dist/services/events/FakeEventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeEventManager.d.ts","sourceRoot":"","sources":["../../../services/events/FakeEventManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;IA4C9C,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IA5C3B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,eAAe,EAAE,CAAM;IAE5C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB;IAY1D,OAAO;IAYP,6EAA6E;IACpE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAIhE;;;;;OAKG;IACY,eAAe,CAC5B,KAAK,EAAE,KAAK,EACZ,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,GACxB,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,IAAI,IAAI;IAQf;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,CAAC,SAAS,UAAU,EACnC,KAAK,EAAE,CAAC,EACR,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,GAC9C,IAAI;IAUP;;;;;;;;OAQG;IACH,mBAAmB,CAAC,CAAC,SAAS,UAAU,EACtC,KAAK,EAAE,CAAC,EACR,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,GAC9C,IAAI;IAYP;;;;;;;OAOG;IACH,qBAAqB,CAAC,CAAC,SAAS,UAAU,EACxC,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,GAC9C,IAAI;IAYP;;;;;;OAMG;IACH,uBAAuB,IAAI,IAAI;IAY/B,gFAAgF;IAChF,OAAO,CAAC,QAAQ;IAWhB;;;;;;;;OAQG;IACH,OAAO,CAAC,OAAO;CAUhB"}

package/dist/services/events/FakeEventManager.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FakeEventManager.test-d.d.ts.map

package/dist/services/events/FakeEventManager.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeEventManager.test-d.d.ts","sourceRoot":"","sources":["../../../services/events/FakeEventManager.test-d.ts"],"names":[],"mappings":""}