@cratis/chronicle 6.34.0 → 6.36.0

package/reducers/for_ReducerEventDispatcher/when_invoking_instance_handlers.spec.ts

@@ -0,0 +1,69 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import { EventType } from '../../events/EventType.js';
+import type { EventContext } from '../../events/EventContext.js';
+import { handles } from '../index.js';
+import { ReducerEventDispatcher } from '../ReducerEventDispatcher.js';
+
+chai.should();
+
+@eventType('instance-reducer-event')
+class AuthorRegistered { constructor(readonly name: string) {} }
+
+class BoundConventional {
+    readonly prefix = 'conventional';
+    constructor() { this.authorRegistered = this.authorRegistered.bind(this); }
+    authorRegistered(event: AuthorRegistered, state: string[] | undefined, context: EventContext) {
+        return [...(state ?? []), `${this.prefix}:${event.name}:${context.eventSourceId}`];
+    }
+}
+
+class BoundExplicit {
+    readonly prefix = 'explicit';
+    constructor() { this.update = this.update.bind(this); }
+    @handles(AuthorRegistered)
+    update(event: AuthorRegistered, state: string[] | undefined, context: EventContext) {
+        return [...(state ?? []), `${this.prefix}:${event.name}:${context.eventSourceId}`];
+    }
+}
+
+class Conventional {
+    authorRegistered(event: AuthorRegistered, state: string[] | undefined, context: EventContext) {
+        return [...(state ?? []), `base:${event.name}:${context.eventSourceId}`];
+    }
+}
+
+class FieldConventional extends Conventional {
+    override authorRegistered = (event: AuthorRegistered, state: string[] | undefined, context: EventContext) =>
+        [...(state ?? []), `field:${event.name}:${context.eventSourceId}`];
+}
+
+for (const { type, prefix } of [
+    { type: BoundConventional, prefix: 'conventional' },
+    { type: BoundExplicit, prefix: 'explicit' },
+    { type: FieldConventional, prefix: 'field' }
+]) {
+    describe(`when invoking the ${prefix} reducer instance handler`, () => {
+        let result: unknown;
+        beforeEach(async () => {
+            const dispatcher = new ReducerEventDispatcher(type, [AuthorRegistered]);
+            const instance = new type();
+            dispatcher.validateInstance(instance);
+            const context: EventContext = {
+                sequenceNumber: 1n, eventSourceId: 'author', eventType: EventType.parse('instance-reducer-event'),
+                occurred: new Date(), correlationId: '', causation: [], tags: []
+            };
+            const handler = dispatcher.handlerFor('instance-reducer-event')!;
+            const initial = await dispatcher.invoke(instance as unknown as Record<string, Function>, handler,
+                new AuthorRegistered('Ada'), undefined, context);
+            result = await dispatcher.invoke(instance as unknown as Record<string, Function>, handler,
+                new AuthorRegistered('Grace'), initial, context);
+        });
+        it('should invoke the instance handler with the event state and context', () => {
+            (result as string[]).should.deep.equal([`${prefix}:Ada:author`, `${prefix}:Grace:author`]);
+        });
+    });
+}

package/reducers/for_Reducers/when_activating_a_field_override.spec.ts

