@cratis/chronicle 0.0.1

package/Projections/modelBound/removedWithJoin.ts

@@ -0,0 +1,55 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types';
+
+/** Metadata stored by the removedWithJoin class or property decorator. */
+export interface RemovedWithJoinMetadata {
+    /** The event constructor that triggers removal via a join. */
+    readonly eventType: Function;
+    /** The event property name that identifies the instance to remove. Defaults to the event source identifier. */
+    readonly key?: string;
+}
+
+const CLASS_METADATA_KEY = 'chronicle:projection:removedWithJoin:class';
+const PROPERTY_METADATA_KEY = 'chronicle:projection:removedWithJoin:property';
+
+/**
+ * Class or property decorator that specifies the event type that removes a read model instance or child via a join.
+ * @param eventType - The event constructor.
+ * @param key - Optional event property name used as the key to identify the instance to remove.
+ * @returns A class and property decorator.
+ */
+export function removedWithJoin(eventType: Function, key?: string): ClassDecorator & PropertyDecorator {
+    return (target: object, propertyKey?: string | symbol) => {
+        if (propertyKey !== undefined) {
+            const propKey = propertyKey.toString();
+            TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, propKey);
+            const existing: RemovedWithJoinMetadata[] = Reflect.getMetadata(PROPERTY_METADATA_KEY, target, propKey) ?? [];
+            Reflect.defineMetadata(PROPERTY_METADATA_KEY, [...existing, { eventType, key }], target, propKey);
+        } else {
+            const existing: RemovedWithJoinMetadata[] = Reflect.getMetadata(CLASS_METADATA_KEY, target) ?? [];
+            Reflect.defineMetadata(CLASS_METADATA_KEY, [...existing, { eventType, key }], target);
+        }
+    };
+}
+
+/**
+ * Retrieves removedWithJoin metadata stored on the given class constructor.
+ * @param target - The class constructor.
+ * @returns An array of removedWithJoin metadata entries.
+ */
+export function getRemovedWithJoinClassMetadata(target: Function): RemovedWithJoinMetadata[] {
+    return Reflect.getMetadata(CLASS_METADATA_KEY, target) ?? [];
+}
+
+/**
+ * Retrieves removedWithJoin metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns An array of removedWithJoin metadata entries.
+ */
+export function getRemovedWithJoinPropertyMetadata(target: object, propertyKey: string): RemovedWithJoinMetadata[] {
+    return Reflect.getMetadata(PROPERTY_METADATA_KEY, target, propertyKey) ?? [];
+}

package/Projections/modelBound/setFrom.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types';
+
+/** Metadata stored by the setFrom property decorator. */
+export interface SetFromMetadata {
+    /** The event constructor associated with this annotation. */
+    readonly eventType: Function;
+    /** The event property name to read the value from. Defaults to the decorated property name. */
+    readonly eventPropertyName?: string;
+}
+
+const METADATA_KEY = 'chronicle:projection:setFrom';
+
+/**
+ * Property decorator that maps an event property value onto the decorated read model property.
+ * @param eventType - The event constructor.
+ * @param eventPropertyName - Optional event property name. Defaults to the property name.
+ * @returns A property decorator.
+ */
+export function setFrom(eventType: Function, eventPropertyName?: string): PropertyDecorator {
+    return (target: object, propertyKey: string | symbol) => {
+        const key = propertyKey.toString();
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
+        const existing: SetFromMetadata[] = Reflect.getMetadata(METADATA_KEY, target, key) ?? [];
+        const metadata: SetFromMetadata = { eventType, eventPropertyName };
+        Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, key);
+    };
+}
+
+/**
+ * Retrieves all setFrom metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns An array of setFrom metadata entries.
+ */
+export function getSetFromMetadata(target: object, propertyKey: string): SetFromMetadata[] {
+    return Reflect.getMetadata(METADATA_KEY, target, propertyKey) ?? [];
+}

