@cratis/chronicle 6.22.1 → 6.24.0

package/testing/EventScenario.constraints.spec.ts

@@ -0,0 +1,415 @@
+// 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 } from '../events/eventTypeDecorator.js';
+import { unique } from '../events/constraints/unique.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 { ReactorScenario } from './ReactorScenario.js';
+import { InProcessConstraints } from './InProcessConstraints.js';
+import { reactor } from '../reactors/reactor.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from './index.js';
+
+chai.should();
+class OracleKeyClaimed {
+    @field(String) @unique('OracleKey', 'Already claimed: {PropertyName}={PropertyValue}') key: string;
+    constructor(key: string) { this.key = key; }
+}
+eventType('OracleKeyClaimed')(OracleKeyClaimed);
+class OracleKeyShared {
+    @field(String) @unique('OracleKey') key: string;
+    constructor(key: string) { this.key = key; }
+}
+eventType('OracleKeyShared')(OracleKeyShared);
+class OracleOnceRecorded {
+    @field(String) label: string;
+    constructor(label: string) { this.label = label; }
+}
+eventType('OracleOnceRecorded')(OracleOnceRecorded);
+unique('OracleOnce')(OracleOnceRecorded);
+class BatchUniqueRecorded {
+    @field(String) @unique('BatchUniqueKey') key: string;
+    constructor(key: string) { this.key = key; }
+}
+eventType('BatchUniqueRecorded')(BatchUniqueRecorded);
+class OracleFluentOnce {
+    @field(String) label: string;
+    constructor(label: string) { this.label = label; }
+}
+eventType('OracleFluentOnce')(OracleFluentOnce);
+class OracleNamedOnce {
+    @field(String) label: string;
+    constructor(label: string) { this.label = label; }
+}
+eventType('OracleNamedOnce')(OracleNamedOnce);
+unique('OracleNamedOnce', 'Already recorded this kind of event')(OracleNamedOnce);
+class OracleFluentOnceConstraint implements IConstraint {
+    define(builder: IConstraintBuilder) { builder.uniqueFor(OracleFluentOnce, undefined, 'OracleFluentOnceConstraint'); }
+}
+constraint('OracleFluentOnceConstraint')(OracleFluentOnceConstraint);
+const types = [OracleKeyClaimed, OracleKeyShared, OracleOnceRecorded, BatchUniqueRecorded, OracleFluentOnce, OracleNamedOnce];
+const scenario = () => new EventScenario({ artifacts: { eventTypes: types, constraints: [OracleFluentOnceConstraint] } });
+type Input = { source: string; type: 'key' | 'shared' | 'once' | 'plain' | 'fluentOnce' | 'namedOnce'; value: string };
+type Outcome = { success: boolean; sequences: string[];
+    wireViolations: Array<{ EventTypeId: string; SequenceNumber: string; ConstraintType: number;
+        ConstraintName: string; Message: string; Details: Record<string, string> }>;
+    violations: Array<{ id: string; message: string; details: Record<string, string> }>;
+    errors: string[]; next: string; history: Array<{ sequence: string; source: string; type: string; value: string }> };
+type Fixture = { constraintOperations: Array<{ mode: 'single' | 'batch'; events: Input[] }>;
+    expected: { outcomes: Outcome[] } };
+const fixture = JSON.parse(readFileSync(new URL('./fixtures/constraints.json', import.meta.url), 'utf8')) as Fixture;
+const value = (input: Input) => input.type === 'key' ? new OracleKeyClaimed(input.value) :
+    input.type === 'shared' ? new OracleKeyShared(input.value) :
+        input.type === 'once' ? new OracleOnceRecorded(input.value) :
+            input.type === 'fluentOnce' ? new OracleFluentOnce(input.value) :
+                input.type === 'namedOnce' ? new OracleNamedOnce(input.value) : new BatchUniqueRecorded(input.value);
+
+const unsupported = (action: () => unknown, operation: string): UnsupportedEventSequenceOperation => {
+    try { action(); throw new Error('Expected rejection'); }
+    catch (error) {
+        (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+        (error as Error).message.should.include(operation);
+        (error as Error).message.should.include('Use a kernel-backed test.');
+        return error as UnsupportedEventSequenceOperation;
+    }
+};
+
+describe('fixture-backed unscoped constraints', () => {
+    it('matches kernel violation messages, details, sequence normalization and batch rollback', async () => {
+        const subject = scenario();
+        const notifications = subject.eventSequence.appendOperations[Symbol.asyncIterator]();
+        const validate = vi.spyOn(InProcessConstraints.prototype, 'validate');
+        let resultCount = 0;
+        try {
+            for (const [index, operation] of fixture.constraintOperations.entries()) {
+                const expected = fixture.expected.outcomes[index];
+                const nextNotification = notifications.next();
+                const results = operation.mode === 'single'
+                    ? [await subject.append(operation.events[0].source, value(operation.events[0]))]
+                    : await subject.appendMany(operation.events.map(entry => ({ eventSourceId: entry.source, event: value(entry) })));
+                const notification = (await nextNotification).value!;
+                const wireViolations = validate.mock.results.at(-1)?.value as ReturnType<InProcessConstraints['validate']>;
+                wireViolations.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;
+                resultCount += operation.events.length;
+                subject.results.length.should.equal(resultCount);
+                results.length.should.equal(operation.events.length);
+                for (const result of results) {
+                    result.isSuccess.should.equal(expected.success);
+                    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);
+                    result.sequenceNumber.value.toString().should.equal(expected.success ?
+                        expected.sequences[results.indexOf(result)] : '0');
+                    if (!expected.success) (await result.waitForCompletion()).should.deep.equal({ isSuccess: true, failedPartitions: [] });
+                }
+                subject.appendedEvents.map(item => ({ sequence: item.context.sequenceNumber.toString(),
+                    source: item.context.eventSourceId, type: item.eventType.id.value,
+                    value: item.content.key ?? item.content.label })).should.deep.equal(expected.history);
+                (await subject.eventSequence.getNextSequenceNumber()).value.toString().should.equal(expected.next);
+            }
+            subject.then.results.should.deep.equal(subject.results);
+        } finally {
+            validate.mockRestore();
+            await notifications.return?.();
+        }
+    });
+
+    it('discovers fluent constraints by default when the selected catalog omits constraints', async () => {
+        const subject = new EventScenario({ artifacts: { eventTypes: types } });
+        (await subject.append('A', new OracleFluentOnce('first'))).isSuccess.should.be.true;
+        (await subject.append('A', new OracleFluentOnce('second'))).constraintViolations[0]
+            .constraintId.should.equal('OracleFluentOnceConstraint');
+    });
+
+    it('rejects a globally discovered fluent contribution sharing a selected decorator name', () => {
+        class SelectedShared { @field(String) @unique('ScenarioSharedFromGlobal') key = 'Alpha'; }
+        eventType('SelectedShared')(SelectedShared);
+        class GlobalShared { @field(String) key = 'Alpha'; }
+        eventType('GlobalShared')(GlobalShared);
+        class GlobalSharedConstraint implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(GlobalShared, event => event.key)
+                    .withMessage('Global configured: {PropertyValue}'));
+            }
+        }
+        constraint('ScenarioSharedFromGlobal')(GlobalSharedConstraint);
+        const production = compileConstraints({ eventTypes: [SelectedShared], constraints: [GlobalSharedConstraint] });
+        production.get('ScenarioSharedFromGlobal')!.uniqueConstraint!.message.should.equal('Global configured: {PropertyValue}');
+        production.get('ScenarioSharedFromGlobal')!.uniqueConstraint!.eventDefinitions.length.should.equal(2);
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [SelectedShared] } }), 'artifacts.constraints')
+            .message.should.include('Every constrained event type must be in the selected catalog.');
+    });
+
+    it('rejects a global property decorator sharing a selected name instead of losing its message', () => {
+        class GlobalDecorated { @field(String) @unique('ScenarioSharedDecorators', 'Global message: {PropertyValue}') key = 'Alpha'; }
+        eventType('GlobalDecorated')(GlobalDecorated);
+        class SelectedDecorated { @field(String) @unique('ScenarioSharedDecorators') key = 'Alpha'; }
+        eventType('SelectedDecorated')(SelectedDecorated);
+        const production = compileConstraints({ eventTypes: [GlobalDecorated, SelectedDecorated], constraints: [] });
+        production.get('ScenarioSharedDecorators')!.uniqueConstraint!.message.should.equal('Global message: {PropertyValue}');
+        production.get('ScenarioSharedDecorators')!.uniqueConstraint!.eventDefinitions.length.should.equal(2);
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [SelectedDecorated] } }), 'artifacts.constraints')
+            .message.should.include('Every constrained event type must be in the selected catalog.');
+    });
+
+    it('rejects a same-named global class decorator as a multi-type unique event constraint', () => {
+        class GlobalOnce { @field(String) label = 'global'; }
+        eventType('GlobalOnce')(GlobalOnce);
+        unique('ScenarioSharedOnce')(GlobalOnce);
+        class SelectedOnce { @field(String) label = 'selected'; }
+        eventType('SelectedOnce')(SelectedOnce);
+        unique('ScenarioSharedOnce')(SelectedOnce);
+        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');
+    });
+
+    it('rejects a global removal decorator targeting a selected constraint', () => {
+        class SelectedClaim { @field(String) @unique('ScenarioRemovedGlobally') key = 'Alpha'; }
+        eventType('SelectedClaim')(SelectedClaim);
+        class GlobalRemoval { @field(String) label = 'removed'; }
+        eventType('GlobalRemoval')(GlobalRemoval);
+        removeConstraint('ScenarioRemovedGlobally')(GlobalRemoval);
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [SelectedClaim] } }), 'artifacts.constraints')
+            .message.should.include('removal');
+    });
+
+    it('rejects a globally discovered fluent constraint referencing a selected removal event', () => {
+        class GlobalClaim { @field(String) key = 'Alpha'; }
+        eventType('GlobalClaim')(GlobalClaim);
+        class SelectedRemoval { @field(String) label = 'removed'; }
+        eventType('SelectedRemoval')(SelectedRemoval);
+        class GlobalRemovalConstraint implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(GlobalClaim, event => event.key).removedWith(SelectedRemoval));
+            }
+        }
+        constraint('ScenarioGlobalRemoval')(GlobalRemovalConstraint);
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [SelectedRemoval] } }), 'artifacts.constraints')
+            .message.should.include('removal');
+    });
+
+    it('rejects a globally discovered constraint named by a selected removal decorator', () => {
+        class GlobalDecoratedClaim { @field(String) key = 'Alpha'; }
+        eventType('GlobalDecoratedClaim')(GlobalDecoratedClaim);
+        class SelectedDecoratedRemoval { @field(String) label = 'removed'; }
+        eventType('SelectedDecoratedRemoval')(SelectedDecoratedRemoval);
+        removeConstraint('ScenarioDecoratedGlobalRemoval')(SelectedDecoratedRemoval);
+        class DecoratedGlobalRemovalConstraint implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(GlobalDecoratedClaim, event => event.key));
+            }
+        }
+        constraint('ScenarioDecoratedGlobalRemoval')(DecoratedGlobalRemovalConstraint);
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [SelectedDecoratedRemoval] } }), 'artifacts.constraints')
+            .message.should.include('removal');
+    });
+
+    it('isolates a selected catalog from unrelated globally discovered constraints', async () => {
+        class Unrelated { @field(String) label = 'unrelated'; }
+        eventType('Unrelated')(Unrelated);
+        class UnrelatedConstraint implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(Unrelated, event => event.label).ignoreCasing());
+            }
+        }
+        constraint('UnrelatedConstraint')(UnrelatedConstraint);
+        const subject = new EventScenario({ artifacts: { eventTypes: types } });
+        (await subject.append('A', new OracleFluentOnce('first'))).isSuccess.should.be.true;
+        (await subject.append('A', new OracleFluentOnce('second'))).constraintViolations.length.should.equal(1);
+    });
+
+    it('uses the same compiler for an unscoped fluent constraint', async () => {
+        class FluentKey implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(OracleKeyClaimed, event => event.key)
+                    .on(OracleKeyShared, event => event.key)
+                    .withMessage('Already claimed: {PropertyName}={PropertyValue}'));
+            }
+        }
+        constraint('OracleKey')(FluentKey);
+        const subject = new EventScenario({ artifacts: { eventTypes: types, constraints: [FluentKey] } });
+        (await subject.append('A', new OracleKeyClaimed('Alpha'))).isSuccess.should.be.true;
+        (await subject.append('B', new OracleKeyShared('Alpha'))).constraintViolations[0]
+            .message.should.equal(fixture.expected.outcomes[2].violations[0].message);
+    });
+
+    it('passes constraints through ReactorScenario and does not deliver rejected events', async () => {
+        const calls: string[] = [];
+        @reactor('constrained-reactor')
+        class ConstrainedReactor {
+            oracleKeyClaimed(event: OracleKeyClaimed) { calls.push(event.key); }
+        }
+        const subject = new ReactorScenario(ConstrainedReactor, { artifacts: { eventTypes: types } });
+        await subject.when.forEventSource('A').events(new OracleKeyClaimed('Alpha'));
+        await subject.when.forEventSource('B').events(new OracleKeyClaimed('Alpha'))
+            .then(() => { throw new Error('Constraint violation was delivered'); }, error => {
+                (error as Error).message.should.include('ReactorScenario action append failed');
+                (error as Error).message.should.include('OracleKey');
+                (error as Error).message.should.include('Already claimed: key=Alpha');
+            });
+        calls.should.deep.equal(['Alpha']);
+        subject.results.length.should.equal(1);
+    });
+
+    it('rolls back a violating given call without publishing setup results', async () => {
+        const subject = scenario();
+        await subject.given.forEventSource('A').events(new OracleKeyClaimed('Alpha'));
+        await subject.given.forEventSource('B').events(new OracleOnceRecorded('one'), new OracleKeyShared('Alpha'))
+            .then(() => { throw new Error('Violated setup accepted'); }, error => {
+                (error as Error).message.should.include('EventScenario given setup failed');
+                (error as Error).message.should.include('Already claimed: key=Alpha');
+            });
+        subject.appendedEvents.length.should.equal(1);
+        subject.results.length.should.equal(0);
+        (await subject.eventSequence.getNextSequenceNumber()).value.should.equal(1n);
+    });
+
+    it('rejects unproven numeric constrained schemas at construction', () => {
+        class NumericConstrained { @field(Number) @unique('NumberKey') key = 1; }
+        eventType('NumericConstrained')(NumericConstrained);
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [NumericConstrained] } }), 'artifacts.constraints');
+    });
+
+    it('rejects a selected constraint covering an event outside the selected catalog', () => {
+        class OutOfCatalog implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(OracleFluentOnce, event => event.label).on(OracleKeyShared, event => event.key));
+            }
+        }
+        constraint('OutOfCatalog')(OutOfCatalog);
+        const subject = scenario();
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: [OracleFluentOnce], constraints: [OutOfCatalog] } }),
+            'artifacts.constraints').message.should.include('Every constrained event type must be in the selected catalog.');
+        subject.results.length.should.equal(0);
+        subject.appendedEvents.length.should.equal(0);
+    });
+
+    it('reads a getter-backed selected constraint catalog only once', () => {
+        class OutOfCatalog implements IConstraint {
+            define(builder: IConstraintBuilder) {
+                builder.unique(key => key.on(OracleFluentOnce, event => event.label).on(OracleKeyShared, event => event.key));
+            }
+        }
+        constraint('GetterOutOfCatalog')(OutOfCatalog);
+        let reads = 0;
+        const artifacts = { eventTypes: [OracleFluentOnce], get constraints() { reads++; return reads === 1 ? [OutOfCatalog] : undefined; } };
+        unsupported(() => new EventScenario({ artifacts }), 'artifacts.constraints');
+        reads.should.equal(1);
+    });
+
+    it('rejects a selected constraint without @constraint metadata', () => {
+        class MissingMetadata implements IConstraint { define(_builder: IConstraintBuilder) {} }
+        unsupported(() => new EventScenario({ artifacts: { eventTypes: types, constraints: [MissingMetadata] } }),
+            'artifacts.constraints').message.should.include('Every selected constraint must have @constraint metadata.');
+    });
+
+    it('rejects overlapping property constraints and property plus event-type constraints at construction', () => {
+        class TwoProperties {
+            @field(String) @unique('FirstProperty') first = 'Alpha';
+            @field(String) @unique('SecondProperty') second = 'Beta';
+        }
+        eventType('TwoProperties')(TwoProperties);
+        class PropertyAndType { @field(String) @unique('PropertyName') name = 'Alpha'; }
+        eventType('PropertyAndType')(PropertyAndType);
+        unique('ClassName')(PropertyAndType);
+        for (const type of [TwoProperties, PropertyAndType]) {
+            unsupported(() => new EventScenario({ artifacts: { eventTypes: [type, OracleFluentOnce], constraints: [OracleFluentOnceConstraint] } }),
+                'artifacts.constraints').message.should.include('Overlapping 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'));
+        const history = subject.appendedEvents;
+        const incoming = subject.appendedEvents;
+        history[0].content.key = 1;
+        const compiled = compileConstraints({ eventTypes: types, constraints: [OracleFluentOnceConstraint] });
+        const checker = new InProcessConstraints(compiled);
+        unsupported(() => checker.validate(history, incoming), 'artifacts.constraints');
+        subject.appendedEvents[0].content.key.should.equal('Alpha');
+        subject.results.length.should.equal(1);
+    });
+
+    it('rejects removal, scoped, composite, case-insensitive and replacement before mutation', async () => {
+        const scoped = (configure: (builder: IConstraintBuilder) => void) => {
+            class InvalidConstraint implements IConstraint {
+                define(builder: IConstraintBuilder) { configure(builder); }
+            }
+            constraint('ScopedOrComposite')(InvalidConstraint);
+            unsupported(() => new EventScenario({ artifacts: { eventTypes: types, constraints: [InvalidConstraint] } }), 'artifacts.constraints');
+        };
+        scoped(builder => builder.perEventStreamId().unique(key => key.on(OracleKeyClaimed, event => event.key)));
+        scoped(builder => builder.perEventStreamType().unique(key => key.on(OracleKeyClaimed, event => event.key)));
+        scoped(builder => builder.perEventSourceType().unique(key => key.on(OracleKeyClaimed, event => event.key)));
+        scoped(builder => builder.unique(key => key.on(OracleKeyClaimed, event => event.key, event => event.key)));
+        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');
+        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('!'))]) {
+            await action().then(() => { throw new Error('Unsupported key accepted'); }, error => {
+                (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+                (error as Error).message.should.include('artifacts.constraints');
+                (error as Error).message.should.include('Use a kernel-backed test.');
+            });
+            subject.appendedEvents.length.should.equal(2);
+            subject.results.length.should.equal(2);
+        }
+    });
+
+    it('wraps throwing and duplicate fluent definitions as unsupported compiler errors', () => {
+        class Throws implements IConstraint { define(_builder: IConstraintBuilder) { throw new Error('Invalid definition'); } }
+        constraint('Throws')(Throws);
+        class First implements IConstraint { define(builder: IConstraintBuilder) { builder.uniqueFor(OracleOnceRecorded); } }
+        class Second implements IConstraint { define(builder: IConstraintBuilder) { builder.uniqueFor(OracleOnceRecorded); } }
+        constraint('Duplicate')(First);
+        constraint('Duplicate')(Second);
+        for (const constraints of [[Throws], [First, Second]]) {
+            unsupported(() => new EventScenario({ artifacts: { eventTypes: types, constraints } }),
+                'artifacts.constraints').message.should.include('compiler');
+        }
+    });
+});

