@cratis/chronicle 6.38.0 → 6.40.0

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

@@ -231,6 +231,6 @@ describe('fixture-backed unique event type cycles', () => {
         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.');
+        } }), 'artifacts.eventTypes.schema (FieldlessRemoval)', 'Only unclassified string, boolean, numeric, Guid, date and object fields are supported.');
     });
 });

package/testing/EventScenario.constraints.spec.ts

@@ -288,10 +288,12 @@ describe('fixture-backed unscoped constraints', () => {
         (await subject.eventSequence.getNextSequenceNumber()).value.should.equal(1n);
     });
 
-    it('rejects unproven numeric constrained schemas at construction', () => {
+    it('accepts fixture-backed safe-integer constrained schemas', async () => {
         class NumericConstrained { @field(Number) @unique('NumberKey') key = 1; }
         eventType('NumericConstrained')(NumericConstrained);
-        unsupported(() => new EventScenario({ artifacts: { eventTypes: [NumericConstrained] } }), 'artifacts.constraints');
+        const subject = new EventScenario({ artifacts: { eventTypes: [NumericConstrained] } });
+        (await subject.append('A', new NumericConstrained())).isSuccess.should.be.true;
+        (await subject.append('B', new NumericConstrained())).isSuccess.should.be.false;
     });
 
     it('rejects a selected constraint covering an event outside the selected catalog', () => {

package/testing/EventScenario.fixtures.spec.ts

@@ -31,10 +31,10 @@ class BoundaryRecorded {
 }
 eventType('BoundaryRecorded')(BoundaryRecorded);
 class UnknownEvent {}
-class UnprovenNumber {
-    @field(Number) amount = 1;
+class UnprovenArray {
+    @field(Array, { genericArguments: [Number] }) amounts = [1];
 }
-eventType('UnprovenNumber')(UnprovenNumber);
+eventType('UnprovenArray')(UnprovenArray);
 class ConstrainedEvent {
     @field(String) value = 'value';
 }
@@ -59,7 +59,7 @@ 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',
         'constraints-property-lifecycle.json', 'constraints-property-covered-removal.json', 'constraints-event-type-cycles.json',
         'constraints-event-type-siblings.json', 'constraints-composite.json',
-        'constraints-ignore-casing.json', 'constraints-scopes.json'].includes(name)).map(name => ({
+        'constraints-ignore-casing.json', 'constraints-scopes.json', 'constraints-field-types.json'].includes(name)).map(name => ({
     name, fixture: JSON.parse(readFileSync(new URL(name, directory), 'utf8')) as Fixture
 }));
 const artifacts = { eventTypes: [OracleEventRecorded, AlternateRecorded, BoundaryRecorded], constraints: [] };
@@ -192,7 +192,7 @@ describe('when appending against committed kernel event fixtures', () => {
 
 
     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: [UnprovenArray] }, constraints: 'disabled' }), 'schema');
         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);

package/testing/EventScenario.ts

@@ -85,7 +85,8 @@ export class EventScenario {
                         }
                     }
                 }
-                constraints = new InProcessConstraints(definitions);
+                constraints = new InProcessConstraints(definitions, new Map(eventTypes.map(type =>
+                    [getEventTypeFor(type).id.value, getEventTypeMetadata(type)!.schema])));
                 for (const [name, capture] of definitions) {
                     const ids = capture.uniqueConstraint?.eventDefinitions.map(entry => entry.eventTypeId) ??
                         capture.uniqueEventType?.eventTypeIds ?? [capture.uniqueEventType?.eventTypeId];
@@ -106,22 +107,32 @@ export class EventScenario {
                     }
                     for (const entry of capture.uniqueConstraint?.eventDefinitions ?? []) {
                         const type = eventTypes.find(type => getEventTypeFor(type).id.value === entry.eventTypeId)!;
-                        const schemaTypes = entry.properties.map(property => getEventTypeMetadata(type)?.schema.properties?.[property]?.type ?? '');
-                        if (scoped && schemaTypes.some(schemaType => schemaType !== 'string')) {
+                        const schemas = entry.properties.map(property => getEventTypeMetadata(type)?.schema.properties?.[property]);
+                        const plainStrings = schemas.every(schema => schema?.type === 'string' && schema.format === undefined);
+                        if (scoped && !plainStrings) {
                             throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
                                 'Scoped property keys must be schema-backed strings.');
                         }
-                        if (entry.properties.length === 1 && !['string', 'boolean'].includes(schemaTypes[0])) {
+                        for (const schema of schemas) {
+                            const supported = schema?.type === 'boolean' && schema.format === undefined ||
+                                schema?.type === 'string' && (schema.format === undefined || schema.format === 'guid') ||
+                                schema?.type === 'number' && (schema.format === undefined || schema.format === 'double');
+                            if (!supported) throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
+                                `Unique keys with schema ${schema?.type ?? 'missing'}/${schema?.format ?? 'unformatted'} are not fixture-backed; date, object and other numeric formats require a kernel-backed test.`);
+                        }
+                        const extendedKey = schemas.some(schema => schema?.type === 'number' || schema?.format === 'guid');
+                        if (extendedKey && (definitions.size !== 1 || capture.uniqueConstraint!.eventDefinitions.length !== 1 ||
+                            removedWith.some(id => id !== undefined))) {
                             throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
-                                'The constrained property must be a schema-backed string or boolean.');
+                                'Guid and numeric keys require one isolated definition covering one event type without removers; shared definitions and removal combinations are not fixture-backed.');
                         }
                         // constraints-ignore-casing.json captures folded string keys only.
