@cratis/chronicle 6.13.0 → 6.14.1

package/dist/types/modelBoundPropertyMetadata.js

@@ -0,0 +1,66 @@
+// 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 { getStandardMetadata } from './standardDecoratorMetadata.js';
+// The standard field decorator has no constructor, but its metadata object is attached to
+// the declaring class after evaluation. Discovery can match that object to a module export.
+const mappedMetadata = new WeakMap();
+const pendingMetadata = new Set();
+const finalizedMetadata = new FinalizationRegistry(reference => pendingMetadata.delete(reference));
+export const modelBoundPropertyKeys = [
+    'setFrom', 'setFromContext', 'setValue', 'addFrom', 'subtractFrom',
+    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll'
+].map(name => `chronicle:projection:${name}`);
+/** Records a standard-decorated class with an event mapping on one of its fields. */
+export function trackModelBoundMetadata(metadata, property) {
+    if (!modelBoundPropertyKeys.some(key => Reflect.hasOwnMetadata(key, metadata, property)))
+        return;
+    let properties = mappedMetadata.get(metadata);
+    if (!properties) {
+        properties = new Set();
+        mappedMetadata.set(metadata, properties);
+        const reference = new WeakRef(metadata);
+        pendingMetadata.add(reference);
+        finalizedMetadata.register(metadata, reference, reference);
+    }
+    properties.add(property);
+}
+/** Whether a class's standard decorator metadata contains a mapped property. */
+export function hasModelBoundMetadata(metadata) {
+    return mappedMetadata.has(metadata);
+}
+/** Returns unresolved mappings grouped by class metadata, dropping resolved and collected entries. */
+export function takeUnregisteredModelBoundMappings(registeredTypes) {
+    const registeredMetadata = new Set();
+    for (const type of registeredTypes) {
+        for (let metadata = getStandardMetadata(type); metadata; metadata = Object.getPrototypeOf(metadata)) {
+            registeredMetadata.add(metadata);
+        }
+    }
+    const unmapped = [];
+    for (const reference of pendingMetadata) {
+        const metadata = reference.deref();
+        pendingMetadata.delete(reference);
+        finalizedMetadata.unregister(reference);
+        if (!metadata || registeredMetadata.has(metadata))
+            continue;
+        const mappingsForClass = new Set();
+        for (const property of mappedMetadata.get(metadata) ?? []) {
+            for (const key of modelBoundPropertyKeys) {
+                const value = Reflect.getOwnMetadata(key, metadata, property);
+                if (value === undefined)
+                    continue;
+                const mappings = Array.isArray(value) ? value : [value];
+                for (const mapping of mappings) {
+                    const eventType = mapping && typeof mapping === 'object' && 'eventType' in mapping ? mapping.eventType : undefined;
+                    const eventName = typeof eventType === 'function' ? eventType.name : 'all events';
+                    mappingsForClass.add(`${property} <- ${eventName}`);
+                }
+            }
+        }
+        if (mappingsForClass.size > 0)
+            unmapped.push(`{${[...mappingsForClass].join(', ')}}`);
+    }
+    return unmapped;
+}
+//# sourceMappingURL=modelBoundPropertyMetadata.js.map

package/dist/types/modelBoundPropertyMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelBoundPropertyMetadata.js","sourceRoot":"","sources":["../../types/modelBoundPropertyMetadata.ts"],"names":[],"mappings":"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"}

package/for_ChronicleClient/when_registering_artifacts/with_legacy_property_mappings.legacy.spec.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describe, expect, it, vi } from 'vitest';
+import { ChronicleClient } from '../../ChronicleClient.js';
+import { ChronicleOptions } from '../../ChronicleOptions.js';
+import type { EventStore } from '../../EventStore.js';
+import { setFrom } from '../../projections/modelBound/setFrom.js';
+
+class Changed {}
+
+class Legacy {
+    @setFrom(Changed) value = '';
+}
+
+describe('when registering artifacts with legacy property mappings', () => {
+    it('should not warn for the model registered on import', async () => {
+        const client = new ChronicleClient(ChronicleOptions.fromConnectionString('chronicle://localhost:35000', { discoveryPatterns: [] }));
+        const warn = vi.spyOn(client['_logger'], 'warn');
+        const store = {
+            name: { value: 'store' }, namespace: { value: 'Default' }, registerArtifacts: vi.fn().mockResolvedValue(undefined)
+        } as unknown as EventStore;
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+            expect(Legacy).toBeDefined();
+        } finally {
+            client.dispose();
+        }
+    });
+});

