@cratis/chronicle 6.24.0 → 6.26.0

package/testing/EventScenario.constraint-cycles.spec.ts

@@ -0,0 +1,236 @@
+// 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 { readFileSync } from 'node:fs';
+import { chai, describe, it, vi } from 'vitest';
+import { field } from '@cratis/fundamentals';
+import { eventType, getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { constraint } from '../events/constraints/constraint.js';
+import { compileConstraints } from '../events/constraints/Constraints.js';
+import type { IConstraint } from '../events/constraints/IConstraint.js';
+import type { IConstraintBuilder } from '../events/constraints/IConstraintBuilder.js';
+import { removeConstraint } from '../events/constraints/removeConstraint.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from './index.js';
+import { InProcessConstraints } from './InProcessConstraints.js';
+import { ReactorScenario } from './ReactorScenario.js';
+import { reactor } from '../reactors/reactor.js';
+
+chai.should();
+class OracleCycleFirst { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleCycleFirst')(OracleCycleFirst);
+class OracleCycleSibling { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleCycleSibling')(OracleCycleSibling);
+class OracleCycleRemoved { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleCycleRemoved')(OracleCycleRemoved);
+removeConstraint('OracleCycle')(OracleCycleRemoved);
+class OracleCycleExpired { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleCycleExpired')(OracleCycleExpired);
+removeConstraint('OracleCycle')(OracleCycleExpired);
+class OracleCycleRenewed { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleCycleRenewed')(OracleCycleRenewed);
+removeConstraint('OracleCycle')(OracleCycleRenewed);
+// Same-named uniqueFor declarations merge into one definition covering the whole set.
+class CycleFirst implements IConstraint {
+    define(builder: IConstraintBuilder) { builder.uniqueFor(OracleCycleFirst, 'Cycle occupied', 'OracleCycle'); }
+}
+constraint('CycleFirst')(CycleFirst);
+class CycleSibling implements IConstraint {
+    define(builder: IConstraintBuilder) { builder.uniqueFor(OracleCycleSibling, undefined, 'OracleCycle'); }
+}
+constraint('CycleSibling')(CycleSibling);
+class CycleRenewed implements IConstraint {
+    define(builder: IConstraintBuilder) { builder.uniqueFor(OracleCycleRenewed, undefined, 'OracleCycle'); }
+}
+constraint('CycleRenewed')(CycleRenewed);
+
+const aliases = { first: OracleCycleFirst, sibling: OracleCycleSibling, cycleRemoved: OracleCycleRemoved,
+    cycleExpired: OracleCycleExpired, renewed: OracleCycleRenewed };
+type Alias = keyof typeof aliases;
+type Input = { source: string; type: Alias; value: string };
+type History = { sequence: string; source: string; sourceType: string; streamType: string; streamId: string;
+    type: string; content: Record<string, string>; hash: string };
+type Violation = { EventTypeId: string; SequenceNumber: string; ConstraintType: number; ConstraintName: string;
+    Message: string; Details: Record<string, string> };
+type Outcome = { success: boolean; sequences: string[]; violations: Array<{ id: string; message: string; details: Record<string, string> }>;
+    wireViolations: Violation[]; errors: string[]; history: History[]; next: string };
+type Fixture = { eventSchemas: Record<string, { eventTypeId: string; properties: Record<string, string> }>;
+    constraintDefinitions: Array<{ kind: string; name: string; eventTypes: string[]; removedWithEventTypeIds: string[]; message: string }>;
+    isolatedConstraintOperations: Array<{ mode: 'single' | 'batch'; events: Input[] }>;
+    expected: { outcomes: Outcome[] } };
+const aliasById = Object.fromEntries(Object.entries(aliases).map(([alias, type]) => [getEventTypeMetadata(type)!.eventType.id.value, alias]));
+const makeEvent = ({ type, value }: Input): object => new aliases[type](value);
+const historyOf = (scenario: EventScenario): History[] => scenario.appendedEvents.map(entry => ({
+    sequence: entry.context.sequenceNumber.toString(), source: entry.context.eventSourceId,
+    sourceType: entry.context.eventSourceType, streamType: entry.context.eventStreamType, streamId: entry.context.eventStreamId,
+    type: entry.eventType.id.value, content: entry.content as Record<string, string>, hash: entry.context.hash
+}));
+const unsupported = async (action: () => unknown, operation: string, reason: string) => {
+    await Promise.resolve().then(action).then(() => { throw new Error('Expected rejection'); }, error => {
+        (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+        (error as Error).message.should.include(`UnsupportedEventSequenceOperation: ${operation}:`);
+        (error as Error).message.should.include(reason);
+        (error as Error).message.should.include('Use a kernel-backed test.');
+    });
+};
+const siblingTypes = [OracleCycleFirst, OracleCycleSibling, OracleCycleRemoved, OracleCycleExpired];
+const cycleTypes = [...siblingTypes, OracleCycleRenewed];
+const shapeReason = 'This unique event type set and removal combination is not fixture-backed.';
+
+describe('fixture-backed unique event type cycles', () => {
+    for (const [name, selected, constraints] of [
+        ['constraints-event-type-siblings', siblingTypes, [CycleFirst, CycleSibling]],
+        ['constraints-event-type-cycles', cycleTypes, [CycleFirst, CycleSibling, CycleRenewed]]
+    ] as const) {
+        it(`matches the pinned kernel ${name}: raw and mapped violations, cycles, hashes and rollback`, async () => {
+            const fixture = JSON.parse(readFileSync(new URL(`./fixtures/${name}.json`, import.meta.url), 'utf8')) as Fixture;
+            Object.fromEntries(selected.map(type => {
+                const metadata = getEventTypeMetadata(type)!;
+                return [aliasById[metadata.eventType.id.value], { eventTypeId: metadata.eventType.id.value,
+                    properties: Object.fromEntries(Object.entries(metadata.schema.properties ?? {}).map(([key, property]) => [key, property.type])) }];
+            })).should.deep.equal(fixture.eventSchemas);
+            const compiled = compileConstraints({ eventTypes: [...selected], constraints: [...constraints] });
+            [...compiled].map(([key, capture]) => ({ kind: 'uniqueEventType', name: key,
+                eventTypes: capture.uniqueEventType!.eventTypeIds!.map(id => aliasById[id]),
+                removedWithEventTypeIds: capture.uniqueEventType!.removedWithEventTypeIds!.map(id => aliasById[id]),
+                message: capture.uniqueEventType!.message ?? ''
+            })).should.deep.equal(fixture.constraintDefinitions);
+            fixture.isolatedConstraintOperations.length.should.be.greaterThan(0);
+            fixture.expected.outcomes.length.should.equal(fixture.isolatedConstraintOperations.length);
+            fixture.expected.outcomes.some(outcome => !outcome.success).should.be.true;
+            const scenario = new EventScenario({ artifacts: { eventTypes: [...selected], constraints: [...constraints] } });
+            const notifications = scenario.eventSequence.appendOperations[Symbol.asyncIterator]();
+            const validate = vi.spyOn(InProcessConstraints.prototype, 'validate');
+            let count = 0;
+            try {
+                for (const [index, operation] of fixture.isolatedConstraintOperations.entries()) {
+                    const expected = fixture.expected.outcomes[index];
+                    const before = historyOf(scenario);
+                    const calls = validate.mock.calls.length;
+                    const nextNotification = notifications.next();
+                    const results = operation.mode === 'single'
+                        ? [await scenario.append(operation.events[0].source, makeEvent(operation.events[0]))]
+                        : await scenario.appendMany(operation.events.map(entry => ({ eventSourceId: entry.source, event: makeEvent(entry) })));
+                    const notification = (await nextNotification).value!;
+                    validate.mock.calls.length.should.equal(calls + 1);
+                    const raw = validate.mock.results.at(-1)?.value as ReturnType<InProcessConstraints['validate']>;
+                    raw.map(({ SequenceNumber, ...violation }) => ({ ...violation, SequenceNumber: SequenceNumber.toString() }))
+                        .should.deep.equal(expected.wireViolations);
+                    notification.length.should.equal(operation.events.length);
+                    notification.every(item => item.result.isSuccess === expected.success).should.be.true;
+                    count += operation.events.length;
+                    scenario.results.length.should.equal(count);
+                    results.length.should.equal(operation.events.length);
+                    for (const [position, result] of results.entries()) {
+                        result.isSuccess.should.equal(expected.success);
+                        result.sequenceNumber.value.toString().should.equal(expected.success ? expected.sequences[position] : '0');
+                        result.constraintViolations.map(item => ({ id: item.constraintId, message: item.message, details: item.details }))
+                            .should.deep.equal(expected.violations);
+                        result.errors.map(item => item.message).should.deep.equal(expected.errors);
+                    }
+                    if (!expected.success) historyOf(scenario).should.deep.equal(before);
+                    historyOf(scenario).should.deep.equal(expected.history);
+                    (await scenario.eventSequence.getNextSequenceNumber()).value.toString().should.equal(expected.next);
+                }
+            } finally {
+                validate.mockRestore();
+                await notifications.return?.();
+            }
+        });
+    }
+
+    it('rolls back a release and reclaim in a failing setup call without results or notifications', async () => {
+        const scenario = new EventScenario({ artifacts: { eventTypes: siblingTypes, constraints: [CycleFirst, CycleSibling] } });
+        const notifications = scenario.eventSequence.appendOperations[Symbol.asyncIterator]();
+        try {
+            const first = notifications.next();
+            await scenario.given.forEventSource('A').events(new OracleCycleFirst('claim'));
+            (await first).value!.length.should.equal(1);
+            const before = historyOf(scenario);
+            await scenario.given.forEventSource('A').events(new OracleCycleRemoved('release'), new OracleCycleFirst('reopen'),
+                new OracleCycleSibling('blocked'))
+                .then(() => { throw new Error('Invalid setup succeeded'); }, error => {
+                    (error as Error).message.should.include('EventScenario given setup failed');
+                });
+            historyOf(scenario).should.deep.equal(before);
+            scenario.results.length.should.equal(0);
+            (await scenario.eventSequence.getNextSequenceNumber()).value.should.equal(1n);
+            const next = notifications.next();
+            const blocked = await scenario.append('A', new OracleCycleSibling('still held'));
+            blocked.constraintViolations.map(item => item.constraintId).should.deep.equal(['OracleCycle']);
+            (await next).value!.map(item => item.event.eventType.id.value).should.deep.equal(['OracleCycleSibling']);
+        } finally { await notifications.return?.(); }
+    });
+
+    it('delivers only committed claim and release events to a reactor', async () => {
+        const calls: string[] = [];
+        @reactor('cycle-reactor')
+        class CycleReactor {
+            oracleCycleFirst(event: OracleCycleFirst) { calls.push(event.label); }
+            oracleCycleSibling(event: OracleCycleSibling) { calls.push(event.label); }
+            oracleCycleExpired(event: OracleCycleExpired) { calls.push(event.label); }
+        }
+        const subject = new ReactorScenario(CycleReactor,
+            { artifacts: { eventTypes: siblingTypes, constraints: [CycleFirst, CycleSibling] } });
+        await subject.when.forEventSource('A').events(new OracleCycleFirst('claim'));
+        await subject.when.forEventSource('A').events(new OracleCycleSibling('blocked'))
+            .then(() => { throw new Error('Occupied cycle delivered'); }, error => {
+                (error as Error).message.should.include('ReactorScenario action append failed');
+            });
+        calls.should.deep.equal(['claim']);
+        subject.results.length.should.equal(1);
+        await subject.when.forEventSource('A').events(new OracleCycleExpired('release'), new OracleCycleSibling('reclaim'));
+        calls.should.deep.equal(['claim', 'release', 'reclaim']);
+        subject.results.length.should.equal(2);
+    });
+
+    it('rejects unsupported input in a batch and leaves history and results unchanged', async () => {
+        const scenario = new EventScenario({ artifacts: { eventTypes: siblingTypes, constraints: [CycleFirst, CycleSibling] } });
+        (await scenario.append('A', new OracleCycleFirst('claim'))).isSuccess.should.be.true;
+        const before = historyOf(scenario);
+        const results = scenario.results;
+        await unsupported(() => scenario.appendMany([{ eventSourceId: 'A', event: new OracleCycleExpired('release') },
+            { eventSourceId: 'B!', event: new OracleCycleFirst('claim') }]), 'appendMany.source (B!)',
+        'Only simple source identifiers are fixture-backed.');
+        historyOf(scenario).should.deep.equal(before);
+        scenario.results.should.deep.equal(results);
+        const blocked = await scenario.append('A', new OracleCycleSibling('still held'));
+        blocked.isSuccess.should.be.false;
+        blocked.constraintViolations.map(item => item.message).should.deep.equal(['Cycle occupied']);
+    });
+
+    it('rejects covered and removal type shapes that no fixture installs, at the shape check', async () => {
+        await unsupported(() => new EventScenario({ artifacts: {
+            eventTypes: [OracleCycleFirst, OracleCycleSibling, OracleCycleRemoved], constraints: [CycleFirst, CycleSibling]
+        } }), 'artifacts.constraints (OracleCycle)', shapeReason);
+        await unsupported(() => new EventScenario({ artifacts: {
+            eventTypes: [OracleCycleFirst, OracleCycleRemoved, OracleCycleRenewed], constraints: [CycleFirst, CycleRenewed]
+        } }), 'artifacts.constraints (OracleCycle)', shapeReason);
+        await unsupported(() => new EventScenario({ artifacts: {
+            eventTypes: [OracleCycleFirst, OracleCycleSibling, OracleCycleRemoved, OracleCycleRenewed],
+            constraints: [CycleFirst, CycleSibling, CycleRenewed]
+        } }), 'artifacts.constraints (OracleCycle)', shapeReason);
+    });
+
+    it('rejects a fixture-shaped cycle installed alongside another definition', async () => {
+        class OtherOnce { @field(String) label = 'other'; }
+        eventType('OracleCycleOtherOnce')(OtherOnce);
+        class OtherOnceConstraint implements IConstraint {
+            define(builder: IConstraintBuilder) { builder.uniqueFor(OtherOnce, undefined, 'OracleCycleOther'); }
+        }
+        constraint('OracleCycleOther')(OtherOnceConstraint);
+        await unsupported(() => new EventScenario({ artifacts: {
+            eventTypes: [...siblingTypes, OtherOnce], constraints: [CycleFirst, CycleSibling, OtherOnceConstraint]
+        } }), 'artifacts.constraints (OracleCycle)', 'Unique event cycles alongside other definitions are not fixture-backed.');
+    });
+
+    it('rejects a fieldless event-type remover at the schema check', async () => {
+        class FieldlessRemoval {}
+        eventType('OracleCycleFieldless')(FieldlessRemoval);
+        removeConstraint('OracleCycle')(FieldlessRemoval);
+        await unsupported(() => new EventScenario({ artifacts: {
+            eventTypes: [OracleCycleFirst, OracleCycleSibling, OracleCycleRemoved, FieldlessRemoval],
+            constraints: [CycleFirst, CycleSibling]
+        } }), 'artifacts.eventTypes.schema (FieldlessRemoval)', 'Only flat, unclassified string/boolean fields are fixture-backed.');
+    });
+});

package/testing/EventScenario.constraint-lifecycle.spec.ts

@@ -0,0 +1,231 @@
+// 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 { readFileSync } from 'node:fs';
+import { chai, describe, it, vi } from 'vitest';
+import { field } from '@cratis/fundamentals';
+import { eventType, getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { constraint } from '../events/constraints/constraint.js';
+import { compileConstraints } from '../events/constraints/Constraints.js';
+import type { IConstraint } from '../events/constraints/IConstraint.js';
+import type { IConstraintBuilder } from '../events/constraints/IConstraintBuilder.js';
+import { removeConstraint } from '../events/constraints/removeConstraint.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from './index.js';
+import { InProcessConstraints } from './InProcessConstraints.js';
+import { ReactorScenario } from './ReactorScenario.js';
+import { reactor } from '../reactors/reactor.js';
+
+chai.should();
+class OracleDomainText { @field(String) key: string; constructor(key: string) { this.key = key; } }
+eventType('OracleDomainText')(OracleDomainText);
+class OracleDomainShared { @field(String) key: string; constructor(key: string) { this.key = key; } }
+eventType('OracleDomainShared')(OracleDomainShared);
+class OracleDomainRemoved { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleDomainRemoved')(OracleDomainRemoved);
+removeConstraint('OracleLifecycleKey')(OracleDomainRemoved);
+class OracleDomainExpired { @field(String) label: string; constructor(label: string) { this.label = label; } }
+eventType('OracleDomainExpired')(OracleDomainExpired);
+class OracleDomainCleared {}
+eventType('OracleDomainCleared')(OracleDomainCleared);
+class LifecycleKey implements IConstraint {
+    define(builder: IConstraintBuilder) {
+        builder.unique(key => key.on(OracleDomainText, event => event.key).on(OracleDomainShared, event => event.key)
+            .removedWith(OracleDomainExpired).removedWith(OracleDomainCleared).withMessage('Taken: {PropertyValue}'));
+    }
+}
+constraint('OracleLifecycleKey')(LifecycleKey);
+class CoveredRemoval implements IConstraint {
+    define(builder: IConstraintBuilder) {
+        builder.unique(key => key.on(OracleDomainShared, event => event.key).on(OracleDomainText, event => event.key)
+            .removedWith(OracleDomainText).withMessage('Taken: {PropertyValue}'));
+    }
+}
+constraint('OracleCoveredRemoval')(CoveredRemoval);
+
+type Alias = 'string' | 'shared' | 'removed' | 'expired' | 'cleared';
+type Input = { source: string; type: Alias; value?: string };
+type History = { sequence: string; source: string; sourceType: string; streamType: string; streamId: string;
+    type: string; content: Record<string, string>; hash: string };
+type Violation = { EventTypeId: string; SequenceNumber: string; ConstraintType: number; ConstraintName: string;
+    Message: string; Details: Record<string, string> };
+type Outcome = { success: boolean; sequences: string[]; violations: Array<{ id: string; message: string; details: Record<string, string> }>;
+    wireViolations: Violation[]; errors: string[]; history: History[]; next: string };
+type Fixture = { eventSchemas: Record<string, { eventTypeId: string; properties: Record<string, string> }>;
+    constraintDefinitions: Array<{ kind: string; name: string; events: Array<{ type: string; properties: string[] }>;
+        ignoreCasing: boolean; removedWithEventTypeIds: string[]; message: string }>;
+    isolatedConstraintOperations: Array<{ mode: 'single' | 'batch'; events: Input[] }>;
+    expected: { outcomes: Outcome[] } };
+const aliases = { string: OracleDomainText, shared: OracleDomainShared, removed: OracleDomainRemoved,
+    expired: OracleDomainExpired, cleared: OracleDomainCleared };
+const aliasById = Object.fromEntries(Object.entries(aliases).map(([alias, type]) => [getEventTypeMetadata(type)!.eventType.id.value, alias]));
+const makeEvent = ({ type, value }: Input): object => type === 'string' ? new OracleDomainText(value!) :
+    type === 'shared' ? new OracleDomainShared(value!) : type === 'removed' ? new OracleDomainRemoved(value!) :
+        type === 'expired' ? new OracleDomainExpired(value!) : new OracleDomainCleared();
+const historyOf = (scenario: EventScenario): History[] => scenario.appendedEvents.map(entry => ({
+    sequence: entry.context.sequenceNumber.toString(), source: entry.context.eventSourceId,
+    sourceType: entry.context.eventSourceType, streamType: entry.context.eventStreamType, streamId: entry.context.eventStreamId,
+    type: entry.eventType.id.value, content: entry.content as Record<string, string>, hash: entry.context.hash
+}));
+const unsupported = async (action: () => unknown, reason: string) => {
+    await Promise.resolve().then(action).then(() => { throw new Error('Expected rejection'); }, error => {
+        (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+        (error as Error).message.should.include(reason);
+        (error as Error).message.should.include('Use a kernel-backed test.');
+    });
+};
+
+describe('fixture-backed unique-property lifecycle', () => {
+    for (const [name, constraints, selected] of [
+        ['constraints-property-lifecycle', [LifecycleKey], Object.values(aliases)],
+        ['constraints-property-covered-removal', [CoveredRemoval], [OracleDomainText, OracleDomainShared]]
+    ] as const) {
+        it(`matches the pinned kernel ${name}: raw and mapped violations, ownership, hashes and rollback`, async () => {
+            const fixture = JSON.parse(readFileSync(new URL(`./fixtures/${name}.json`, import.meta.url), 'utf8')) as Fixture;
+            const ids = new Set(selected.map(type => type.name));
+            Object.fromEntries(Object.entries(aliases).filter(([, type]) => ids.has(type.name)).map(([alias, type]) => {
+                const metadata = getEventTypeMetadata(type)!;
+                return [alias, { eventTypeId: metadata.eventType.id.value,
+                    properties: Object.fromEntries(Object.entries(metadata.schema.properties ?? {}).map(([key, property]) => [key, property.type])) }];
+            })).should.deep.equal(fixture.eventSchemas);
+            const compiled = compileConstraints({ eventTypes: [...selected], constraints: [...constraints] });
+            [...compiled].map(([key, capture]) => ({ kind: 'uniqueProperty', name: key,
+                events: capture.uniqueConstraint!.eventDefinitions.map(entry => ({ type: aliasById[entry.eventTypeId], properties: entry.properties })),
+                ignoreCasing: capture.uniqueConstraint!.ignoreCasing,
+                removedWithEventTypeIds: (capture.uniqueConstraint!.removedWithEventTypeIds ?? [])
+                    .map(id => aliasById[id]), message: capture.uniqueConstraint!.message ?? ''
+            })).should.deep.equal(fixture.constraintDefinitions);
+            fixture.isolatedConstraintOperations.length.should.be.greaterThan(0);
+            fixture.expected.outcomes.length.should.equal(fixture.isolatedConstraintOperations.length);
+            const scenario = new EventScenario({ artifacts: { eventTypes: [...selected], constraints: [...constraints] } });
+            const notifications = scenario.eventSequence.appendOperations[Symbol.asyncIterator]();
+            const validate = vi.spyOn(InProcessConstraints.prototype, 'validate');
+            let count = 0;
+            try {
+                for (const [index, operation] of fixture.isolatedConstraintOperations.entries()) {
+                    const expected = fixture.expected.outcomes[index];
+                    const before = historyOf(scenario);
+                    const nextNotification = notifications.next();
+                    const results = operation.mode === 'single'
+                        ? [await scenario.append(operation.events[0].source, makeEvent(operation.events[0]))]
+                        : await scenario.appendMany(operation.events.map(entry => ({ eventSourceId: entry.source, event: makeEvent(entry) })));
+                    const notification = (await nextNotification).value!;
+                    const raw = validate.mock.results.at(-1)?.value as ReturnType<InProcessConstraints['validate']>;
+                    raw.map(({ SequenceNumber, ...violation }) => ({ ...violation, SequenceNumber: SequenceNumber.toString() }))
+                        .should.deep.equal(expected.wireViolations);
+                    notification.length.should.equal(operation.events.length);
+                    notification.every(item => item.result.isSuccess === expected.success).should.be.true;
+                    count += operation.events.length;
+                    scenario.results.length.should.equal(count);
+                    results.length.should.equal(operation.events.length);
+                    for (const [position, result] of results.entries()) {
+                        result.isSuccess.should.equal(expected.success);
+                        result.sequenceNumber.value.toString().should.equal(expected.success ? expected.sequences[position] : '0');
+                        result.constraintViolations.map(item => ({ id: item.constraintId, message: item.message, details: item.details }))
+                            .should.deep.equal(expected.violations);
+                        result.errors.map(item => item.message).should.deep.equal(expected.errors);
+                    }
+                    if (!expected.success) historyOf(scenario).should.deep.equal(before);
+                    historyOf(scenario).should.deep.equal(expected.history);
+                    (await scenario.eventSequence.getNextSequenceNumber()).value.toString().should.equal(expected.next);
+                }
+            } finally {
+                validate.mockRestore();
+                await notifications.return?.();
+            }
+        });
+    }
+
+    it('rolls back removal in a failing setup call without results or notifications', async () => {
+        const scenario = new EventScenario({ artifacts: { eventTypes: Object.values(aliases), constraints: [LifecycleKey] } });
+        const notifications = scenario.eventSequence.appendOperations[Symbol.asyncIterator]();
+        try {
+            const first = notifications.next();
+            await scenario.given.forEventSource('A').events(new OracleDomainText('Alpha'));
+            (await first).value!.length.should.equal(1);
+            const second = notifications.next();
+            await scenario.given.forEventSource('B').events(new OracleDomainShared('Beta'));
+            (await second).value!.length.should.equal(1);
+            const before = historyOf(scenario);
+            await scenario.given.forEventSource('A').events(new OracleDomainRemoved('end'), new OracleDomainShared('Beta'))
+                .then(() => { throw new Error('Invalid setup succeeded'); }, error => {
+                    (error as Error).message.should.include('EventScenario given setup failed');
+                });
+            historyOf(scenario).should.deep.equal(before);
+            scenario.results.length.should.equal(0);
+            (await scenario.eventSequence.getNextSequenceNumber()).value.should.equal(2n);
+            const next = notifications.next();
+            (await scenario.append('C', new OracleDomainShared('Alpha'))).constraintViolations.length.should.equal(1);
+            (await next).value!.map(item => item.event.eventType.id.value).should.deep.equal(['OracleDomainShared']);
+        } finally { await notifications.return?.(); }
+    });
+
+    it('delivers only committed claim/removal events to a reactor', async () => {
+        const calls: string[] = [];
+        @reactor('lifecycle-reactor')
+        class LifecycleReactor {
+            oracleDomainText(event: OracleDomainText) { calls.push(event.key); }
+            oracleDomainRemoved(event: OracleDomainRemoved) { calls.push(event.label); }
+        }
+        const subject = new ReactorScenario(LifecycleReactor,
+            { artifacts: { eventTypes: Object.values(aliases), constraints: [LifecycleKey] } });
+        await subject.when.forEventSource('A').events(new OracleDomainText('Alpha'));
+        await subject.when.forEventSource('B').events(new OracleDomainText('Alpha'))
+            .then(() => { throw new Error('Duplicate claim delivered'); }, error => {
+                (error as Error).message.should.include('ReactorScenario action append failed');
+            });
+        calls.should.deep.equal(['Alpha']);
+        subject.results.length.should.equal(1);
+        await subject.when.forEventSource('A').events(new OracleDomainRemoved('released'));
+        await subject.when.forEventSource('B').events(new OracleDomainText('Alpha'));
+        calls.should.deep.equal(['Alpha', 'released', 'Alpha']);
+        subject.results.length.should.equal(3);
+    });
+
+    it('rejects a removal type shared by two definitions without claiming kernel semantics', async () => {
+        class FirstClaim { @field(String) key = 'Alpha'; }
+        eventType('FirstRemovalClaim')(FirstClaim);
+        class SecondClaim { @field(String) key = 'Beta'; }
+        eventType('SecondRemovalClaim')(SecondClaim);
+        class SharedRemoval { @field(String) label = 'end'; }
+        eventType('SharedRemoval')(SharedRemoval);
+        class FirstKey implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(FirstClaim, event => event.key).removedWith(SharedRemoval));
+            }
+        }
+        constraint('FirstRemovalKey')(FirstKey);
+        class SecondKey implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(SecondClaim, event => event.key).removedWith(SharedRemoval));
+            }
+        }
+        constraint('SecondRemovalKey')(SecondKey);
+        await unsupported(() => new EventScenario({ artifacts: {
+            eventTypes: [FirstClaim, SecondClaim, SharedRemoval], constraints: [FirstKey, SecondKey]
+        } }), 'Removal type shared by several definitions is not fixture-backed.');
+    });
+
+    it('rejects unresolved removal names and unproven cross-definition interactions before mutation', async () => {
+        class Missing { @field(String) label = 'missing'; }
+        eventType('MissingLifecycleRemoval')(Missing);
+        removeConstraint('NotDefined')(Missing);
+        await unsupported(() => new EventScenario({ artifacts: { eventTypes: [Missing, OracleDomainText], constraints: [LifecycleKey] } }),
+            'Unresolved removal constraint name');
+        class Other implements IConstraint {
+            define(builder: IConstraintBuilder) { builder.unique(key => key.on(OracleDomainRemoved, event => event.label)); }
+        }
+        constraint('OtherLifecycleKey')(Other);
+        await unsupported(() => new EventScenario({ artifacts: { eventTypes: Object.values(aliases), constraints: [LifecycleKey, Other] } }),
+            'Removal overlapping another validating definition');
+        const scenario = new EventScenario({ artifacts: { eventTypes: Object.values(aliases), constraints: [LifecycleKey] } });
+        (await scenario.append('A', new OracleDomainText('Alpha'))).isSuccess.should.be.true;
+        const before = historyOf(scenario);
+        const results = scenario.results;
+        await unsupported(() => scenario.appendMany([{ eventSourceId: 'A', event: new OracleDomainRemoved('end') },
+            { eventSourceId: 'B', event: new OracleDomainText('unproven!') }]), 'artifacts.constraints');
+        historyOf(scenario).should.deep.equal(before);
+        scenario.results.should.deep.equal(results);
+        (await scenario.append('B', new OracleDomainText('Alpha'))).constraintViolations.length.should.equal(1);
+    });
+});

package/testing/EventScenario.constraints.spec.ts

@@ -172,7 +172,19 @@ describe('fixture-backed unscoped constraints', () => {
         const production = compileConstraints({ eventTypes: [GlobalOnce, SelectedOnce], constraints: [] });
         production.get('ScenarioSharedOnce')!.uniqueEventType!.eventTypeIds.should.deep.equal(['GlobalOnce', 'SelectedOnce']);
         unsupported(() => new EventScenario({ artifacts: { eventTypes: [SelectedOnce] } }), 'artifacts.constraints')
-            .message.should.include('multi-type unique event cycles');
+            .message.should.include('This unique event type set and removal combination is not fixture-backed.');
+    });
+
+    it('rejects removal of a selected unique-event-type constraint at construction', () => {
+        class Once { @field(String) label = 'recorded'; }
+        eventType('OnceWithRemoval')(Once);
+        unique('OnceName')(Once);
+        class Removal { @field(String) label = 'removed'; }
+        eventType('OnceNameRemoval')(Removal);
+        removeConstraint('OnceName')(Removal);
+        const message = unsupported(() => new EventScenario({ artifacts: { eventTypes: [Once, Removal] } }), 'artifacts.constraints').message;
+        message.should.include('OnceName');
+        message.should.include('This unique event type set and removal combination is not fixture-backed.');
     });
 
     it('rejects a global removal decorator targeting a selected constraint', () => {
@@ -330,22 +342,6 @@ describe('fixture-backed unscoped constraints', () => {
         }
     });
 
-    it('rejects a fresh-source key replacement within one batch without changing results or history', async () => {
-        const subject = scenario();
-        await subject.append('A', new OracleKeyClaimed('Alpha'));
-        const history = subject.appendedEvents;
-        const results = subject.results;
-        await subject.appendMany('C', [new OracleKeyClaimed('First'), new OracleKeyShared('Second')])
-            .then(() => { throw new Error('In-batch replacement accepted'); }, error => {
-                (error instanceof UnsupportedEventSequenceOperation).should.be.true;
-                (error as Error).message.should.include('artifacts.constraints');
-                (error as Error).message.should.include('Replacing a key within one batch');
-                (error as Error).message.should.include('Use a kernel-backed test.');
-            });
-        subject.appendedEvents.should.deep.equal(history);
-        subject.results.should.deep.equal(results);
-    });
-
     it('rejects history with an unproven unique key without changing scenario state', async () => {
         const subject = scenario();
         await subject.append('A', new OracleKeyClaimed('Alpha'));
@@ -359,7 +355,7 @@ describe('fixture-backed unscoped constraints', () => {
         subject.results.length.should.equal(1);
     });
 
-    it('rejects removal, scoped, composite, case-insensitive and replacement before mutation', async () => {
+    it('rejects scoped, composite and case-insensitive configurations and unsupported keys before mutation', async () => {
         const scoped = (configure: (builder: IConstraintBuilder) => void) => {
             class InvalidConstraint implements IConstraint {
                 define(builder: IConstraintBuilder) { configure(builder); }
@@ -374,22 +370,15 @@ describe('fixture-backed unscoped constraints', () => {
         scoped(builder => builder.unique(key => key.on(OracleKeyClaimed, event => event.key).ignoreCasing()));
         scoped(builder => builder.unique(key => key.on(OracleKeyClaimed, event => event.key))
             .uniqueFor(OracleOnceRecorded));
-        class Removal { @field(String) label = 'removed'; }
-        eventType('Removal')(Removal);
-        removeConstraint('OracleKey')(Removal);
-        unsupported(() => new EventScenario({ artifacts: { eventTypes: [...types, Removal], constraints: [OracleFluentOnceConstraint] } }), 'artifacts.constraints')
-            .message.should.include('removal');
         class AnotherOnce { @field(String) label = 'second'; }
         eventType('AnotherOnce')(AnotherOnce);
         unique('OracleOnce')(AnotherOnce);
         unsupported(() => new EventScenario({ artifacts: { eventTypes: [...types, AnotherOnce], constraints: [OracleFluentOnceConstraint] } }), 'artifacts.constraints')
-            .message.should.include('multi-type unique event cycles');
+            .message.should.include('This unique event type set and removal combination is not fixture-backed.');
         const subject = scenario();
         await subject.append('A', new OracleKeyClaimed('Alpha'));
         await subject.append('B', new OracleKeyClaimed('beta'));
-        for (const action of [() => subject.append('A', new OracleKeyClaimed('different')),
-            () => subject.appendMany('A', [new OracleKeyClaimed('Alpha'), new OracleKeyClaimed('changed')]),
-            () => subject.append('C', new OracleKeyClaimed('!'))]) {
+        for (const action of [() => subject.append('C', new OracleKeyClaimed('!'))]) {
             await action().then(() => { throw new Error('Unsupported key accepted'); }, error => {
                 (error instanceof UnsupportedEventSequenceOperation).should.be.true;
                 (error as Error).message.should.include('artifacts.constraints');

package/testing/EventScenario.fixtures.spec.ts

@@ -56,7 +56,9 @@ interface Fixture {
 }
 const directory = new URL('./fixtures/', import.meta.url);
 const fixtures = readdirSync(directory).filter(name => name.endsWith('.json') &&
-    !['batches.json', 'batch-omitted-routes.json', 'batch-rollback.json', 'builders.json', 'constraints.json', 'constraints-isolation.json', 'constraints-key-domain.json'].includes(name)).map(name => ({
+    !['batches.json', 'batch-omitted-routes.json', 'batch-rollback.json', 'builders.json', 'constraints.json', 'constraints-isolation.json', 'constraints-key-domain.json',
+        'constraints-property-lifecycle.json', 'constraints-property-covered-removal.json', 'constraints-event-type-cycles.json',
+        'constraints-event-type-siblings.json'].includes(name)).map(name => ({
     name, fixture: JSON.parse(readFileSync(new URL(name, directory), 'utf8')) as Fixture
 }));
 const artifacts = { eventTypes: [OracleEventRecorded, AlternateRecorded, BoundaryRecorded], constraints: [] };

package/testing/EventScenario.rejections.spec.ts

@@ -85,7 +85,7 @@ async function rejects(action: () => Promise<unknown>, operation: string): Promi
 
 describe('when the fixture-bounded event sequence encounters unproven operations', () => {
     for (const [type, operation] of [
-        [RemovesConstraint, 'artifacts.eventTypes.constraints'], [Tagged, 'tags'],
+        [RemovesConstraint, 'artifacts.constraints'], [Tagged, 'tags'],
         [LaterGeneration, 'artifacts.eventTypes'], [Tombstone, 'artifacts.eventTypes'],
         [CommaId, 'artifacts.eventTypes.id'], [PaddedId, 'artifacts.eventTypes.id'],
         [NonAsciiPaddedId, 'artifacts.eventTypes.id']

package/testing/EventScenario.ts

@@ -77,6 +77,14 @@ export class EventScenario {
                         ...(capture.uniqueEventType?.removedWithEventTypeIds ?? [])];
                     return [...constrained, ...removedWith].some(id => id !== undefined && selectedIds.has(id));
                 })) : compiled;
+                for (const type of eventTypes) {
+                    for (const name of getRemovedConstraintNames(type)) {
+                        if (!definitions.has(name)) {
+                            throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
+                                'Unresolved removal constraint name in the selected catalog.');
+                        }
+                    }
+                }
                 constraints = new InProcessConstraints(definitions);
                 for (const [name, capture] of definitions) {
                     const ids = capture.uniqueConstraint?.eventDefinitions.map(entry => entry.eventTypeId) ??
@@ -86,7 +94,7 @@ export class EventScenario {
                         ...(capture.uniqueEventType?.removedWithEventTypeIds ?? [])];
                     if ([...ids, ...removedWith].some(id => id !== undefined && !selectedIds.has(id))) {
                         throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
-                            'Every constrained event type must be in the selected catalog.');
+                            'Every constrained event type must be in the selected catalog. Claiming and removal references must be complete.');
                     }
                     for (const entry of capture.uniqueConstraint?.eventDefinitions ?? []) {
                         const type = eventTypes.find(type => getEventTypeFor(type).id.value === entry.eventTypeId)!;