@@ -0,0 +1,63 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EventContext, EventType, ObservationState, ReplayState, type ReducerMessage } from '@cratis/chronicle.contracts';
+import { beforeEach, chai, describe, it } from 'vitest';
+import type { IClientArtifactsProvider } from '../../artifacts/index.js';
+import type { ChronicleConnection } from '../../connection/index.js';
+import { ConnectionLifecycle } from '../../connection/ConnectionLifecycle.js';
+import type { IEventStore } from '../../IEventStore.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import { handles, reducer, Reducers } from '../index.js';
+
+chai.should();
+
+@eventType('field-reducer-event')
+class AuthorRegistered {}
+const calls: string[] = [];
+class Base {
+    @handles(AuthorRegistered) update() { calls.push('base'); return {}; }
+    beginReplay() { calls.push('replay'); }
+    endReplay() {}
+}
+@reducer('field-reducer')
+class Derived extends Base {
+    override update = () => { calls.push('field'); return {}; };
+}
+
+for (const replayState of [ReplayState.REPLAY_STATE_None, ReplayState.BeginReplay]) {
+    describe(`when activating a reducer with a field override for replay state ${replayState}`, () => {
+        let result: ReducerMessage;
+        let disposed: boolean;
+        beforeEach(async () => {
+            calls.length = 0;
+            disposed = false;
+            const lifecycle = new ConnectionLifecycle();
+            let finish!: () => void;
+            const finished = new Promise<void>(resolve => { finish = resolve; });
+            async function* stream(queue: AsyncIterable<ReducerMessage>) {
+                const messages = queue[Symbol.asyncIterator]();
+                await messages.next();
+                yield { Events: [{ Content: '{}', Context: EventContext.fromPartial({
+                    EventType: EventType.fromPartial({ Id: 'field-reducer-event', Generation: 1 }), SequenceNumber: 1n
+                }) }], Partition: 'author', ReplayState: replayState, InitialState: '' };
+                result = (await messages.next()).value!;
+                await lifecycle.disconnected(error => { throw error; });
+                finish();
+            }
+            const reducers = new Reducers({ reducers: [Derived], eventTypes: [AuthorRegistered], readModels: [] } as unknown as IClientArtifactsProvider,
+                { reducers: { observe: stream }, readModels: { registerMany: async () => ({}) } } as unknown as ChronicleConnection,
+                'store', 'tenant', lifecycle, 'sink', { readModels: {} } as IEventStore,
+                type => ({ instance: new type(), dispose: () => { disposed = true; } }));
+            try { await reducers.register(); await finished; } finally { reducers.dispose(); }
+        });
+        it('should fail delivery without invoking the field or replay notification', () => {
+            calls.should.have.lengthOf(0);
+            result.Content!.Value1!.State.should.equal(ObservationState.Failed);
+            result.Content!.Value1!.ReadModelState.should.equal('');
+            result.Content!.Value1!.ExceptionMessages.join(' ').should.contain(
+                "Override 'update' on 'Derived' hides @handles(AuthorRegistered) declared on 'Base'; use a method with @handles instead of an instance field.");
+        });
+        it('should release the rejected activation lease', () => { disposed.should.be.true; });
+    });
+}

package/reducers/for_Reducers/when_observing_explicit_handlers.legacy.spec.ts

@@ -0,0 +1,73 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { EventContext, EventType, ObservationState, type ReducerMessage } from '@cratis/chronicle.contracts';
+import { beforeEach, chai, describe, it } from 'vitest';
+import type { IClientArtifactsProvider } from '../../artifacts/index.js';
+import type { ChronicleConnection } from '../../connection/index.js';
+import { ConnectionLifecycle } from '../../connection/ConnectionLifecycle.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import type { EventContext as ClientEventContext } from '../../events/EventContext.js';
+import { handles, reducer, Reducers } from '../index.js';
+
+chai.should();
+
+@eventType('legacy-reduced-handler')
+class AuthorRegistered { constructor(readonly name = '') {} }
+
+@reducer('legacy-reduction')
+class AuthorReducer {
+    @handles(AuthorRegistered)
+    update(event: AuthorRegistered, state: { names: string[] } | undefined, context: ClientEventContext) {
+        return { names: [...(state?.names ?? []), event.name], id: context.eventSourceId };
+    }
+}
+
+describe('when observing explicit legacy reducer handlers', () => {
+    let registration: ReducerMessage;
+    let result: ReducerMessage;
+    beforeEach(async () => {
+        const lifecycle = new ConnectionLifecycle();
+        let finish!: () => void;
+        const finished = new Promise<void>(resolve => { finish = resolve; });
+        async function* stream(queue: AsyncIterable<ReducerMessage>) {
+            const messages = queue[Symbol.asyncIterator]();
+            registration = (await messages.next()).value!;
+            yield {
+                Events: ['Ada', 'Grace'].map((name, index) => ({
+                    Context: EventContext.fromPartial({
+                        EventType: EventType.fromPartial({ Id: 'legacy-reduced-handler', Generation: 1 }),
+                        EventSourceId: 'author', SequenceNumber: BigInt(index + 1)
+                    }),
+                    Content: JSON.stringify({ name })
+                })),
+                Partition: 'author', ReplayState: 0, InitialState: ''
+            };
+            result = (await messages.next()).value!;
+            await lifecycle.disconnected(error => { throw error; });
+            finish();
+        }
+        const connection = {
+            reducers: { observe: stream }, readModels: { registerMany: async () => ({}) }
+        } as unknown as ChronicleConnection;
+        const artifacts = {
+            reducers: [AuthorReducer], eventTypes: [AuthorRegistered], readModels: []
+        } as unknown as IClientArtifactsProvider;
+        const reducers = new Reducers(artifacts, connection, 'store', 'tenant', lifecycle, 'sink');
+        try {
+            await reducers.register();
+            await finished;
+        } finally { reducers.dispose(); }
+    });
+    it('should subscribe to the explicitly named event type', () => {
+        registration.Content!.Value0!.Reducer!.EventTypes.map(entry => entry.EventType!.Id)
+            .should.deep.equal(['legacy-reduced-handler']);
+    });
+    it('should pass the event state and context through the named method', () => {
+        JSON.parse(result.Content!.Value1!.ReadModelState).should.deep.equal({ names: ['Ada', 'Grace'], id: 'author' });
+    });
+    it('should acknowledge both deliveries successfully', () => {
+        result.Content!.Value1!.State.should.equal(ObservationState.Success);
+        result.Content!.Value1!.LastSuccessfulObservation.should.equal(2n);
+    });
+});