package/for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts

@@ -0,0 +1,138 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ChronicleClient } from '../../ChronicleClient.js';
+import { ChronicleOptions } from '../../ChronicleOptions.js';
+import type { EventStore } from '../../EventStore.js';
+import { childrenFrom } from '../../projections/modelBound/childrenFrom.js';
+import { fromEvent } from '../../projections/modelBound/fromEvent.js';
+import { setFrom } from '../../projections/modelBound/setFrom.js';
+import { DecoratorType } from '../../types/DecoratorType.js';
+import { TypeDiscoverer } from '../../types/TypeDiscoverer.js';
+
+class Changed {}
+
+function createClient() {
+    const client = new ChronicleClient(ChronicleOptions.fromConnectionString('chronicle://localhost:35000', { discoveryPatterns: [] }));
+    const warn = vi.spyOn(client['_logger'], 'warn');
+    const registerArtifacts = vi.fn().mockResolvedValue(undefined);
+    const store = { name: { value: 'store' }, namespace: { value: 'Default' }, registerArtifacts } as unknown as EventStore;
+    return { client, warn, store, registerArtifacts };
+}
+
+afterEach(() => {
+    TypeDiscoverer.default.clear();
+});
+
+describe('when registering artifacts with standard property mappings', () => {
+    it('should warn once about orphan mappings with their property and event type', async () => {
+        const discoverer = new TypeDiscoverer(async () => ['model.ts'], async () => {
+            class Orphan {
+                @setFrom(Changed) value = '';
+                @setFrom(Changed) name = '';
+            }
+            class OtherOrphan { @setFrom(Changed) value = ''; }
+            void Orphan;
+            void OtherOrphan;
+            return {};
+        });
+        await discoverer.discover('model.ts');
+        const { client, warn, store, registerArtifacts } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).toHaveBeenCalledTimes(1);
+            expect(warn.mock.calls[0][0]).toContain('{value <- Changed, name <- Changed}, {value <- Changed}');
+            expect(warn.mock.calls[0][0]).toContain('@fromEvent(...)');
+            expect(warn.mock.calls[0][0]).toContain('discoveryPatterns');
+            expect(warn.mock.calls[0][0]).toContain('register the class explicitly');
+            expect(registerArtifacts).toHaveBeenCalledTimes(2);
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should not warn after the first instance registers the model before store creation', async () => {
+        class Constructed { @setFrom(Changed) value = ''; }
+        new Constructed();
+        const { client, warn, store } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should not warn for a discovered export', async () => {
+        class Discovered { @setFrom(Changed) value = ''; }
+        const discoverer = new TypeDiscoverer(async () => ['model.ts'], async () => ({ Discovered }));
+        await discoverer.discover('model.ts');
+        const { client, warn, store } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should not warn for an unexported base class of a discovered model', async () => {
+        class Base { @setFrom(Changed) value = ''; }
+        class Derived extends Base {}
+        const discoverer = new TypeDiscoverer(async () => ['model.ts'], async () => ({ Derived }));
+        await discoverer.discover('model.ts');
+        const { client, warn, store } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should not warn for an unexported child of a discovered model', async () => {
+        class Line { @setFrom(Changed) value = ''; }
+        class Cart {
+            @childrenFrom(Changed)
+            @field(Array, { genericArguments: [Line] })
+            lines: Line[] = [];
+        }
+        const discoverer = new TypeDiscoverer(async () => ['model.ts'], async () => ({ Cart }));
+        await discoverer.discover('model.ts');
+        const { client, warn, store } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should not warn for an explicitly registered class', async () => {
+        class Explicit { @setFrom(Changed) value = ''; }
+        TypeDiscoverer.default.register(DecoratorType.ReadModel, Explicit);
+        const { client, warn, store } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should not warn for a class-level model mapping', async () => {
+        @fromEvent(Changed)
+        class ClassMapped { @setFrom(Changed) value = ''; }
+        const { client, warn, store } = createClient();
+        try {
+            await client['registerArtifactsForStore'](store, 'new-store');
+            expect(warn).not.toHaveBeenCalled();
+            void ClassMapped;
+        } finally {
+            client.dispose();
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.13.0",
+    "version": "6.14.1",
     "description": "Event sourcing for TypeScript and Node.js — the idiomatic client for Cratis Chronicle, the open-source event-sourcing database",
     "author": "Cratis",
     "license": "MIT",
@@ -76,6 +76,11 @@
             "import": "./dist/reducers/index.js",
             "default": "./dist/reducers/index.js"
         },
+        "./testing": {
+            "types": "./dist/testing/index.d.ts",
+            "import": "./dist/testing/index.js",
+            "default": "./dist/testing/index.js"
+        },
         "./seeding": {
             "types": "./dist/seeding/index.d.ts",
             "import": "./dist/seeding/index.js",
@@ -162,7 +167,7 @@
         "build": "tsc -b",
         "clean": "rm -rf dist",
         "test": "vitest run",
-        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts",
+        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts",
         "test:native": "node ./scripts/check-native-esm.mjs"
     },
     "dependencies": {

package/projections/modelBound/decorators.standard.spec.ts

@@ -84,11 +84,11 @@ describe('standard model-bound decorators', () => {
         }
     });
 
-    it('should explain that an unconstructed property-only model was never registered', async () => {
+    it('should explain how to register an unconstructed model not exported for discovery', async () => {
         const getInstanceByKey = vi.fn().mockResolvedValue({ ReadModel: '{"value":"stored"}' });
         const connection = { readModels: { getInstanceByKey } } as unknown as ChronicleConnection;
         const readModels = new ReadModels('store', 'Default', connection, DefaultClientArtifactsProvider.default, 'sink');
-        await expect(readModels.findInstanceById(UnconstructedMappedOnly, 'id')).rejects.toThrow(/add a class-level @fromEvent/);
+        await expect(readModels.findInstanceById(UnconstructedMappedOnly, 'id')).rejects.toThrow(/register it explicitly before creating the event store/);
         expect(getInstanceByKey).not.toHaveBeenCalled();
     });
     it('stores class and property annotations without constructing an instance', () => {

package/readModels/ReadModels.ts

@@ -333,7 +333,7 @@ export class ReadModels implements IReadModels {
         const neverRegistered = resolved?.isModelBound && this._isModelBoundProjectionRegistered && !this._isModelBoundProjectionRegistered(readModelType);
         if (!resolved || neverRegistered) {
             throw new Error(hasModelBoundProperties(readModelType)
-                ? `Unknown read model '${readModelType.name}'. It has model-bound property mappings but was not registered when the event store was created. With standard decorators, a class whose mappings are all on properties is only registered once an instance exists; add a class-level @fromEvent(...) decorator so it registers when its module loads.`
+                ? `Unknown read model '${readModelType.name}'. It has model-bound property mappings but was not registered when the event store was created. Export the class from a module matched by discoveryPatterns, or register it explicitly before creating the event store.`
                 : `Unknown read model '${readModelType.name}'. Make sure it is discoverable through a projection, reducer, or model-bound mapping.`);
         }
         return resolved;

package/readModels/discovery.spec.ts

@@ -82,7 +82,7 @@ describe('when discovering read models from observers', () => {
         setFrom(Event)(RegisteredLate.prototype, 'value');
         const { connection } = createConnection();
         const readModels = new ReadModels('store', 'Default', connection, DefaultClientArtifactsProvider.default, 'sink', () => false);
-        await expect(readModels.findInstanceById(RegisteredLate, 'key')).rejects.toThrow(/add a class-level @fromEvent/);
+        await expect(readModels.findInstanceById(RegisteredLate, 'key')).rejects.toThrow(/register it explicitly before creating the event store/);
     });
 
     it('should explain how to register an unregistered property-bound model', async () => {
@@ -91,7 +91,7 @@ describe('when discovering read models from observers', () => {
         Reflect.defineMetadata('chronicle:typeIntrospection:properties', ['value'], NeverRegistered);
         const { connection } = createConnection();
         await expect(new ReadModels('store', 'Default', connection, DefaultClientArtifactsProvider.default, 'sink').findInstanceById(NeverRegistered, 'key'))
-            .rejects.toThrow(/add a class-level @fromEvent/);
+            .rejects.toThrow(/register it explicitly before creating the event store/);
     });
 
     it('should deduplicate inferred types and retain custom identifiers', async () => {

package/readModels/registration.legacy.spec.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { describe, expect, it, vi } from 'vitest';
+import { DefaultClientArtifactsProvider } from '../artifacts/DefaultClientArtifactsProvider.js';
+import type { ChronicleConnection } from '../connection/ChronicleConnection.js';
+import { eventType } from '../events/eventTypeDecorator.js';
+import { setFrom } from '../projections/modelBound/setFrom.js';
+import { Projections } from '../projections/Projections.js';
+
+@eventType('legacy-cold-registration-event')
+class Changed { @field(String) value!: string; }
+
+let constructions = 0;
+class LegacyPropertyOnly {
+    @setFrom(Changed)
+    @field(String)
+    value = '';
+
+    constructor() { constructions++; }
+}
+
+describe('when registering a legacy-decorated property-only read model', () => {
+    it('should discover and register it without constructing an instance first', async () => {
+        expect(constructions).toBe(0);
+        const provider = DefaultClientArtifactsProvider.default;
+        expect(provider.readModels).toContain(LegacyPropertyOnly);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+
+        expect(registerMany.mock.calls[0][0].ReadModels.some((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'LegacyPropertyOnly')).toBe(true);
+        expect(register.mock.calls.some(call => call[0].Projections[0].ReadModel === 'LegacyPropertyOnly')).toBe(true);
+    });
+});

package/readModels/registration.standard.spec.ts

@@ -0,0 +1,108 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { describe, expect, it, vi } from 'vitest';
+import { DefaultClientArtifactsProvider } from '../artifacts/DefaultClientArtifactsProvider.js';
+import type { ChronicleConnection } from '../connection/ChronicleConnection.js';
+import { eventType } from '../events/eventTypeDecorator.js';
+import { Projections } from '../projections/Projections.js';
+import { setFrom } from '../projections/modelBound/setFrom.js';
+import { DecoratorType } from '../types/DecoratorType.js';
+import { TypeDiscoverer } from '../types/TypeDiscoverer.js';
+import { ReadModels } from './ReadModels.js';
+
+@eventType('cold-registration-event')
+class Changed { @field(String) value!: string; }
+
+let constructions = 0;
+class PropertyOnly {
+    @setFrom(Changed, 'value')
+    @field(String)
+    value = '';
+
+    constructor() { constructions++; }
+}
+
+describe('when discovering a standard-decorated property-only read model', () => {
+    it('should register and query the model before any instance has been constructed', async () => {
+        expect(constructions).toBe(0);
+        const discoverer = new TypeDiscoverer(async () => ['models.ts'], async () => ({ PropertyOnly }));
+        await discoverer.discover('models.ts');
+        expect(constructions).toBe(0);
+
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const getInstanceByKey = vi.fn().mockResolvedValue({ ReadModel: '{"value":"stored"}' });
+        const connection = { readModels: { registerMany, getInstanceByKey }, projections: { register } } as unknown as ChronicleConnection;
+        const projections = new Projections('store', 'Default', connection, provider, 'sink');
+        await projections.register();
+        const readModels = new ReadModels('store', 'Default', connection, provider, 'sink', type => projections.hasForModel(type));
+        const result = await readModels.findInstanceById(PropertyOnly, 'id');
+
+        expect(registerMany.mock.calls[0][0].ReadModels.some((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'PropertyOnly')).toBe(true);
+        expect(register.mock.calls.some(call => call[0].Projections[0].ReadModel === 'PropertyOnly')).toBe(true);
+        expect(getInstanceByKey).toHaveBeenCalledWith(expect.objectContaining({ ReadModelIdentifier: 'PropertyOnly', ReadModelKey: 'id' }));
+        expect(result?.value).toBe('stored');
+    });
+
+    it('should register an explicitly supplied model without glob discovery or construction', async () => {
+        class ExplicitModel {
+            @setFrom(Changed)
+            @field(String)
+            value = '';
+        }
+        const discoverer = new TypeDiscoverer();
+        discoverer.register(DecoratorType.ReadModel, ExplicitModel);
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+
+        expect(registerMany.mock.calls[0][0].ReadModels.some((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'ExplicitModel')).toBe(true);
+        expect(register.mock.calls.some(call => call[0].Projections[0].ReadModel === 'ExplicitModel')).toBe(true);
+    });
+
+    it('should not register the same model twice when constructed before discovery', async () => {
+        class ConstructedFirst {
+            @setFrom(Changed)
+            @field(String)
+            value = '';
+        }
+        new ConstructedFirst();
+        const discoverer = new TypeDiscoverer(async () => ['models.ts'], async () => ({ ConstructedFirst }));
+        await discoverer.discover('models.ts');
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        expect(provider.readModels.filter(type => type === ConstructedFirst)).toHaveLength(1);
+
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+
+        expect(registerMany.mock.calls[0][0].ReadModels.filter((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'ConstructedFirst')).toHaveLength(1);
+        expect(register.mock.calls.filter(call => call[0].Projections[0].ReadModel === 'ConstructedFirst')).toHaveLength(1);
+    });
+
+    it('should not register the same model again after its first construction', async () => {
+        const discoverer = new TypeDiscoverer(async () => ['models.ts'], async () => ({ PropertyOnly }));
+        await discoverer.discover('models.ts');
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+        const registered = registerMany.mock.calls.length;
+        const registeredProjections = register.mock.calls.length;
+
+        new PropertyOnly();
+        new PropertyOnly();
+
+        expect(provider.readModels.filter(type => type === PropertyOnly)).toHaveLength(1);
+        expect(registerMany).toHaveBeenCalledTimes(registered);
+        expect(register).toHaveBeenCalledTimes(registeredProjections);
+    });
+});

package/readModels/rootReadModelTypes.ts

@@ -13,8 +13,7 @@ import { isNested } from '../projections/modelBound/nested.js';
 import { getReducerMetadata } from '../reducers/reducer.js';
 import { TypeIntrospector } from '../types/TypeIntrospector.js';
 
-/** Excludes models used as children or nested objects from root projection registration. */
-export function rootReadModelTypes(artifacts: IClientArtifactsProvider): Constructor[] {
+function inspectReadModelTypes(artifacts: IClientArtifactsProvider): { models: Constructor[]; usedAsChildren: Set<Function>; visited: Set<Function> } {
     const models = artifacts.readModels;
     const usedAsChildren = new Set<Function>();
     const visited = new Set<Function>();
@@ -61,5 +60,16 @@ export function rootReadModelTypes(artifacts: IClientArtifactsProvider): Constru
         const model = getReducerMetadata(type)?.readModel;
         if (model) inspect(model);
     }
+    return { models, usedAsChildren, visited };
+}
+
+/** Excludes models used as children or nested objects from root projection registration. */
+export function rootReadModelTypes(artifacts: IClientArtifactsProvider): Constructor[] {
+    const { models, usedAsChildren } = inspectReadModelTypes(artifacts);
     return models.filter(type => !usedAsChildren.has(type));
 }
+
+/** Includes all read-model types reached from registered roots, including children and nested models. */
+export function reachableReadModelTypes(artifacts: IClientArtifactsProvider): Function[] {
+    return [...inspectReadModelTypes(artifacts).visited];
+}

package/reducers/ReducerEventDispatcher.ts

@@ -0,0 +1,47 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Constructor } from '@cratis/fundamentals';
+import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import type { EventContext } from '../events/EventContext.js';
+import type { ReducerEventHandler } from './ReducerEventHandler.js';
+
+/** Selects and invokes the same reducer handlers for kernel deliveries and in-process scenarios. */
+export class ReducerEventDispatcher {
+    readonly handlers: ReducerEventHandler[];
+
+    /** Discovers event methods from the artifact event types. */
+    constructor(reducerType: Constructor, eventTypes: readonly Constructor[]) {
+        const proto = reducerType.prototype as Record<string, unknown>;
+        this.handlers = [];
+        for (const eventTypeClass of eventTypes) {
+            const metadata = getEventTypeMetadata(eventTypeClass);
+            if (!metadata) continue;
+            const className = (eventTypeClass as Function).name;
+            const methodName = className.charAt(0).toLowerCase() + className.slice(1);
+            if (typeof proto[methodName] === 'function') {
+                this.handlers.push({
+                    id: metadata.eventType.id.value,
+                    generation: metadata.eventType.generation.value,
+                    methodName
+                });
+            }
+        }
+    }
+
+    /** Resolves a registered event type, or returns undefined for an unsubscribed event. */
+    handlerFor(eventTypeId: string): ReducerEventHandler | undefined {
+        return this.handlers.find(handler => handler.id === eventTypeId);
+    }
+
+    /** Calls the selected handler with the event, current state, and context. */
+    async invoke(
+        instance: Record<string, Function>,
+        handler: ReducerEventHandler,
+        event: unknown,
+        currentState: unknown,
+        context: EventContext
+    ): Promise<unknown> {
+        return await instance[handler.methodName](event, currentState, context) as unknown;
+    }
+}

package/reducers/ReducerEventHandler.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** Event type and camel-case method selected for a reducer observation. */
+export interface ReducerEventHandler {
+    readonly id: string;
+    readonly generation: number;
+    readonly methodName: string;
+}