-                        if (capture.uniqueConstraint!.ignoreCasing && schemaTypes.some(schemaType => schemaType !== 'string')) {
+                        if (capture.uniqueConstraint!.ignoreCasing && !plainStrings) {
                             throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
                                 'Case-insensitive keys must be schema-backed strings.');
                         }
                         // constraints-composite.json captures string components only.
-                        if (entry.properties.length > 1 && schemaTypes.some(schemaType => schemaType !== 'string')) {
+                        if (entry.properties.length > 1 && !plainStrings) {
                             throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
                                 'Every property of a composite key must be a schema-backed string.');
                         }

package/testing/InProcessConstraints.ts

@@ -7,6 +7,7 @@ import type { AppendedEvent } from '../events/AppendedEvent.js';
 import type { ConstraintCapture } from '../events/constraints/ConstraintBuilder.js';
 import { resolveConstraintMessage } from '../events/constraints/Constraints.js';
 import type { ConstraintViolation } from '../eventSequences/ConstraintViolation.js';
+import type { JsonSchema } from '../schemas/JsonSchema.js';
 import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOperation.js';
 import { eventTypeScopeKey, propertyScopeKey, scopeIndex } from './ConstraintScope.js';
 
@@ -16,7 +17,18 @@ const unavailable = '18446744073709551615';
 // Only the key characters captured by the packaged oracle, not every valid event-content character.
 const provenString = /^[A-Za-z0-9 .@_:\-|{}$\u00e9]*$/;
 