package/reducers/for_Reducers/when_registering_explicit_handlers.spec.ts

@@ -0,0 +1,57 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it, vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../../artifacts/index.js';
+import type { ChronicleConnection } from '../../connection/index.js';
+import { ConnectionLifecycle } from '../../connection/ConnectionLifecycle.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import { handles, reducer, Reducers } from '../index.js';
+
+chai.should();
+
+@eventType('reducer-handled-event')
+class AuthorRegistered {}
+@eventType('unselected-reducer-event')
+class Unregistered {}
+
+@reducer('valid-handlers')
+class Valid { @handles(AuthorRegistered) update() {} }
+@reducer('missing-handler-event')
+class Missing { @handles(Unregistered) update() {} }
+@reducer('duplicate-handlers')
+class Duplicate {
+    @handles(AuthorRegistered) update() {}
+    authorRegistered() {}
+}
+
+for (const [type, message] of [
+    [Missing, /update.*Missing.*Unregistered.*no registered event type/],
+    [Duplicate, /multiple handlers.*reducer-handled-event.*update.*authorRegistered/]
+] as const) {
+    describe(`when registering a reducer with invalid explicit handlers on ${type.name}`, () => {
+        const observe = vi.fn();
+        const registerMany = vi.fn();
+        let error: unknown;
+        beforeEach(async () => {
+            observe.mockReset();
+            registerMany.mockReset();
+            error = undefined;
+            const artifacts = { reducers: [Valid, type], eventTypes: [AuthorRegistered], readModels: [] } as unknown as IClientArtifactsProvider;
+            const connection = { reducers: { observe }, readModels: { registerMany } } as unknown as ChronicleConnection;
+            const reducers = new Reducers(artifacts, connection, 'store', 'tenant', new ConnectionLifecycle(), 'sink');
+            try { await reducers.register(); } catch (caught) { error = caught; }
+            finally { reducers.dispose(); }
+        });
+        it('should reject registration with an actionable error', () => {
+            (error instanceof Error).should.be.true;
+            (error as Error).message.should.match(message);
+        });
+        it('should not register read models before validating all handlers', () => {
+            registerMany.mock.calls.should.have.lengthOf(0);
+        });
+        it('should not start an observation before validating all reducers', () => {
+            observe.mock.calls.should.have.lengthOf(0);
+        });
+    });
+}

package/reducers/index.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+export { handles } from '../events/handles.js';
 export { ReducerId } from './ReducerId.js';
 export { reducer, getReducerMetadata, isReducer } from './reducer.js';
 export type { ReducerMetadata } from './reducer.js';

package/testing/ReactorScenario.ts

