@cratis/chronicle 6.23.0 → 6.25.0

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.constraint-values.spec.ts

@@ -0,0 +1,199 @@
+// 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 { ConceptAs, field } from '@cratis/fundamentals';
+import { eventType, getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { compileConstraints } from '../events/constraints/Constraints.js';
+import { unique } from '../events/constraints/unique.js';
+import { constraint } from '../events/constraints/constraint.js';
+import type { IConstraint } from '../events/constraints/IConstraint.js';
+import type { IConstraintBuilder } from '../events/constraints/IConstraintBuilder.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from './index.js';
+import { InProcessConstraints } from './InProcessConstraints.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 OracleDomainFlag {
+    @field(Boolean) key: boolean;
+    constructor(key: boolean) { this.key = key; }
+}
+eventType('OracleDomainFlag')(OracleDomainFlag);
+class TextKey implements IConstraint {
+    define(builder: IConstraintBuilder) {
+        builder.unique(key => key.on(OracleDomainText, event => event.key).on(OracleDomainShared, event => event.key)
+            .withMessage('Taken: {PropertyValue}'));
+    }
+}
+constraint('OracleDomainKey')(TextKey);
+class ScalarKey implements IConstraint {
+    define(builder: IConstraintBuilder) {
+        builder.unique(key => key.on(OracleDomainText, event => event.key).on(OracleDomainShared, event => event.key)
+            .on(OracleDomainFlag, event => event.key).withMessage('Taken: {PropertyValue}'));
+    }
+}
+constraint('OracleDomainKey')(ScalarKey);
+
+type Input = { source: string; type: 'string' | 'shared' | 'boolean'; value: string | boolean;
+    sourceType?: string; streamType?: string; streamId?: string };
+type Routing = { sourceType?: string; streamType?: string; streamId?: string };
+type History = { sequence: string; source: string; sourceType: string; streamType: string; streamId: string;
+    type: string; content: { key: string | boolean }; hash: string };
+type Outcome = { success: boolean; sequences: string[]; violations: Array<{ id: string; message: string; details: Record<string, string> }>;
+    wireViolations: Array<{ EventTypeId: string; SequenceNumber: string; ConstraintType: number;
+        ConstraintName: string; Message: string; Details: Record<string, string> }>;
+    errors: string[]; history: History[]; next: string };
+type Fixture = { isolatedConstraintOperations: Array<{ mode: 'single' | 'batch'; events: Input[]; options?: Routing }>;
+    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 }>;
+    expected: { outcomes: Outcome[] } };
+const eventTypes = [OracleDomainText, OracleDomainShared, OracleDomainFlag];
+const aliases = { string: OracleDomainText, shared: OracleDomainShared, boolean: OracleDomainFlag };
+const aliasesById = Object.fromEntries(Object.entries(aliases).map(([alias, type]) => [getEventTypeMetadata(type)!.eventType.id.value, alias]));
+const load = (name: string): Fixture => JSON.parse(readFileSync(new URL(`./fixtures/${name}.json`, import.meta.url), 'utf8')) as Fixture;
+const event = (entry: Input) => entry.type === 'string' ? new OracleDomainText(entry.value as string) :
+    entry.type === 'shared' ? new OracleDomainShared(entry.value as string) : new OracleDomainFlag(entry.value as boolean);
+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 { key: string | boolean }, hash: entry.context.hash
+}));
+
+describe('fixture-backed unique scalar values', () => {
+    for (const name of ['constraints-isolation', 'constraints-key-domain']) {
+        it(`matches the packaged kernel ${name} after every operation`, async () => {
+            const fixture = load(name);
+            const constraints = [name === 'constraints-isolation' ? TextKey : ScalarKey];
+            const compiled = compileConstraints({ eventTypes, constraints });
+            Object.fromEntries(Object.entries(aliases).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);
+            [...compiled].map(([key, capture]) => ({
+                kind: 'uniqueProperty', name: key,
+                events: capture.uniqueConstraint!.eventDefinitions.map(entry => ({ type: aliasesById[entry.eventTypeId], properties: entry.properties })),
+                ignoreCasing: capture.uniqueConstraint!.ignoreCasing,
+                removedWithEventTypeIds: capture.uniqueConstraint!.removedWithEventTypeIds ?? [],
+                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, 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 resultCount = scenario.results.length;
+                    const nextNotification = notifications.next();
+                    const results = operation.mode === 'single'
+                        ? [await scenario.append(operation.events[0].source, event(operation.events[0]))]
+                        : await scenario.appendMany(operation.events.map(entry => ({ eventSourceId: entry.source, event: event(entry),
+                            eventSourceType: entry.sourceType ?? operation.options?.sourceType,
+                            eventStreamType: entry.streamType ?? operation.options?.streamType,
+                            eventStreamId: entry.streamId ?? operation.options?.streamId })));
+                    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);
+                        scenario.results.length.should.equal(resultCount + operation.events.length);
+                    }
+                    historyOf(scenario).should.deep.equal(expected.history);
+                    (await scenario.eventSequence.getNextSequenceNumber()).value.toString().should.equal(expected.next);
+                }
+            } finally {
+                validate.mockRestore();
+                await notifications.return?.();
+            }
+        });
+    }
+
+    it('accepts serialized unconstrained concepts and dates but rejects a constrained date', async () => {
+        class ScenarioLabel extends ConceptAs<string> { static readonly valueType = String; }
+        class UnconstrainedValue {
+            @field(ScenarioLabel) concept = new ScenarioLabel('example');
+            @field(String) date = new Date('2025-01-02T03:04:05.000Z');
+        }
+        eventType('OracleUnconstrainedValue')(UnconstrainedValue);
+        class ConstrainedValue {
+            @field(String) @unique('OracleConstrainedValue') key = new Date('2025-01-02T03:04:05.000Z');
+        }
+        eventType('OracleConstrainedValue')(ConstrainedValue);
+        const scenario = new EventScenario({ artifacts: { eventTypes: [UnconstrainedValue, ConstrainedValue] } });
+        const date = new Date('2025-01-02T03:04:05.000Z');
+        (await scenario.append('A', new UnconstrainedValue())).isSuccess.should.be.true;
+        scenario.appendedEvents[0].content.should.deep.equal({ concept: 'example', date: date.toISOString() });
+        await scenario.append('B', new ConstrainedValue()).then(() => { throw new Error('Constrained date accepted'); }, error => {
+            (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+            (error as Error).message.should.include('append.content');
+            (error as Error).message.should.include('Use a kernel-backed test.');
+        });
+        scenario.appendedEvents.length.should.equal(1);
+        scenario.results.length.should.equal(1);
+    });
+
+    it('rejects conversions and strings outside the captured domain without changing state', async () => {
+        const scenario = new EventScenario({ artifacts: { eventTypes: [OracleDomainText, OracleDomainShared, OracleDomainFlag], constraints: [ScalarKey] } });
+        (await scenario.append('A', new OracleDomainText('0'))).isSuccess.should.be.true;
+        const before = historyOf(scenario);
+        const results = scenario.results;
+        const unprovenKeys = ['!', '#', '%', '&', "'", '(', ')', '*', '+', ',', '/', ';', '<', '=', '>', '?', '[', ']', '^', '`', '~'];
+        const invalidContent: unknown[] = [1, 0, 1.5, undefined, [], {}, new Date(), 'É', 'e\u0301', '"', '\\', '\n'];
+        // The production serializer throws on null before checkedContent can run.
+        for (const [value, operation] of [
+            ...unprovenKeys.map(value => [value, 'artifacts.constraints']),
+            ...invalidContent.map(value => [value, 'append.content']),
+            [null, 'append.serialization']
+        ] as Array<[unknown, string]>) {
+            const bad = new OracleDomainText('valid');
+            Object.assign(bad, { key: value });
+            await scenario.append('B', bad).then(() => { throw new Error('Unsupported value accepted'); }, error => {
+                (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+                (error as Error).message.should.include(operation, `value: ${JSON.stringify(value)}; error: ${(error as Error).message}`);
+                (error as Error).message.should.include('Use a kernel-backed test.');
+            });
+            historyOf(scenario).should.deep.equal(before);
+            scenario.results.should.deep.equal(results);
+            (await scenario.eventSequence.getNextSequenceNumber()).value.should.equal(1n);
+        }
+        const wrong = new OracleDomainFlag(true);
+        Object.assign(wrong, { key: 'true' });
+        await scenario.appendMany([{ eventSourceId: 'C', event: new OracleDomainText('new') },
+            { eventSourceId: 'D', event: wrong }]).then(() => { throw new Error('Mismatched batch accepted'); }, error => {
+            (error instanceof UnsupportedEventSequenceOperation).should.be.true;
+            (error as Error).message.should.include('appendMany.content');
+            (error as Error).message.should.include('Use a kernel-backed test.');
+        });
+        historyOf(scenario).should.deep.equal(before);
+        scenario.results.should.deep.equal(results);
+    });
+});

package/testing/EventScenario.constraints.spec.ts

@@ -175,6 +175,18 @@ describe('fixture-backed unscoped constraints', () => {
             .message.should.include('multi-type unique event cycles');
     });
 
+    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('Removal');
+        message.should.include('Use a kernel-backed test.');
+    });
+
     it('rejects a global removal decorator targeting a selected constraint', () => {
         class SelectedClaim { @field(String) @unique('ScenarioRemovedGlobally') key = 'Alpha'; }
         eventType('SelectedClaim')(SelectedClaim);
@@ -276,10 +288,10 @@ describe('fixture-backed unscoped constraints', () => {
         (await subject.eventSequence.getNextSequenceNumber()).value.should.equal(1n);
     });
 
-    it('rejects non-string constrained schemas at construction', () => {
-        class BoolConstrained { @field(Boolean) @unique('Flag') active = true; }
-        eventType('BoolConstrained')(BoolConstrained);
-        unsupported(() => new EventScenario({ artifacts: { eventTypes: [BoolConstrained] } }), 'artifacts.constraints');
+    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', () => {
@@ -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,11 +370,6 @@ 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);
@@ -387,11 +378,10 @@ describe('fixture-backed unscoped constraints', () => {
         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');
                 (error as Error).message.should.include('Use a kernel-backed test.');
             });
             subject.appendedEvents.length.should.equal(2);

package/testing/EventScenario.fixtures.spec.ts

@@ -56,7 +56,8 @@ 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'].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'].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,13 +94,13 @@ 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)!;
-                        if (getEventTypeMetadata(type)?.schema.properties?.[entry.properties[0]]?.type !== 'string') {
+                        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.');
+                                'The constrained property must be a schema-backed string or boolean.');
                         }
                     }
                 }