-function kernelKeyString(value: unknown, name: string): string {
+function kernelKeyString(value: unknown, name: string, schema?: JsonSchema): string {
+    // constraints-field-types.json: the kernel converts Guid keys before comparing or reporting them.
+    if (schema?.format === 'guid') {
+        if (typeof value === 'string' && /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(value)) return value.toLowerCase();
+        throw new UnsupportedEventSequenceOperation('artifacts.constraints', name, 'Only dashed Guid keys are fixture-backed.');
+    }
+    // Avoid .NET floating-point formatting, exponent spelling and JavaScript precision loss.
+    if (schema?.type === 'number') {
+        if (typeof value === 'number' && Number.isSafeInteger(value)) return String(value);
+        throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
+            'Only safe-integer numeric keys are fixture-backed; fractional, exponential and unsafe-integer comparisons require a kernel-backed test.');
+    }
     if (typeof value === 'string' && provenString.test(value)) return value;
     if (typeof value === 'boolean') return value ? 'True' : 'False';
     throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
@@ -35,10 +47,10 @@ type Claim = { key: string; parts: Array<{ property: string; raw: string }> };
  * (UniqueConstraintDefinitionExtensions.GetPropertiesAndValues/GetValue at Chronicle 8fe5d30). Not a tuple:
  * ['a-b', 'c'] and ['a', 'b-c'] claim the same key, as constraints-composite.json captures.
  */
-function claimOf(name: string, unique: UniqueCapture, eventTypeId: string, content: Record<string, unknown>): Claim | undefined {
+function claimOf(name: string, unique: UniqueCapture, eventTypeId: string, content: Record<string, unknown>, schema?: JsonSchema): Claim | undefined {
     const properties = unique.eventDefinitions.find(entry => entry.eventTypeId === eventTypeId)?.properties;
     if (properties === undefined) return undefined;
-    const parts = properties.map(property => ({ property, raw: kernelKeyString(content[property], name) }));
+    const parts = properties.map(property => ({ property, raw: kernelKeyString(content[property], name, schema?.properties?.[property]) }));
     const joined = parts.map(part => part.raw).join('-');
     if (!unique.ignoreCasing) return { key: keyHash(joined), parts };
     // The kernel applies .NET ToLowerInvariant to the joined value. constraints-ignore-casing.json proves
@@ -56,7 +68,8 @@ export class InProcessConstraints {
     private readonly _removalTypes = new Set<string>();
     private readonly _propertyRemovalTypes = new Set<string>();
 
-    constructor(private readonly _definitions: ReadonlyMap<string, ConstraintCapture>) {
+    constructor(private readonly _definitions: ReadonlyMap<string, ConstraintCapture>,
+        private readonly _schemas: ReadonlyMap<string, JsonSchema> = new Map()) {
         const coveredTypes = new Map<string, string>();
         const removalOwners = new Map<string, string>();
         for (const [name, capture] of _definitions) {
@@ -173,10 +186,7 @@ export class InProcessConstraints {
                 }
                 const properties = unique.eventDefinitions.find(entry => entry.eventTypeId === type)?.properties;
                 if (properties === undefined) continue;
-                if (properties.some(property => !['string', 'boolean'].includes(typeof prior.content[property]))) {
-                    throw this.unsupported(name, 'History has an unproven key.');
-                }
-                claims.set(source, { key: claimOf(name, unique, type, prior.content)!.key,
+                claims.set(source, { key: claimOf(name, unique, type, prior.content, this._schemas.get(type))!.key,
                     sequence: prior.context.sequenceNumber.toString() });
             }
         }
@@ -187,7 +197,7 @@ export class InProcessConstraints {
             const source = event.context.eventSourceId;
             const violationCount = violations.length;
             for (const [name, definition] of this._definitions) {
-                const claim = definition.uniqueConstraint && claimOf(name, definition.uniqueConstraint, type, event.content);
+                const claim = definition.uniqueConstraint && claimOf(name, definition.uniqueConstraint, type, event.content, this._schemas.get(type));
                 if (claim) {
                     const key = claim.key;
                     const scope = propertyScopeKey(definition.scope, event.context);

package/testing/InProcessEventSequence.ts

@@ -29,6 +29,7 @@ import { prepareSingleAppend } from '../eventSequences/prepareSingleAppend.js';
 import { toContractsGuid } from '../connection/Guid.js';
 import { getRemovedConstraintNames } from '../events/constraints/removeConstraint.js';
 import { InProcessConstraints, type WireConstraintViolation } from './InProcessConstraints.js';
+import { matchesEventField, supportsEventField } from './EventFieldSchema.js';
 import type { EventScenarioOptions } from './EventScenarioOptions.js';
 import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOperation.js';
 
@@ -38,7 +39,7 @@ const unprovenFilterCharacters = /[\u007f-\u009f]|(?=[^\x00-\x7f])\p{White_Space
 function matchesConstrainedValue(value: unknown, content: unknown): boolean {
     // Use production serialization for concepts, not their wrapper object's runtime type.
     // Keep rejecting other unproven conversions, such as a Date assigned to a string field.
-    if (value && typeof value === 'object' && typeKeyOf(value.constructor as Constructor) === conceptAsTypeKey) {
+    if (value && typeof value === 'object' && [conceptAsTypeKey, 'Guid'].includes(typeKeyOf(value.constructor as Constructor) ?? '')) {
         return JsonSerializer.serialize(value) === JSON.stringify(content);
     }
     return value === content;
@@ -117,11 +118,8 @@ export class InProcessEventSequence implements IEventSequence {
                 !schema.properties || (Object.keys(schema.properties).length === 0 &&
                     !this._constraints?.isRemovalOnlyType(eventType.id.value)) ||
                 Object.entries(schema.properties).some(([key, property]) =>
-                    !/^[a-z][a-zA-Z0-9]*$/.test(key) || !['string', 'boolean'].includes(property.type ?? '') ||
-                    property.format !== undefined || property.compliance?.length || property.security?.length ||
-                    property.items !== undefined || property.properties !== undefined || property.enum !== undefined ||
-                    property.additionalProperties !== undefined)) {
-                throw this.unsupported('artifacts.eventTypes.schema', type.name, 'Only flat, unclassified string/boolean fields are fixture-backed.');
+                    !/^[a-z][a-zA-Z0-9]*$/.test(key) || !supportsEventField(property))) {
+                throw this.unsupported('artifacts.eventTypes.schema', type.name, 'Only unclassified string, boolean, numeric, Guid, date and object fields are supported.');
             }
             this._catalog.set(type, metadata);
         }
@@ -177,7 +175,7 @@ export class InProcessEventSequence implements IEventSequence {
             try {
                 prepared = prepareSingleAppend(event, this._correlationId ? { correlationId: this._correlationId() } : undefined);
                 content = this.checkedContent(event, prepared.content, 'append.content',
-                    'Content differs from the flat scalar schema; null, missing and extra values are not proven.');
+                    'Content differs from the event schema; null, missing and extra values are not proven.');
             } catch (error) {
                 if (error instanceof UnsupportedEventSequenceOperation) throw error;
                 throw this.unsupported('append.serialization', event.constructor.name, `Payload or metadata could not be serialized: ${String(error)}.`);
@@ -455,7 +453,7 @@ export class InProcessEventSequence implements IEventSequence {
     }
 
     private checkedContent(event: object, serialized: string, operation: string,
-        mismatchReason = 'Content differs from the fixture-backed scalar schema.'): Record<string, unknown> {
+        mismatchReason = 'Content differs from the event schema.'): Record<string, unknown> {
         let content: Record<string, unknown>;
         try { content = JSON.parse(serialized) as Record<string, unknown>; }
         catch { throw this.unsupported(operation, event.constructor.name, 'Content must be valid JSON.'); }
@@ -463,10 +461,11 @@ export class InProcessEventSequence implements IEventSequence {
         const properties = metadata.schema.properties!;
         if (!content || typeof content !== 'object' || Array.isArray(content) ||
             Object.keys(content).length !== Object.keys(properties).length ||
-            Object.entries(properties).some(([key, property]) => typeof content[key] !== property.type ||
+            Object.entries(properties).some(([key, property]) => !Object.hasOwn(content, key) || !matchesEventField(content[key], property) ||
                 (this._constraints?.isConstrainedProperty(metadata.eventType.id.value, key) &&
                     !matchesConstrainedValue(Reflect.get(event, key), content[key])) ||
-                (property.type === 'string' && !/^[\x20-\x21\x23-\x5b\x5d-\x7e\u00e9]*$/.test(content[key] as string)))) {
+                (property.type === 'string' && property.format === undefined &&
+                    !/^[\x20-\x21\x23-\x5b\x5d-\x7e\u00e9]*$/.test(content[key] as string)))) {
             throw this.unsupported(operation, event.constructor.name, mismatchReason);
         }
         return content;

package/testing/ReadModelScenario.ts

@@ -174,7 +174,7 @@ export class ReadModelScenario<TReadModel extends object> {
                 throw new UnsupportedProjectionOperation(this._modelName, 'observe', `${eventSourceType}/${eventStreamType}/${eventStreamId}`,
                     'observed events must use the default event source type and stream; routed events require a kernel-backed test');
             }
-            return { sourceId: event.context.eventSourceId, content: event.content, context: event.context };
+            return { sourceId: event.context.eventSourceId, content: event.content, context: event.context, scenarioLocalHash: true };
         });
     }
 

package/testing/ScenarioEvent.ts

@@ -4,4 +4,4 @@
 import type { EventContext } from '../events/EventContext.js';
 
 /** An event serialized at the scenario boundary. */
-export type ScenarioEvent = { sourceId: string; content: unknown; context: EventContext };
+export type ScenarioEvent = { sourceId: string; content: unknown; context: EventContext; scenarioLocalHash?: boolean };

package/testing/for_EventScenario/when_appending_field_types/field_scenario_behaviors.fixture.ts

@@ -0,0 +1,219 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { Guid, JsonSerializer, type Constructor } from '@cratis/fundamentals';
+import { beforeEach, chai, describe, it, vi, type Assertion } from 'vitest';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { EventSequence } from '../../../eventSequences/EventSequence.js';
+import { EventSequenceId } from '../../../eventSequences/EventSequenceId.js';
+import type { IUnitOfWorkManager } from '../../../transactions/IUnitOfWorkManager.js';
+import { getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import { EventScenario, ReactorScenario, ReadModelScenario, UnsupportedEventSequenceOperation, UnsupportedProjectionOperation } from '../../index.js';
+import { InProcessConstraints } from '../../InProcessConstraints.js';
+
+chai.should();
+const should = (value: unknown): Assertion => (value as { should: Assertion }).should;
+
+export function fieldScenarioBehaviors(fixtures: {
+    recorded: Constructor;
+    reactor: Constructor;
+    model: Constructor;
+    reducer: Constructor;
+    guidConstraint: Constructor;
+    numberConstraint: Constructor;
+    doubleConstraint: Constructor;
+    double: Constructor<{ key: number }>;
+    projection: Constructor;
+    objectProjection: Constructor;
+    hashProjection: Constructor;
+    guid: Constructor<{ key: Guid }>;
+    number: Constructor<{ key: number }>;
+    guidConcept: Constructor;
+    numberConcept: Constructor;
+    rejected: Constructor[];
+}): void {
+    const artifacts = { eventTypes: [fixtures.recorded], reducers: [], projections: [] };
+    const serialized = () => JSON.parse(JsonSerializer.serialize(new fixtures.recorded())) as Record<string, unknown>;
+
+    describe('when appending unconstrained primitive and concept fields', () => {
+        let scenario: EventScenario;
+        let connectedContent: Record<string, unknown>;
+        beforeEach(async () => {
+            scenario = new EventScenario({ artifacts });
+            const append = vi.fn().mockResolvedValue({ Response: { SequenceNumber: 0n, ConstraintViolations: [], Errors: [] } });
+            const connected = new EventSequence(EventSequenceId.eventLog, 'store', 'default',
+                { eventSequences: { append } } as unknown as ChronicleConnection, {} as IUnitOfWorkManager);
+            const event = new fixtures.recorded();
+            await connected.append('A', event);
+            connectedContent = JSON.parse(append.mock.calls[0][0].Content as string) as Record<string, unknown>;
+            await scenario.given.forEventSource('A').events(event);
+            await scenario.append('B', event);
+            await scenario.appendMany('C', [event]);
+            await scenario.appendMany([{ eventSourceId: 'D', event }]);
+        });
+        it('should serialize every append overload exactly like the connected client', () => {
+            should(scenario.appendedEvents.map(event => event.content)).deep.equal(Array(4).fill(connectedContent));
+            should(scenario.results.map(result => result.isSuccess)).deep.equal([true, true, true]);
+        });
+        it('should retain independent nested history snapshots', async () => {
+            const first = scenario.appendedEvents[0].content;
+            (first.payload as Record<string, unknown>).amount = -1;
+            const read = await scenario.eventSequence.getForEventSourceIdAndEventTypes('A', [fixtures.recorded]);
+            should(read[0].content).deep.equal(connectedContent);
+        });
+    });
+
+    for (const [property, value] of [
+        ['identifier', 'not-a-guid'], ['identifier', Guid.parse('zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz')],
+        ['occurred', new Date('+010000-01-01T00:00:00.000Z')], ['occurred', new Date('0000-01-01T00:00:00.000Z')],
+        ['payload', { amount: 1, identifier: 'bad', occurred: new Date() }]
+    ] as const) {
+        describe(`when a declared ${property} field contains an invalid serialized value`, () => {
+            it('should reject before committing a setup call', async () => {
+                const scenario = new EventScenario({ artifacts });
+                const event = Object.assign(new fixtures.recorded(), { [property]: value });
+                const error = await scenario.given.forEventSource('A').events(new fixtures.recorded(), event).then(() => undefined, error => error);
+                should(error).instanceOf(UnsupportedEventSequenceOperation);
+                should(scenario.appendedEvents).have.lengthOf(0);
+                should(scenario.results).have.lengthOf(0);
+                should((await scenario.eventSequence.getNextSequenceNumber()).value).equal(0n);
+            });
+        });
+    }
+
+    describe('when delivering new field types through a reactor', () => {
+        let scenario: ReactorScenario;
+        beforeEach(async () => {
+            scenario = new ReactorScenario(fixtures.reactor, { artifacts });
+            await scenario.when.forEventSource('A').events(new fixtures.recorded());
+        });
+        it('should deliver client-serialized JSON without kernel normalization or concept wrappers', () => {
+            should(scenario.results[0].completed).equal(true);
+            should(scenario.produced[0]).deep.equal(serialized());
+        });
+    });
+
+    describe('when observing new field types through a reducer', () => {
+        let result: object | null;
+        beforeEach(async () => {
+            const scenario = new EventScenario({ artifacts });
+            const models = new ReadModelScenario(fixtures.model, { ...artifacts, reducers: [fixtures.reducer] }).observe(scenario);
+            await scenario.append('A', new fixtures.recorded());
+            result = await models.instanceForEventSourceId('A');
+        });
+        it('should give the reducer client-serialized JSON without kernel normalization', () => { should(result).deep.equal(serialized()); });
+    });
+
+    describe('when observing new scalar fields through a projection', () => {
+        let result: object | null;
+        beforeEach(async () => {
+            const scenario = new EventScenario({ artifacts });
+            const models = new ReadModelScenario(fixtures.projection, artifacts).observe(scenario);
+            await scenario.append('A', new fixtures.recorded());
+            result = await models.instanceForEventSourceId('A');
+        });
+        it('should preserve the existing fixture-backed projection conversion', () => {
+            const content = serialized();
+            should(JSON.parse(JsonSerializer.serialize(result))).deep.equal({
+                id: 'A', amount: content.amount, identifier: String(content.identifier).toLowerCase(), occurred: content.occurred });
+        });
+    });
+
+    it('should still reject object projection targets independently of accepted event content', () => {
+        should(() => new ReadModelScenario(fixtures.objectProjection, artifacts)).throw(UnsupportedProjectionOperation);
+    });
+
+    it('should reject a projection that treats a new payload hash as a kernel hash', async () => {
+        const scenario = new EventScenario({ artifacts });
+        const models = new ReadModelScenario(fixtures.hashProjection, artifacts).observe(scenario);
+        await scenario.append('A', new fixtures.recorded());
+        const error = await models.instanceForEventSourceId('A').then(() => undefined, error => error);
+        should(error).instanceOf(UnsupportedProjectionOperation);
+        should(String(error)).include('Hash');
+    });
+
+    for (const type of fixtures.rejected) {
+        describe(`when registering the unproven ${type.name} unique key`, () => {
+            it('should name the constraint boundary rather than rejecting ordinary event serialization', async () => {
+                should(() => new EventScenario({ artifacts: { eventTypes: [type] } })).throw(UnsupportedEventSequenceOperation, 'artifacts.constraints');
+                const scenario = new EventScenario({ artifacts: { eventTypes: [type] }, constraints: 'disabled' });
+                should((await scenario.append('A', new type())).isSuccess).equal(true);
+            });
+        });
+    }
+
+    for (const type of [fixtures.guidConcept, fixtures.numberConcept]) {
+        describe(`when claiming the same ${type.name} concept key`, () => {
+            it('should compare its serialized primitive and report the duplicate', async () => {
+                const scenario = new EventScenario({ artifacts: { eventTypes: [type] } });
+                should((await scenario.append('A', new type())).isSuccess).equal(true);
+                const duplicate = await scenario.append('B', new type());
+                should(duplicate.isSuccess).equal(false);
+                should(duplicate.constraintViolations[0].details.PropertyValue).equal(
+                    String((JSON.parse(JsonSerializer.serialize(new type())) as { key: unknown }).key).toLowerCase());
+            });
+        });
+    }
+
+    for (const value of [1.5, 1e-7, Number.MAX_SAFE_INTEGER + 1, -Number.MAX_SAFE_INTEGER - 1, NaN, Infinity]) {
+        describe(`when a constrained number contains ${value}`, () => {
+            it('should reject the entire batch before recording results or history', async () => {
+                const scenario = new EventScenario({ artifacts: { eventTypes: [fixtures.number], constraints: [fixtures.numberConstraint] } });
+                const event = new fixtures.number(); event.key = value;
+                const error = await scenario.appendMany('A', [new fixtures.number(), event]).then(() => undefined, error => error);
+                should(error).instanceOf(UnsupportedEventSequenceOperation);
+                should(scenario.results).have.lengthOf(0);
+                should(scenario.appendedEvents).have.lengthOf(0);
+            });
+        });
+    }
+
+    it('should normalize negative zero using production serialization before comparing numeric keys', async () => {
+        const scenario = new EventScenario({ artifacts: { eventTypes: [fixtures.number], constraints: [fixtures.numberConstraint] } });
+        const zero = new fixtures.number(); zero.key = 0;
+        const negative = new fixtures.number(); negative.key = -0;
+        await scenario.append('A', zero);
+        should((await scenario.append('B', negative)).isSuccess).equal(false);
+    });
+
+    const fixture = JSON.parse(readFileSync(new URL('../../fixtures/constraints-field-types.json', import.meta.url), 'utf8')) as {
+        fieldConstraintCases: Array<{ kind: string; eventType: string; operations: Array<{ mode: string; events: Array<{ source: string; content: string }> }> }>;
+        expected: Array<{ fieldSchema: unknown; steps: Array<{ success: boolean; sequences: string[]; wireViolations: unknown[]; history: unknown[]; next: string }> }>;
+    };
+    for (const [caseIndex, test] of fixture.fieldConstraintCases.entries()) {
+        if (test.kind !== 'kernelSemantics') continue;
+        describe(`when replaying the packaged ${test.eventType} constraint fixture`, () => {
+            it('should match every raw violation, hash, history, sequence and atomic rejection', async () => {
+                const type = test.eventType === 'OracleFieldGuid' ? fixtures.guid : test.eventType === 'OracleFieldDouble' ? fixtures.double : fixtures.number;
+                should(getEventTypeMetadata(type)!.eventType.id.value).equal(test.eventType);
+                should(getEventTypeMetadata(type)!.schema.properties!.key).deep.equal(fixture.expected[caseIndex].fieldSchema);
+                const scenario = new EventScenario({ artifacts: { eventTypes: [type],
+                    constraints: [type === fixtures.guid ? fixtures.guidConstraint : type === fixtures.double ? fixtures.doubleConstraint : fixtures.numberConstraint] } });
+                const validate = vi.spyOn(InProcessConstraints.prototype, 'validate');
+                try {
+                    for (const [index, operation] of test.operations.entries()) {
+                        const expected = fixture.expected[caseIndex].steps[index];
+                        const events = operation.events.map(entry => {
+                            const event = new type();
+                            const key = (JSON.parse(entry.content) as { key: string | number }).key;
+                            Object.assign(event, { key });
+                            return { eventSourceId: entry.source, event };
+                        });
+                        const results = operation.mode === 'single'
+                            ? [await scenario.append(events[0].eventSourceId, events[0].event)] : await scenario.appendMany(events);
+                        should(results.every(result => result.isSuccess === expected.success)).equal(true);
+                        should(results.map(result => result.sequenceNumber.value.toString())).deep.equal(
+                            expected.success ? expected.sequences : results.map(() => '0'));
+                        const raw = validate.mock.results.at(-1)!.value as ReturnType<InProcessConstraints['validate']>;
+                        should(raw.map(({ SequenceNumber, ...violation }) => ({ ...violation, SequenceNumber: SequenceNumber.toString() })))
+                            .deep.equal(expected.wireViolations);
+                        should(scenario.appendedEvents.map(event => ({ source: event.context.eventSourceId,
+                            sequence: event.context.sequenceNumber.toString(), content: event.content, hash: event.context.hash }))).deep.equal(expected.history);
+                        should((await scenario.eventSequence.getNextSequenceNumber()).value.toString()).equal(expected.next);
+                    }
+                } finally { validate.mockRestore(); }
+            });
+        });
+    }
+}

package/testing/for_EventScenario/when_appending_field_types/with_invalid_formatted_content.legacy.spec.ts

@@ -0,0 +1,123 @@
+// 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 { field } from '@cratis/fundamentals';
+import { beforeEach, chai, describe, it } from 'vitest';
+import { eventType, getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import type { JsonSchema } from '../../../schemas/JsonSchema.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from '../../index.js';
+
+chai.should();
+
+const invalid: Array<{ schema: JsonSchema; value: unknown }> = [
+    { schema: { type: 'integer' }, value: 1.5 },
+    { schema: { type: 'integer' }, value: Number.MAX_SAFE_INTEGER + 1 }
+];
+for (const format of ['guid', 'uuid']) {
+    for (const value of ['not-a-guid', 'abcdef01abcdabcdabcdabcdef012345', 'abcdef01-abcd-abcd-abcd-abcdef01234g', '"', '\\', '\n', 'é']) {
+        invalid.push({ schema: { type: 'string', format }, value });
+    }
+}
+for (const value of ['01/02/2025', '2025-02-29', '2024-02-30', '2025-13-01', '0000-01-01', '+010000-01-01', '2025-01-02T00:00:00.000Z']) {
+    invalid.push({ schema: { type: 'string', format: 'date' }, value });
+}
+for (const value of ['January 2, 2025', '2025-01-02', '2025-02-29T00:00:00.000Z', '2024-02-30T00:00:00.000Z',
+    '2025-01-02T24:00:00.000Z', '2025-01-02T00:60:00.000Z', '2025-01-02T00:00:60.000Z',
+    '0000-01-01T00:00:00.000Z', '+010000-01-01T00:00:00.000Z', '2025-01-02T00:00:00', '2025-01-02T00:00:00+01:00']) {
+    invalid.push({ schema: { type: 'string', format: 'date-time' }, value });
+}
+const ranges: Array<[string, number, number]> = [
+    ['int8', -128, 127], ['uint8', 0, 255], ['int16', -32768, 32767], ['uint16', 0, 65535],
+    ['int32', -2147483648, 2147483647], ['uint32', 0, 4294967295],
+    ['int64', Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], ['uint64', 0, Number.MAX_SAFE_INTEGER]
+];
+for (const [format, minimum, maximum] of ranges) {
+    for (const type of ['integer', 'number'] as const) {
+        for (const value of [minimum - 1, maximum + 1, 1.5]) invalid.push({ schema: { type, format }, value });
+    }
+}
+for (const [format, value] of [['int64', 2 ** 63], ['uint64', 2 ** 64], ['float', 3.5e38], ['decimal', 8e28]] as const) {
+    invalid.push({ schema: { type: 'number', format }, value });
+}
+
+for (const { schema, value } of invalid) {
+    describe(`when appending invalid ${schema.type}/${schema.format} content ${JSON.stringify(value)}`, () => {
+        for (const operation of ['single', 'batch', 'setup']) {
+            let scenario: EventScenario;
+            let failure: unknown;
+            beforeEach(async () => {
+                class Recorded { @field(Object) value: unknown = value; }
+                eventType('InvalidFormattedContent')(Recorded);
+                getEventTypeMetadata(Recorded)!.schema.properties!.value = schema;
+                scenario = new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' });
+                const valid = new Recorded();
+                valid.value = schema.type === 'string'
+                    ? schema.format === 'date' ? '2024-02-29' : schema.format === 'date-time' ? '2024-02-29T00:00:00.000Z' : '00000000-0000-0000-0000-000000000000'
+                    : 1;
+                await scenario.given.forEventSource('existing').events(valid);
+                const append = operation === 'single' ? scenario.append('A', new Recorded())
+                    : operation === 'batch' ? scenario.appendMany('A', [valid, new Recorded()])
+                    : scenario.given.forEventSource('A').events(valid, new Recorded());
+                failure = await append.then(() => undefined, error => error);
+            });
+            it(`should reject the ${operation} without changing history results or the next sequence`, async () => {
+                (failure as Error).should.be.instanceOf(UnsupportedEventSequenceOperation);
+                scenario.appendedEvents.should.have.lengthOf(1);
+                scenario.results.should.have.lengthOf(0);
+                (await scenario.eventSequence.getNextSequenceNumber()).value.should.equal(1n);
+            });
+        }
+    });
+}
+
+for (const property of [
+    ...['date', 'date-time', 'guid', 'uuid'].map(format => ({ type: 'string' as const, format })),
+    { type: 'integer', format: 'int32' }
+] satisfies JsonSchema[]) {
+    for (const container of ['properties', 'additionalProperties']) {
+        describe(`when a nested ${container} schema contains an invalid ${property.format}`, () => {
+            it('should validate the nested field before accepting content', async () => {
+                class Recorded { @field(Object) payload = { nested: property.type === 'integer' ? 2147483648 : 'invalid' }; }
+                eventType('InvalidNestedFormattedContent')(Recorded);
+                getEventTypeMetadata(Recorded)!.schema.properties!.payload = container === 'properties'
+                    ? { type: 'object', properties: { nested: property } } : { type: 'object', additionalProperties: property };
+                const scenario = new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' });
+                const failure = await scenario.append('A', new Recorded()).then(() => undefined, error => error);
+                failure.should.be.instanceOf(UnsupportedEventSequenceOperation);
+                scenario.appendedEvents.should.have.lengthOf(0);
+            });
+        });
+    }
+}
+
+const valid: Array<{ schema: JsonSchema; values: unknown[] }> = [
+    { schema: { type: 'string', format: 'date' }, values: ['0001-01-01', '2024-02-29', '9999-12-31'] },
+    { schema: { type: 'string', format: 'date-time' }, values: ['0001-01-01T00:00:00.000Z', '2024-02-29T12:34:56Z', '9999-12-31T23:59:59.999Z'] },
+    { schema: { type: 'string', format: 'guid' }, values: ['ABCDEF01-ABCD-ABCD-ABCD-ABCDEF012345'] },
+    ...ranges.map(([format, minimum, maximum]) => ({ schema: { type: 'integer' as const, format }, values: [minimum, maximum] }))
+];
+for (const { schema, values } of valid) {
+    describe(`when appending supported ${schema.type}/${schema.format} boundaries`, () => {
+        it('should retain the serialized values without kernel normalization', async () => {
+            class Recorded { @field(Object) value: unknown; }
+            eventType('ValidFormattedContent')(Recorded);
+            getEventTypeMetadata(Recorded)!.schema.properties!.value = schema;
+            const scenario = new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' });
+            await scenario.appendMany('A', values.map(value => Object.assign(new Recorded(), { value })));
+            scenario.appendedEvents.map(event => event.content.value).should.deep.equal(values);
+        });
+    });
+}
+
+for (const format of ['unknown', 'int128']) {
+    describe(`when registering an unsupported numeric format ${format}`, () => {
+        it('should reject the schema rather than ignoring its format', () => {
+            class Recorded { @field(Number) value = 1; }
+            eventType('UnsupportedNumericFormat')(Recorded);
+            getEventTypeMetadata(Recorded)!.schema.properties!.value.format = format;
+            (() => new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' }))
+                .should.throw(UnsupportedEventSequenceOperation, 'artifacts.eventTypes.schema');
+        });
+    });
+}