@@ -21,6 +21,7 @@ import { EventStoreNamespaceName } from '../EventStoreNamespaceName.js';
 import type { IEventStore } from '../IEventStore.js';
 import type { IReadModels } from '../readModels/IReadModels.js';
 import { getReactorEventTypes, invokeReactorHandler, selectReactorHandler } from '../reactors/ReactorDispatcher.js';
+import { createHandlerInstanceValidator } from '../observation/createHandlerInstanceValidator.js';
 import { getReactorMetadata } from '../reactors/reactor.js';
 import { normalizeReactorSideEffects } from '../reactors/ReactorSideEffects.js';
 import type { ReactorServices } from '../reactors/ReactorServices.js';
@@ -40,6 +41,7 @@ export class ReactorScenario {
     private readonly _entries: ReturnType<typeof getReactorEventTypes>;
     private readonly _eventTypes: readonly Constructor[];
     private readonly _instance?: Record<string, Function>;
+    private readonly _validateInstance: (instance: object) => void;
     private readonly _store: IEventStore;
     private readonly _controller = new AbortController();
     private readonly _effects: RecordedReactorSideEffect[] = [];
@@ -76,9 +78,12 @@ export class ReactorScenario {
             eventTypeMigrations: eventTypeMigrations === undefined ? undefined : [...eventTypeMigrations]
         } });
         this._entries = getReactorEventTypes(_reactor, this._eventTypes);
+        this._validateInstance = createHandlerInstanceValidator(_reactor,
+            this._entries.flatMap(entry => [entry.methodName, entry.replayMethodName].filter((name): name is string => !!name)));
         // Every unsupported event-sequence operation is latched at its source, whichever result or stream carries it.
         observeUnsupportedOperations(this._events.eventSequence, error => { this.latch(error); });
         this._instance = _options.artifactActivator ? undefined : new (_reactor as new () => Record<string, Function>)();
+        if (this._instance) this._validateInstance(this._instance);
         this._store = _options.servicesEventStore ?? this.scenarioStore();
         this.given = { forEventSource: id => ({ events: (...events) => this.deliver(id, events, true) }) };
         this.when = { forEventSource: id => ({ events: (...events) => this.deliver(id, events, false) }) };
@@ -246,7 +251,10 @@ export class ReactorScenario {
                         artifactId: getReactorMetadata(this._reactor)!.id.value, eventStore: this._store,
                         readModels: services.readModels, eventSequenceId: 'event-log', partition: sourceId,
                         signal: services.signal, delivery: ArtifactDelivery.Events, eventContext: first.context },
-                    this._options.artifactActivator, process);
+                    this._options.artifactActivator, artifact => {
+                        this._validateInstance(artifact.instance);
+                        return process(artifact);
+                    });
                 } else {
                     await process({ instance: this._instance ?? {} });
                 }

package/testing/ReducerReadModelProcessor.ts