package/Projections/modelBound/setFromContext.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types';
+
+/** Metadata stored by the setFromContext property decorator. */
+export interface SetFromContextMetadata {
+    /** The event constructor associated with this annotation. */
+    readonly eventType: Function;
+    /** The event context property name to read the value from. Defaults to the decorated property name. */
+    readonly contextPropertyName?: string;
+}
+
+const METADATA_KEY = 'chronicle:projection:setFromContext';
+
+/**
+ * Property decorator that maps a value from an event context property onto the decorated read model property.
+ * @param eventType - The event constructor.
+ * @param contextPropertyName - Optional event context property name. Defaults to the property name.
+ * @returns A property decorator.
+ */
+export function setFromContext(eventType: Function, contextPropertyName?: string): PropertyDecorator {
+    return (target: object, propertyKey: string | symbol) => {
+        const key = propertyKey.toString();
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
+        const existing: SetFromContextMetadata[] = Reflect.getMetadata(METADATA_KEY, target, key) ?? [];
+        const metadata: SetFromContextMetadata = { eventType, contextPropertyName };
+        Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, key);
+    };
+}
+
+/**
+ * Retrieves all setFromContext metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns An array of setFromContext metadata entries.
+ */
+export function getSetFromContextMetadata(target: object, propertyKey: string): SetFromContextMetadata[] {
+    return Reflect.getMetadata(METADATA_KEY, target, propertyKey) ?? [];
+}

package/Projections/modelBound/setValue.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types';
+
+/** Metadata stored by the setValue property decorator. */
+export interface SetValueMetadata {
+    /** The event constructor that triggers the value assignment. */
+    readonly eventType: Function;
+    /** The constant value to assign to the property when the event occurs. */
+    readonly value: unknown;
+}
+
+const METADATA_KEY = 'chronicle:projection:setValue';
+
+/**
+ * Property decorator that sets the decorated read model property to a constant value when the specified event occurs.
+ * @param eventType - The event constructor.
+ * @param value - The constant value to assign.
+ * @returns A property decorator.
+ */
+export function setValue(eventType: Function, value: unknown): PropertyDecorator {
+    return (target: object, propertyKey: string | symbol) => {
+        const key = propertyKey.toString();
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
+        const existing: SetValueMetadata[] = Reflect.getMetadata(METADATA_KEY, target, key) ?? [];
+        const metadata: SetValueMetadata = { eventType, value };
+        Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, key);
+    };
+}
+
+/**
+ * Retrieves all setValue metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns An array of setValue metadata entries.
+ */
+export function getSetValueMetadata(target: object, propertyKey: string): SetValueMetadata[] {
+    return Reflect.getMetadata(METADATA_KEY, target, propertyKey) ?? [];
+}

package/Projections/modelBound/subtractFrom.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types';
+
+/** Metadata stored by the subtractFrom property decorator. */
+export interface SubtractFromMetadata {
+    /** The event constructor associated with this annotation. */
+    readonly eventType: Function;
+    /** The event property name whose value is subtracted from the read model property. Defaults to the decorated property name. */
+    readonly eventPropertyName?: string;
+}
+
+const METADATA_KEY = 'chronicle:projection:subtractFrom';
+
+/**
+ * Property decorator that subtracts an event property value from the decorated read model property.
+ * @param eventType - The event constructor.
+ * @param eventPropertyName - Optional event property name. Defaults to the property name.
+ * @returns A property decorator.
+ */
+export function subtractFrom(eventType: Function, eventPropertyName?: string): PropertyDecorator {
+    return (target: object, propertyKey: string | symbol) => {
+        const key = propertyKey.toString();
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
+        const existing: SubtractFromMetadata[] = Reflect.getMetadata(METADATA_KEY, target, key) ?? [];
+        const metadata: SubtractFromMetadata = { eventType, eventPropertyName };
+        Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, key);
+    };
+}
+
+/**
+ * Retrieves all subtractFrom metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns An array of subtractFrom metadata entries.
+ */
+export function getSubtractFromMetadata(target: object, propertyKey: string): SubtractFromMetadata[] {
+    return Reflect.getMetadata(METADATA_KEY, target, propertyKey) ?? [];
+}

package/README.md