package/testing/EventScenario.fixtures.spec.ts

@@ -56,7 +56,7 @@ 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'].includes(name)).map(name => ({
+    !['batches.json', 'batch-omitted-routes.json', 'batch-rollback.json', 'builders.json', 'constraints.json', 'constraints-isolation.json', 'constraints-key-domain.json'].includes(name)).map(name => ({
     name, fixture: JSON.parse(readFileSync(new URL(name, directory), 'utf8')) as Fixture
 }));
 const artifacts = { eventTypes: [OracleEventRecorded, AlternateRecorded, BoundaryRecorded], constraints: [] };
@@ -188,9 +188,11 @@ describe('when appending against committed kernel event fixtures', () => {
     });
 
 
-    it('should reject unproven schemas, event registrations and constraints before appending', async () => {
+    it('should reject unproven schemas and registrations but discover supported constraints', async () => {
         unsupported(() => new EventScenario({ artifacts: { eventTypes: [UnprovenNumber] }, constraints: 'disabled' }), 'schema');
-        unsupported(() => new EventScenario({ artifacts: { eventTypes: [ConstrainedEvent] } }), 'constraints');
+        const constrained = new EventScenario({ artifacts: { eventTypes: [ConstrainedEvent] } });
+        (await constrained.append('A', new ConstrainedEvent())).isSuccess.should.be.true;
+        (await constrained.append('A', new ConstrainedEvent())).constraintViolations.length.should.equal(1);
         unsupported(() => new EventScenario({ artifacts }), 'empty constraint catalog');
         unsupported(() => new EventScenario({ artifacts, constraints: 'disabled', eventStore: 'other-store' }), 'eventStore');
         const scenario = makeScenario();

package/testing/EventScenario.rejections.spec.ts

@@ -28,7 +28,7 @@ class RemovesConstraint {
     @field(String) name = 'value';
 }
 eventType('RemovesConstraint')(RemovesConstraint);
-removeConstraint('name')(RemovesConstraint);
+removeConstraint('OtherName')(RemovesConstraint);
 class Tagged {
     @field(String) name = 'value';
 }
@@ -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 [
-        [PropertyUnique, 'artifacts.constraints'], [RemovesConstraint, 'artifacts.eventTypes.constraints'], [Tagged, 'tags'],
+        [RemovesConstraint, 'artifacts.eventTypes.constraints'], [Tagged, 'tags'],
         [LaterGeneration, 'artifacts.eventTypes'], [Tombstone, 'artifacts.eventTypes'],
         [CommaId, 'artifacts.eventTypes.id'], [PaddedId, 'artifacts.eventTypes.id'],
         [NonAsciiPaddedId, 'artifacts.eventTypes.id']
@@ -93,11 +93,18 @@ describe('when the fixture-bounded event sequence encounters unproven operations
         it(`should reject ${type.name} during catalog validation`, () => {
             const subject = scenario();
             rejected(() => new EventScenario({ artifacts: { eventTypes: [type] },
-                ...(type === PropertyUnique || type === RemovesConstraint ? {} : { constraints: 'disabled' as const }) }), operation);
+                ...(type === RemovesConstraint ? {} : { constraints: 'disabled' as const }) }), operation);
             clean(subject);
         });
     }
 
+    it('should discover property-level uniqueness instead of silently discarding it', async () => {
+        const subject = new EventScenario({ artifacts: { eventTypes: [PropertyUnique] } });
+        (await subject.append('A', new PropertyUnique())).isSuccess.should.be.true;
+        (await subject.append('B', new PropertyUnique())).constraintViolations[0].constraintId.should.equal('name');
+        subject.appendedEvents.length.should.equal(1);
+    });
+
     it('should reject duplicate event IDs in the catalog', () => {
         const subject = scenario();
         rejected(() => new EventScenario({ artifacts: { eventTypes: [Recorded, DuplicateId] }, constraints: 'disabled' }), 'artifacts.eventTypes');

package/testing/EventScenario.ts

@@ -3,6 +3,7 @@
 
 import { DefaultClientArtifactsProvider } from '../artifacts/DefaultClientArtifactsProvider.js';
 import { TypeDiscoverer } from '../types/TypeDiscoverer.js';
+import { TypeIntrospector } from '../types/TypeIntrospector.js';
 import type { AppendOptions } from '../eventSequences/AppendOptions.js';
 import type { AppendResult } from '../eventSequences/AppendResult.js';
 import type { EventForEventSourceId } from '../eventSequences/EventForEventSourceId.js';
@@ -10,8 +11,12 @@ import type { AppendedEvent } from '../events/AppendedEvent.js';
 import type { IEventSequence } from '../eventSequences/IEventSequence.js';
 import type { IEventLog } from '../eventSequences/IEventLog.js';
 import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
-import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { getEventTypeFor, getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { compileConstraints } from '../events/constraints/Constraints.js';
 import { getUniqueEventMetadata, getUniquePropertyMetadata } from '../events/constraints/unique.js';
+import { getRemovedConstraintNames } from '../events/constraints/removeConstraint.js';
+import { getConstraintMetadata } from '../events/constraints/constraint.js';
+import { InProcessConstraints } from './InProcessConstraints.js';
 import type { EventScenarioOptions } from './EventScenarioOptions.js';
 import { EventScenarioGivenBuilder } from './EventScenarioGivenBuilder.js';
 import { EventScenarioWhenBuilder } from './EventScenarioWhenBuilder.js';
@@ -19,6 +24,11 @@ import { InProcessEventSequence } from './InProcessEventSequence.js';
 import { registerScenarioSeed } from './EventScenarioSeed.js';
 import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOperation.js';
 
+function hasConstraintDecorators(type: Function): boolean {
+    return getUniqueEventMetadata(type) !== undefined || getRemovedConstraintNames(type).length > 0 ||
+        TypeIntrospector.getTrackedProperties(type).some(property => getUniquePropertyMetadata(type, property) !== undefined);
+}
+
 /** A kernel-free, fixture-bounded append scenario. No observer runs automatically. */
 export class EventScenario {
     readonly eventSequence: IEventSequence;
@@ -26,25 +36,76 @@ export class EventScenario {
     readonly when: EventScenarioWhenBuilder;
 
     constructor(options: EventScenarioOptions = {}) {
-        const artifacts = options.artifacts ?? new DefaultClientArtifactsProvider(TypeDiscoverer.default);
+        const selectedArtifacts = options.artifacts;
+        const selectedConstraints = selectedArtifacts?.constraints;
+        const artifacts = selectedArtifacts ?? new DefaultClientArtifactsProvider(TypeDiscoverer.default);
         const eventTypes = [...artifacts.eventTypes];
-        if (options.artifacts?.constraints?.length === 0 && options.constraints !== 'disabled') {
+        if (selectedConstraints?.length === 0 && options.constraints !== 'disabled') {
             throw new UnsupportedEventSequenceOperation('artifacts.constraints', 'empty constraint catalog',
                 'An empty selected catalog cannot silently disable constraint discovery; set constraints: disabled explicitly.');
         }
-        const discovered = options.artifacts?.constraints ?? new DefaultClientArtifactsProvider(TypeDiscoverer.default).constraints;
-        if (options.constraints !== 'disabled' && (discovered.length || eventTypes.some(type => {
-            const metadata = getEventTypeMetadata(type);
-            return getUniqueEventMetadata(type) || [...(metadata?.members.keys() ?? [])].some(key => getUniquePropertyMetadata(type, key));
-        }))) {
-            throw new UnsupportedEventSequenceOperation('artifacts.constraints', discovered.map(type => type.name).join(', ') || 'event metadata',
-                'Constraint definitions are rejected until kernel-backed constraint fixtures are available.');
+        const discoveredArtifacts = selectedArtifacts && selectedConstraints === undefined
+            ? new DefaultClientArtifactsProvider(TypeDiscoverer.default) : undefined;
+        const discovered = selectedConstraints ?? discoveredArtifacts?.constraints ?? artifacts.constraints;
+        let constraints: InProcessConstraints | undefined;
+        if (options.constraints !== 'disabled') {
+            for (const type of discovered ?? []) {
+                if (!getConstraintMetadata(type)) throw new UnsupportedEventSequenceOperation('artifacts.constraints', type.name,
+                    'Every selected constraint must have @constraint metadata.');
+            }
+            try {
+                // Keep global decorator contributions. A shadowed ID is accepted only when neither
+                // constructor has constraint decorators, so either one compiles to the same constraints.
+                const compiledEventTypes = [...new Set([...(discoveredArtifacts?.eventTypes ?? []), ...eventTypes])];
+                const constructorsById = new Map<string, (typeof eventTypes)[number]>();
+                for (const type of compiledEventTypes) {
+                    const id = getEventTypeFor(type).id.value;
+                    const previous = constructorsById.get(id);
+                    if (previous && previous !== type && (hasConstraintDecorators(previous) || hasConstraintDecorators(type))) {
+                        throw new UnsupportedEventSequenceOperation('artifacts.eventTypes', id,
+                            'Conflicting constructors share an event type ID; constraint discovery cannot choose one.');
+                    }
+                    constructorsById.set(id, type);
+                }
+                const compiled = compileConstraints({ eventTypes: [...constructorsById.values()], constraints: discovered ?? [] });
+                const selectedIds = new Set(eventTypes.map(type => getEventTypeFor(type).id.value));
+                const definitions = discoveredArtifacts ? new Map([...compiled].filter(([, capture]) => {
+                    const constrained = capture.uniqueConstraint?.eventDefinitions.map(entry => entry.eventTypeId) ??
+                        capture.uniqueEventType?.eventTypeIds ?? [capture.uniqueEventType?.eventTypeId];
+                    const removedWith = [...(capture.uniqueConstraint?.removedWithEventTypeIds ?? []),
+                        capture.uniqueConstraint?.removedWithEventTypeId,
+                        ...(capture.uniqueEventType?.removedWithEventTypeIds ?? [])];
+                    return [...constrained, ...removedWith].some(id => id !== undefined && selectedIds.has(id));
+                })) : compiled;
+                constraints = new InProcessConstraints(definitions);
+                for (const [name, capture] of definitions) {
+                    const ids = capture.uniqueConstraint?.eventDefinitions.map(entry => entry.eventTypeId) ??
+                        capture.uniqueEventType?.eventTypeIds ?? [capture.uniqueEventType?.eventTypeId];
+                    const removedWith = [...(capture.uniqueConstraint?.removedWithEventTypeIds ?? []),
+                        capture.uniqueConstraint?.removedWithEventTypeId,
+                        ...(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.');
+                    }
+                    for (const entry of capture.uniqueConstraint?.eventDefinitions ?? []) {
+                        const type = eventTypes.find(type => getEventTypeFor(type).id.value === entry.eventTypeId)!;
+                        if (!['string', 'boolean'].includes(getEventTypeMetadata(type)?.schema.properties?.[entry.properties[0]]?.type ?? '')) {
+                            throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
+                                'The constrained property must be a schema-backed string or boolean.');
+                        }
+                    }
+                }
+            } catch (error) {
+                if (error instanceof UnsupportedEventSequenceOperation) throw error;
+                throw new UnsupportedEventSequenceOperation('artifacts.constraints', 'compiler', `Invalid constraint definition: ${String(error)}.`);
+            }
         }
         if (artifacts.eventTypeMigrations?.length) {
             throw new UnsupportedEventSequenceOperation('artifacts.eventTypeMigrations', artifacts.eventTypeMigrations.map(type => type.name).join(', '),
                 'Migrations are not fixture-backed.');
         }
-        const sequence = new InProcessEventSequence(options, eventTypes);
+        const sequence = new InProcessEventSequence(options, eventTypes, constraints);
         this.eventSequence = sequence;
         registerScenarioSeed(this, (source, events) => sequence.seed(source, events));
         this.given = new EventScenarioGivenBuilder(this);