@@ -18,6 +18,7 @@ export class ReducerReadModelProcessor<TReadModel extends object> implements IRe
     async process(events: readonly ScenarioEvent[]): Promise<Map<string, ReadModelState<TReadModel>>> {
         const results = new Map<string, ReadModelState<TReadModel>>();
         const reducer = new (this._reducerType as new () => Record<string, Function>)();
+        this._dispatcher.validateInstance(reducer);
         for (const event of events) {
             const handler = this._dispatcher.handlerFor(event.context.eventType.id.value);
             if (!handler) continue;

package/testing/for_ReactorScenario/when_delivering_to_an_explicit_handler.spec.ts

@@ -0,0 +1,100 @@
+// 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 { beforeEach, chai, describe, it } from 'vitest';
+import { eventType, handles, onceOnly, reactor, type EventContext, type ReactorServices } from '../../index.js';
+import { ReactorScenario } from '../index.js';
+
+chai.should();
+
+@eventType('scenario-explicit-author')
+class AuthorRegistered {
+    @field(String) name: string;
+    constructor(name: string) { this.name = name; }
+}
+@eventType('scenario-explicit-notification')
+class AuthorNotified {
+    @field(String) name: string;
+    constructor(name: string) { this.name = name; }
+}
+
+const calls: { name: string; source: string; method: string }[] = [];
+@reactor('explicit-scenario-handler')
+class AuthorReactor {
+    @onceOnly()
+    @handles(AuthorRegistered)
+    notify(event: AuthorRegistered, context: EventContext, services: ReactorServices) {
+        (services.readModels === services.eventStore.readModels).should.be.true;
+        calls.push({ name: event.name, source: context.eventSourceId, method: 'notify' });
+        return new AuthorNotified(event.name);
+    }
+}
+
+const options = { artifacts: { eventTypes: [AuthorRegistered, AuthorNotified] }, constraints: 'disabled' as const };
+
+describe('when delivering a live event to an explicitly named onceOnly handler in ReactorScenario', () => {
+    let scenario: ReactorScenario;
+    beforeEach(async () => {
+        calls.length = 0;
+        scenario = new ReactorScenario(AuthorReactor, options);
+        await scenario.when.forEventSource('author-1').events(new AuthorRegistered('Ada'));
+    });
+    it('should invoke the method with the event and context', () => {
+        calls.should.deep.equal([{ name: 'Ada', source: 'author-1', method: 'notify' }]);
+    });
+    it('should process returned side effects', () => {
+        scenario.shouldHaveProduced(AuthorNotified, event => event.name === 'Ada');
+    });
+    it('should complete delivery', () => {
+        scenario.results[0].completed.should.be.true;
+    });
+});
+
+describe('when ReactorScenario has an unregistered explicit handler', () => {
+    it('should reject it before constructing the reactor', () => {
+        let constructed = false;
+        @reactor('invalid-explicit-scenario')
+        class Invalid {
+            constructor() { constructed = true; }
+            @handles(AuthorRegistered) notify() {}
+        }
+        (() => new ReactorScenario(Invalid, { ...options, artifacts: { eventTypes: [AuthorNotified] } }))
+            .should.throw(/notify.*AuthorRegistered.*no registered event type/);
+        constructed.should.be.false;
+    });
+});
+
+@reactor('field-shadowing-scenario')
+class FieldReactor extends AuthorReactor {
+    override notify = () => new AuthorNotified('hidden');
+}
+
+describe('when an instance field hides an inherited ReactorScenario handler', () => {
+    it('should reject the field after constructing the reactor', () => {
+        (() => new ReactorScenario(FieldReactor, options)).should.throw(
+            "Override 'notify' on 'FieldReactor' hides @handles(AuthorRegistered) declared on 'AuthorReactor'; use a method with @handles instead of an instance field.");
+    });
+    it('should reject an activator-created field before delivery and dispose its lease', async () => {
+        let disposed = false;
+        const scenario = new ReactorScenario(FieldReactor, { ...options, artifactActivator: type => ({
+            instance: new type(), dispose: () => { disposed = true; }
+        }) });
+        const [result] = await Promise.allSettled([scenario.when.forEventSource('author').events(new AuthorRegistered('Ada'))]);
+        result.status.should.equal('rejected');
+        if (result.status === 'rejected') (result.reason as Error).message.should.match(/Override 'notify'.*use a method/);
+        scenario.produced.should.have.lengthOf(0);
+        disposed.should.be.true;
+    });
+});
+
+describe('when ReactorScenario has duplicate explicit and conventional handlers', () => {
+    @reactor('duplicate-explicit-scenario')
+    class Invalid {
+        @handles(AuthorRegistered) notify() {}
+        authorRegistered() {}
+    }
+    it('should reject the ambiguous event delivery', () => {
+        (() => new ReactorScenario(Invalid, options)).should.throw(/multiple handlers.*scenario-explicit-author/);
+    });
+});

package/testing/for_ReadModelScenario/when_evaluating_arithmetic/with_a_fluent_projection.spec.ts

@@ -0,0 +1,85 @@
+// 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 { chai, describe, it } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import type { IProjectionBuilderFor } from '../../../projections/declarative/IProjectionBuilderFor.js';
+import { projection } from '../../../projections/declarative/projection.js';
+import { ReadModelScenario } from '../../ReadModelScenario.js';
+import { UnsupportedProjectionOperation } from '../../projections/UnsupportedProjectionOperation.js';
+
+chai.should();
+
+class Changed {
+    constructor(readonly amount: number) {}
+}
+field(Number)(Changed.prototype, 'amount');
+eventType('fluent-arithmetic-changed')(Changed);
+class Removed {}
+eventType('fluent-arithmetic-removed')(Removed);
+class Totals {
+    id = '';
+    added = 0;
+    subtracted = 0;
+    counted = 0;
+    incremented = 0;
+    decremented = 0;
+}
+field(String)(Totals.prototype, 'id');
+for (const property of ['added', 'subtracted', 'counted', 'incremented', 'decremented']) field(Number)(Totals.prototype, property);
+class TotalsProjection {
+    define(builder: IProjectionBuilderFor<Totals>): void {
+        builder.noAutoMap().withInitialValues(() => ({ id: '', added: 10, subtracted: 10, counted: 0, incremented: 0, decremented: 0 }))
+            .from(Changed, from => from.add(model => model.added).with(event => event.amount)
+                .subtract(model => model.subtracted).with(event => event.amount)
+                .count(model => model.counted).increment(model => model.incremented).decrement(model => model.decremented))
+            .removedWith(Removed);
+    }
+}
+projection('fluent-arithmetic', Totals)(TotalsProjection);
+const artifacts = { eventTypes: [Changed, Removed], projections: [TotalsProjection], reducers: [] };
+
+describe('when evaluating arithmetic with a fluent projection', () => {
+    for (const operation of ['add', 'subtract'] as const) {
+        it(`should reject fluent ${operation} with a snake_case operand before any events are seeded`, () => {
+            class PriceChanged {
+                unit_price = 2;
+            }
+            field(Number)(PriceChanged.prototype, 'unit_price');
+            eventType(`fluent-arithmetic-snake-case-${operation}`)(PriceChanged);
+            class PriceTotals {
+                id = '';
+                total = 0;
+            }
+            field(String)(PriceTotals.prototype, 'id');
+            field(Number)(PriceTotals.prototype, 'total');
+            class PriceProjection {
+                define(builder: IProjectionBuilderFor<PriceTotals>): void {
+                    builder.from(PriceChanged, from => from[operation](model => model.total).with(event => event.unit_price));
+                }
+            }
+            projection(`fluent-arithmetic-snake-case-${operation}`, PriceTotals)(PriceProjection);
+            (() => new ReadModelScenario(PriceTotals, { eventTypes: [PriceChanged], projections: [PriceProjection], reducers: [] }))
+                .should.throw(UnsupportedProjectionOperation).with.property('message')
+                .that.includes('kernel only permits an underscore as the first character')
+                .and.includes('https://github.com/Cratis/Chronicle/issues/4491');
+        });
+    }
+
+    it('should apply all five property operations to initial values', async () => {
+        const scenario = new ReadModelScenario(Totals, artifacts);
+        scenario.given.forEventSource('A').events(new Changed(2.5), new Changed(-1));
+        const result = (await scenario.instance)!;
+        [result.added, result.subtracted, result.counted, result.incremented, result.decremented].should.deep.equal([11.5, 8.5, 2, 2, -2]);
+    });
+
+    it('should discard the accumulator on removal and reapply initial values on recreation', async () => {
+        const scenario = new ReadModelScenario(Totals, artifacts);
+        scenario.given.forEventSource('A').events(new Changed(3), new Removed());
+        (await scenario.wasDeletedForEventSourceId('A')).should.be.true;
+        scenario.given.forEventSource('A').events(new Changed(4));
+        const result = (await scenario.instance)!;
+        [result.added, result.counted].should.deep.equal([14, 1]);
+    });
+});

package/testing/for_ReadModelScenario/when_evaluating_arithmetic/with_legacy_decorators.legacy.spec.ts

@@ -0,0 +1,91 @@
+// 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 { chai, describe, it } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { addFrom } from '../../../projections/modelBound/addFrom.js';
+import { subtractFrom } from '../../../projections/modelBound/subtractFrom.js';
+import { count } from '../../../projections/modelBound/count.js';
+import { increment } from '../../../projections/modelBound/increment.js';
+import { decrement } from '../../../projections/modelBound/decrement.js';
+import { setFrom } from '../../../projections/modelBound/setFrom.js';
+import { ReadModelScenario } from '../../ReadModelScenario.js';
+import { UnsupportedProjectionOperation } from '../../projections/UnsupportedProjectionOperation.js';
+
+chai.should();
+
+@eventType('legacy-arithmetic-added')
+class Added {
+    @field(Number) amount: number;
+    @field(String) title = 'not mapped';
+    constructor(amount: number) { this.amount = amount; }
+}
+@eventType('legacy-arithmetic-subtracted')
+class Subtracted {
+    @field(Number) amount: number;
+    constructor(amount: number) { this.amount = amount; }
+}
+@eventType('legacy-arithmetic-renamed')
+class Renamed {
+    @field(Number) amount = 1;
+    @field(String) caption = 'explicit';
+    @field(String) title = 'automapped';
+}
+class Totals {
+    @field(String) id = '';
+    @field(Number) @addFrom(Added, 'amount') @subtractFrom(Subtracted, 'amount') @addFrom(Renamed, 'amount') total = 0;
+    @field(Number) @addFrom(Added) @subtractFrom(Subtracted) amount = 0;
+    @field(Number) @count(Added) counted = 0;
+    @field(Number) @increment(Added) incremented = 0;
+    @field(Number) @decrement(Added) decremented = 0;
+    @field(String) @setFrom(Renamed, 'caption') label = '';
+    @field(String) title = '';
+}
+const artifacts = { eventTypes: [Added, Subtracted, Renamed], readModels: [Totals], reducers: [], projections: [] };
+
+// The same operations are captured in arithmetic.json, arithmetic-numeric-matrix.json and arithmetic-automap.json.
+describe('when evaluating arithmetic with legacy model-bound decorators', () => {
+    for (const [operation, decorate] of [['add', addFrom], ['subtract', subtractFrom]] as const) {
+        it(`should reject @${operation}From with a snake_case operand before any events are seeded`, () => {
+            @eventType(`legacy-arithmetic-snake-case-${operation}`)
+            class PriceChanged {
+                @field(Number) unit_price = 2;
+            }
+            class PriceTotals {
+                @field(String) id = '';
+                @field(Number) @decorate(PriceChanged, 'unit_price') total = 0;
+            }
+            (() => new ReadModelScenario(PriceTotals, { eventTypes: [PriceChanged], readModels: [PriceTotals], reducers: [], projections: [] }))
+                .should.throw(UnsupportedProjectionOperation).with.property('message')
+                .that.includes('kernel only permits an underscore as the first character')
+                .and.includes('https://github.com/Cratis/Chronicle/issues/4491');
+        });
+    }
+
+    it('should accumulate all five operations and default event property names', async () => {
+        const scenario = new ReadModelScenario(Totals, artifacts);
+        scenario.given.forEventSource('A').events(new Added(2.5), new Added(3), new Subtracted(1));
+        const result = (await scenario.instance)!;
+        [result.total, result.amount, result.counted, result.incremented, result.decremented].should.deep.equal([4.5, 4.5, 2, 2, -2]);
+    });
+
+    it('should replay additional seeds without counting the previous replay twice and keep sources independent', async () => {
+        const scenario = new ReadModelScenario(Totals, artifacts);
+        scenario.given.forEventSource('A').events(new Added(2));
+        (await scenario.instance)!.total.should.equal(2);
+        scenario.given.forEventSource('B').events(new Added(7));
+        scenario.given.forEventSource('A').events(new Added(3));
+        (await scenario.instanceForEventSourceId('A'))!.total.should.equal(5);
+        (await scenario.instanceForEventSourceId('B'))!.total.should.equal(7);
+    });
+
+    it('should suppress aggregate-only AutoMap and restore it for mixed mappings', async () => {
+        const scenario = new ReadModelScenario(Totals, artifacts);
+        scenario.given.forEventSource('A').events(new Added(2));
+        ((await scenario.instance)!.title === undefined).should.be.true;
+        scenario.given.forEventSource('A').events(new Renamed());
+        const result = (await scenario.instance)!;
+        [result.total, result.title, result.label].should.deep.equal([3, 'automapped', 'explicit']);
+    });
+});