@@ -0,0 +1,69 @@
+# Chronicle TypeScript Client
+
+A TypeScript-idiomatic client for [Cratis Chronicle](https://github.com/Cratis/Chronicle) — the open source event-sourcing kernel.
+
+## Overview
+
+`@cratis/chronicle` provides a clean, type-safe TypeScript API for interacting with the Chronicle Kernel. It builds on top of [`@cratis/chronicle.contracts`](https://www.npmjs.com/package/@cratis/chronicle.contracts) (the gRPC contracts package) and exposes idiomatic TypeScript constructs including:
+
+- **Decorators** — `@eventType`, `@readModel`, `@reactor`, `@reducer`, `@constraint`, `@projection`, `@modelBoundProjection`
+- **Value objects** — `EventSequenceNumber`, `EventTypeId`, `EventStoreName`, etc.
+- **Fluent client** — `ChronicleClient` → `EventStore` → `EventLog` → `append()`
+
+## Structure
+
+```
+Source/          ← @cratis/chronicle TypeScript library
+Documentation/   ← User-facing documentation
+Samples/
+  Console/       ← Plain Node.js console sample application
+```
+
+## Prerequisite: Chronicle Running
+
+You need a Chronicle Kernel available before running samples or application code.
+
+The easiest local setup is the development Docker image:
+
+```bash
+docker run -p 35000:35000 -p 8080:8080 cratis/chronicle:latest-development
+```
+
+## Getting Started
+
+See [Documentation/getting-started.md](./Documentation/getting-started.md) for installation and usage instructions.
+
+## Quick Example
+
+```typescript
+import 'reflect-metadata';
+import { ChronicleClient, ChronicleOptions, eventType } from '@cratis/chronicle';
+
+@eventType()
+class EmployeeHired {
+    constructor(readonly firstName: string, readonly lastName: string) {}
+}
+
+const client = new ChronicleClient(ChronicleOptions.development());
+const store = await client.getEventStore('MyStore');
+const result = await store.eventLog.append('employee-123', new EmployeeHired('Jane', 'Doe'));
+console.log(`Appended at sequence number ${result.sequenceNumber.value}`);
+client.dispose();
+```
+
+## Building
+
+```bash
+yarn install
+yarn workspace @cratis/chronicle compile
+```
+
+## Running the Console Sample
+
+```bash
+yarn install
+yarn workspace @cratis/chronicle-test-console build
+yarn workspace @cratis/chronicle-test-console start
+```
+
+Set the `CHRONICLE_CONNECTION` environment variable to override the default connection string (`chronicle://localhost:35000`).

package/Reactors/IReactors.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Defines a system to work with reactors, including discovery and registration with the Kernel.
+ */
+export interface IReactors {
+    /**
+     * Discovers all reactors from the registered client artifacts.
+     * @returns A promise that resolves when discovery is complete.
+     */
+    discover(): Promise<void>;
+
+    /**
+     * Registers all discovered reactors with the Chronicle Kernel and starts observation.
+     * @returns A promise that resolves when registration is complete.
+     */
+    register(): Promise<void>;
+}

package/Reactors/ReactorId.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Unique identifier for a reactor.
+ */
+export class ReactorId {
+    constructor(readonly value: string) {}
+
+    /** @inheritdoc */
+    toString(): string {
+        return this.value;
+    }
+}

package/Reactors/Reactors.ts

@@ -0,0 +1,320 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { diag } from '@opentelemetry/api';
+import { Constructor } from '@cratis/fundamentals';
+import { ObservationState, ReactorMessage } from '@cratis/chronicle.contracts';
+import { IClientArtifactsProvider } from '../artifacts';
+import { ChronicleConnection } from '../connection';
+import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
+import { getEventTypeMetadata } from '../Events/eventTypeDecorator';
+import { EventContext } from '../Events/EventContext';
+import { EventTypeId } from '../Events/EventTypeId';
+import { EventTypeGeneration } from '../Events/EventTypeGeneration';
+import { EventSequenceId } from '../EventSequences/EventSequenceId';
+import { IReactors } from './IReactors';
+import { getReactorMetadata } from './reactor';
+
+/** Expression used to partition reactor observations by event source ID. */
+const EVENT_SOURCE_ID_KEY = '$eventSourceId';
+
+/** Sentinel sequence number sent back when no event was successfully processed. */
+const SEQUENCE_NUMBER_UNAVAILABLE = 4294967295;
+
+interface EventTypeEntry {
+    readonly id: string;
+    readonly generation: number;
+    readonly methodName: string;
+}
+
+/**
+ * A push-based async queue that implements {@link AsyncIterable} for use with nice-grpc
+ * bidirectional streaming. Values pushed via {@link send} are yielded in order to
+ * any consumer that iterates the queue.
+ */
+class AsyncQueue<T> {
+    private readonly _queue: T[] = [];
+    private _resolve: ((result: IteratorResult<T, undefined>) => void) | undefined = undefined;
+    private _done = false;
+
+    /** Pushes a value into the queue. No-op if the queue has been completed. */
+    send(value: T): void {
+        if (this._done) return;
+        if (this._resolve) {
+            const resolve = this._resolve;
+            this._resolve = undefined;
+            resolve({ value, done: false });
+        } else {
+            this._queue.push(value);
+        }
+    }
+
+    /** Signals that no more values will be pushed, causing consumers to finish iteration. */
+    complete(): void {
+        this._done = true;
+        if (this._resolve) {
+            this._resolve({ value: undefined, done: true });
+            this._resolve = undefined;
+        }
+    }
+
+    [Symbol.asyncIterator](): AsyncIterator<T, undefined> {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return {
+            next(): Promise<IteratorResult<T, undefined>> {
+                if (self._queue.length > 0) {
+                    return Promise.resolve({ value: self._queue.shift()!, done: false });
+                }
+                if (self._done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise(resolve => {
+                    self._resolve = resolve as (result: IteratorResult<T, undefined>) => void;
+                });
+            },
+            return(): Promise<IteratorResult<T, undefined>> {
+                self._done = true;
+                if (self._resolve) {
+                    self._resolve({ value: undefined, done: true });
+                    self._resolve = undefined;
+                }
+                return Promise.resolve({ value: undefined, done: true });
+            }
+        };
+    }
+}
+
+/**
+ * Implements {@link IReactors}, managing discovery and registration of reactors
+ * with the Chronicle Kernel via bidirectional gRPC streaming.
+ */
+export class Reactors implements IReactors {
+    private readonly _logger = diag.createComponentLogger({ namespace: '@cratis/chronicle/Reactors' });
+    private readonly _lifecycle: ConnectionLifecycle;
+    private readonly _reactors = new Map<string, Constructor>();
+    private readonly _queues = new Map<string, AsyncQueue<ReactorMessage>>();
+    private _registered = false;
+
+    /**
+     * Creates a new {@link Reactors} instance.
+     * @param _clientArtifacts - Provider for discovered client artifact types.
+     * @param _connection - The Chronicle gRPC connection.
+     * @param _eventStoreName - The name of the event store.
+     * @param _namespace - The namespace within the event store.
+     * @param lifecycle - The connection lifecycle used to react to disconnect events.
+     */
+    constructor(
+        private readonly _clientArtifacts: IClientArtifactsProvider,
+        private readonly _connection: ChronicleConnection,
+        private readonly _eventStoreName: string,
+        private readonly _namespace: string,
+        lifecycle: ConnectionLifecycle
+    ) {
+        this._lifecycle = lifecycle;
+        lifecycle.onDisconnected(async () => {
+            this._logger.info('Disconnected — stopping all reactor observations');
+            this._registered = false;
+            this.disconnectAll();
+        });
+    }
+
+    /** @inheritdoc */
+    async discover(): Promise<void> {
+        this._reactors.clear();
+        for (const type of this._clientArtifacts.reactors) {
+            const metadata = getReactorMetadata(type);
+            if (metadata) {
+                this._reactors.set(metadata.id.value, type);
+                this._logger.debug('Discovered reactor', { reactorId: metadata.id.value, type: (type as Function).name });
+            }
+        }
+    }
+
+    /** @inheritdoc */
+    async register(): Promise<void> {
+        if (this._registered) {
+            return;
+        }
+
+        if (this._reactors.size === 0) {
+            await this.discover();
+        }
+
+        this._logger.info('Registering reactors', { count: this._reactors.size });
+        for (const [id, reactorType] of this._reactors) {
+            this.startObservation(id, reactorType);
+        }
+
+        this._registered = true;
+    }
+
+    private startObservation(id: string, reactorType: Constructor): void {
+        const metadata = getReactorMetadata(reactorType)!;
+        const eventSequenceId = metadata.eventSequenceId ?? EventSequenceId.eventLog.value;
+        const eventTypes = this.getEventTypesFor(reactorType);
+
+        this._logger.info('Starting reactor observation', {
+            reactorId: id,
+            eventSequenceId,
+            handlerCount: eventTypes.length,
+            handlers: eventTypes.map(e => e.methodName)
+        });
+
+        this.observeReactor(id, reactorType, eventSequenceId, eventTypes).catch(err => {
+            this._logger.error('Reactor observation loop exited with error', { reactorId: id, error: String(err) });
+        });
+    }
+
+    private async observeReactor(
+        id: string,
+        reactorType: Constructor,
+        eventSequenceId: string,
+        eventTypes: EventTypeEntry[]
+    ): Promise<void> {
+        const queue = new AsyncQueue<ReactorMessage>();
+        this._queues.set(id, queue);
+
+        queue.send({
+            Content: {
+                Value0: {
+                    ConnectionId: this._lifecycle.connectionId,
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    Reactor: {
+                        ReactorId: id,
+                        EventSequenceId: eventSequenceId,
+                        EventTypes: eventTypes.map(et => ({
+                            EventType: { Id: et.id, Generation: et.generation, Tombstone: false },
+                            Key: EVENT_SOURCE_ID_KEY
+                        })),
+                        IsReplayable: false,
+                        Tags: [],
+                        Filters: {
+                            FilterTags: [],
+                            EventSourceType: '',
+                            EventStreamType: 'All'
+                        }
+                    }
+                },
+                Value1: undefined
+            }
+        });
+
+        try {
+            const reactorInstance = new (reactorType as new () => Record<string, Function>)();
+
+            for await (const eventsToObserve of this._connection.reactors.observe(queue)) {
+                let lastSuccessfullyObservedEvent = SEQUENCE_NUMBER_UNAVAILABLE;
+                let state = ObservationState.Success;
+                const exceptionMessages: string[] = [];
+                let exceptionStackTrace = '';
+
+                this._logger.debug('Received events to observe', {
+                    reactorId: id,
+                    partition: eventsToObserve.Partition,
+                    count: eventsToObserve.Events.length
+                });
+
+                for (const event of eventsToObserve.Events) {
+                    try {
+                        const eventTypeId = event.Context?.EventType?.Id;
+                        if (!eventTypeId) {
+                            this._logger.warn('Event missing event type context', { reactorId: id });
+                            continue;
+                        }
+
+                        const entry = eventTypes.find(et => et.id === eventTypeId);
+                        if (!entry) {
+                            this._logger.debug('No handler registered for event type — skipping', { reactorId: id, eventTypeId });
+                            lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
+                            continue;
+                        }
+
+                        const content = JSON.parse(event.Content) as Record<string, unknown>;
+                        const context: EventContext = {
+                            sequenceNumber: event.Context!.SequenceNumber,
+                            eventSourceId: event.Context!.EventSourceId,
+                            eventType: {
+                                id: new EventTypeId(event.Context!.EventType!.Id),
+                                generation: new EventTypeGeneration(event.Context!.EventType!.Generation),
+                                tombstone: event.Context!.EventType!.Tombstone
+                            },
+                            occurred: new Date(event.Context!.Occurred?.Value ?? ''),
+                            correlationId: event.Context?.CorrelationId ? `${event.Context.CorrelationId.lo}-${event.Context.CorrelationId.hi}` : '',
+                            causation: []
+                        };
+
+                        this._logger.info('Invoking reactor handler', {
+                            reactorId: id,
+                            method: entry.methodName,
+                            sequenceNumber: event.Context!.SequenceNumber,
+                            eventTypeId
+                        });
+
+                        await reactorInstance[entry.methodName](content, context);
+                        lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
+                    } catch (err) {
+                        this._logger.error('Error handling event in reactor', { reactorId: id, error: String(err) });
+                        exceptionMessages.push(String(err));
+                        exceptionStackTrace = err instanceof Error ? (err.stack ?? '') : '';
+                        state = ObservationState.Failed;
+                        break;
+                    }
+                }
+
+                queue.send({
+                    Content: {
+                        Value0: undefined,
+                        Value1: {
+                            Partition: eventsToObserve.Partition,
+                            State: state,
+                            LastSuccessfulObservation: lastSuccessfullyObservedEvent,
+                            ExceptionMessages: exceptionMessages,
+                            ExceptionStackTrace: exceptionStackTrace
+                        }
+                    }
+                });
+            }
+        } catch (err) {
+            if (!this._queues.has(id)) {
+                this._logger.debug('Reactor observation stream closed cleanly', { reactorId: id });
+            } else {
+                this._logger.error('Reactor observation stream ended unexpectedly', { reactorId: id, error: String(err) });
+            }
+        } finally {
+            this._queues.delete(id);
+        }
+    }
+
+    private getEventTypesFor(reactorType: Constructor): EventTypeEntry[] {
+        const proto = reactorType.prototype as Record<string, unknown>;
+        const entries: EventTypeEntry[] = [];
+
+        for (const eventTypeClass of this._clientArtifacts.eventTypes) {
+            const eventTypeMeta = getEventTypeMetadata(eventTypeClass);
+            if (!eventTypeMeta) continue;
+
+            const className = (eventTypeClass as Function).name;
+            const methodName = className.charAt(0).toLowerCase() + className.slice(1);
+
+            if (typeof proto[methodName] === 'function') {
+                entries.push({
+                    id: eventTypeMeta.eventType.id.value,
+                    generation: eventTypeMeta.eventType.generation.value,
+                    methodName
+                });
+            }
+        }
+
+        return entries;
+    }
+
+    private disconnectAll(): void {
+        for (const queue of this._queues.values()) {
+            queue.complete();
+        }
+        this._queues.clear();
+    }
+}

package/Reactors/index.ts

@@ -0,0 +1,8 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { ReactorId } from './ReactorId';
+export { reactor, getReactorMetadata, isReactor } from './reactor';
+export type { ReactorMetadata } from './reactor';
+export type { IReactors } from './IReactors';
+export { Reactors } from './Reactors';