@cratis/chronicle 6.49.0 → 6.51.0

package/events/for_NamedTag/when_constructing/with_invalid_values.spec.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it } from 'vitest';
+import { InvalidNamedTag } from '../../InvalidNamedTag.js';
+import { NamedTag } from '../../NamedTag.js';
+
+chai.should();
+
+describe('when constructing a named tag with invalid values', () => {
+    it('should reject an empty name', () => (() => new NamedTag('', 'value')).should.throw(InvalidNamedTag));
+    it('should reject a whitespace name', () => (() => new NamedTag(' \t', 'value')).should.throw(InvalidNamedTag));
+    it('should reject a name of only next-line characters like .NET', () => (() => new NamedTag('\u0085', 'value')).should.throw(InvalidNamedTag));
+    it('should reject a missing name', () => (() => new NamedTag(undefined as unknown as string, 'value')).should.throw(InvalidNamedTag));
+    it('should reject a null value', () => (() => new NamedTag('name', null as unknown as string)).should.throw(InvalidNamedTag));
+    it('should reject a non-string value', () => (() => new NamedTag('name', 42 as unknown as string)).should.throw(InvalidNamedTag));
+});

package/events/for_NamedTag/when_constructing/with_valid_values.spec.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it } from 'vitest';
+import { NamedTag } from '../../NamedTag.js';
+
+chai.should();
+
+describe('when constructing a named tag with a name and an empty value', () => {
+    const tag = new NamedTag('import-batch', '');
+    it('should keep the name exactly', () => tag.name.should.equal('import-batch'));
+    it('should keep the empty value', () => tag.value.should.equal(''));
+    it('should be immutable', () => Object.isFrozen(tag).should.be.true);
+});
+
+describe('when comparing named tags', () => {
+    it('should treat the same name and value as equal', () => new NamedTag('a', 'B').equals(new NamedTag('a', 'B')).should.be.true);
+    it('should compare values case-sensitively', () => new NamedTag('a', 'B').equals(new NamedTag('a', 'b')).should.be.false);
+});

package/events/for_mergeNamedTags/when_merging/with_event_and_call_tags.spec.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { mergeNamedTags } from '../../mergeNamedTags.js';
+import { NamedTag } from '../../NamedTag.js';
+
+chai.should();
+
+describe('when merging event and call named tags', () => {
+    let result: NamedTag[];
+    beforeEach(() => {
+        result = mergeNamedTags(
+            [new NamedTag('side', 'debit'), new NamedTag('transfer', 't-1')],
+            [new NamedTag('transfer', 't-1'), new NamedTag('transfer', 'T-1'), new NamedTag('side', 'credit')]);
+    });
+    it('should keep the first occurrence of each exact pair in order, including several values per name', () =>
+        result.map(tag => [tag.name, tag.value]).should.deep.equal([
+            ['side', 'debit'], ['transfer', 't-1'], ['transfer', 'T-1'], ['side', 'credit']
+        ]));
+});
+
+describe('when merging plain named tag objects', () => {
+    let result: NamedTag[];
+    beforeEach(() => { result = mergeNamedTags([{ name: 'channel', value: 'web' } as NamedTag]); });
+    it('should return validated named tag instances', () => result[0].should.be.instanceOf(NamedTag));
+});
+
+describe('when merging no named tags', () => {
+    it('should return an empty list', () => mergeNamedTags(undefined, null, []).should.deep.equal([]));
+});

package/events/for_mergeNamedTags/when_merging/with_invalid_entries.spec.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it } from 'vitest';
+import { InvalidNamedTag } from '../../InvalidNamedTag.js';
+import { mergeNamedTags } from '../../mergeNamedTags.js';
+import type { NamedTag } from '../../NamedTag.js';
+
+chai.should();
+
+describe('when merging named tags with invalid entries', () => {
+    it('should reject a null element', () => (() => mergeNamedTags([null as unknown as NamedTag])).should.throw(InvalidNamedTag));
+    it('should reject a plain object with a blank name', () =>
+        (() => mergeNamedTags([{ name: ' ', value: 'x' } as NamedTag])).should.throw(InvalidNamedTag));
+    it('should reject a string instead of a collection', () =>
+        (() => mergeNamedTags('name' as unknown as NamedTag[])).should.throw(InvalidNamedTag));
+});

package/events/for_toClientEventContext/when_converting_named_tags.spec.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import type { EventContext } from '../EventContext.js';
+import { NamedTag } from '../NamedTag.js';
+import { toClientEventContext } from '../toClientEventContext.js';
+import type { WireEventContext } from '../WireEventContext.js';
+
+chai.should();
+
+function wireContext(namedTags?: { Name: string; Value: string }[]): WireEventContext {
+    return {
+        EventSourceId: 'source', SequenceNumber: 1n, EventSourceType: 'Default', EventStreamType: 'All', EventStreamId: 'Default',
+        EventType: { Id: 'type', Generation: 1, Tombstone: false }, Occurred: { Value: '2025-01-01T00:00:00.000Z' },
+        CorrelationId: undefined, Causation: [], CausedBy: undefined, Tags: [], Hash: '', ObservationState: 1, Subject: 'source',
+        NamedTags: namedTags
+    } as unknown as WireEventContext;
+}
+
+describe('when converting a delivered context with named tags', () => {
+    let context: EventContext;
+    beforeEach(() => { context = toClientEventContext(wireContext([{ Name: 'batch', Value: 'b-1' }, { Name: 'batch', Value: '' }])); });
+    it('should expose every named tag in delivered order', () =>
+        context.namedTags!.map(tag => [tag.name, tag.value]).should.deep.equal([['batch', 'b-1'], ['batch', '']]));
+    it('should expose named tag instances', () => context.namedTags![0].should.be.instanceOf(NamedTag));
+});
+
+describe('when converting a delivered context without named tags', () => {
+    it('should expose an empty list', () => toClientEventContext(wireContext()).namedTags!.should.deep.equal([]));
+});

package/events/index.ts

@@ -21,5 +21,8 @@ export { filterEventsByTag, getFilterTagsFor } from './filterEventsByTagDecorato
 export { eventSourceType, getEventSourceTypeFor } from './eventSourceTypeDecorator.js';
 export { eventStreamType, getEventStreamTypeFor } from './eventStreamTypeDecorator.js';
 export { mergeTags } from './mergeTags.js';
+export { NamedTag } from './NamedTag.js';
+export { InvalidNamedTag } from './InvalidNamedTag.js';
+export { mergeNamedTags } from './mergeNamedTags.js';
 export * from './constraints/index.js';
 export * from './migrations/index.js';

package/events/mergeNamedTags.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { InvalidNamedTag } from './InvalidNamedTag.js';
+import { NamedTag } from './NamedTag.js';
+
+/**
+ * Validates and merges structured named tags - for example the tags carried by an individual event and
+ * the tags supplied for a whole append call - into one distinct list. The first occurrence of each exact
+ * (ordinal, case-sensitive) name and value pair is kept, in order. Mirrors the .NET client's
+ * `NamedTagConverters.Merge`.
+ * @param sources - The named tag sources to merge, in precedence order. An undefined or null source contributes nothing.
+ * @returns The distinct, validated named tags.
+ * @throws {@link InvalidNamedTag} when a source is not iterable, contains an entry that is not an object,
+ * or contains a tag with a blank name or a non-string value.
+ */
+export function mergeNamedTags(...sources: ReadonlyArray<Iterable<NamedTag> | undefined | null>): NamedTag[] {
+    const seen = new Set<string>();
+    const merged: NamedTag[] = [];
+    for (const source of sources) {
+        if (source === undefined || source === null) continue;
+        if (typeof source !== 'object' || typeof (source as Iterable<NamedTag>)[Symbol.iterator] !== 'function') {
+            throw new InvalidNamedTag();
+        }
+        for (const entry of source as Iterable<unknown>) {
+            if (entry === null || typeof entry !== 'object') throw new InvalidNamedTag();
+            // Reconstruct so plain { name, value } objects are validated exactly like NamedTag instances.
+            const tag = entry instanceof NamedTag ? entry
+                : new NamedTag(Reflect.get(entry, 'name') as string, Reflect.get(entry, 'value') as string);
+            const key = JSON.stringify([tag.name, tag.value]);
+            if (seen.has(key)) continue;
+            seen.add(key);
+            merged.push(tag);
+        }
+    }
+    return merged;
+}

package/events/toClientEventContext.ts

@@ -8,6 +8,7 @@ import { EventType } from './EventType.js';
 import { EventTypeGeneration } from './EventTypeGeneration.js';
 import { EventTypeId } from './EventTypeId.js';
 import { Tag } from './Tag.js';
+import { NamedTag } from './NamedTag.js';
 import type { WireEventContext } from './WireEventContext.js';
 
 /** Converts kernel metadata identically for reads, reactors, and reducers. */
@@ -37,7 +38,8 @@ export function toClientEventContext(context: WireEventContext): EventContext {
             occurred: causation.Occurred ? new Date(causation.Occurred.Value) : undefined,
             properties: { ...causation.Properties }
         })),
-        tags: (context.Tags ?? []).map(value => new Tag(value))
+        tags: (context.Tags ?? []).map(value => new Tag(value)),
+        namedTags: (context.NamedTags ?? []).map(tag => new NamedTag(tag.Name, tag.Value))
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.49.0",
+    "version": "6.51.0",
     "description": "Event sourcing for TypeScript and Node.js — the idiomatic client for Cratis Chronicle, the open-source event-sourcing database",
     "author": "Cratis",
     "license": "MIT",
@@ -173,12 +173,12 @@
         "clean": "rm -rf dist",
         "test": "vitest run",
         "test:integration": "vitest run --config vitest.integration.config.ts",
-        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/declarative/addChildCompatibility.standard.spec.ts projections/declarative/for_CompositeKeyBuilder/when_typing_constant_parts.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts testing/for_EventScenario/when_appending_concept_fields/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_scoped_constraints/with_standard_decorators.standard.spec.ts schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts events/for_handles/when_decorating_a_method.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_arithmetic/with_standard_decorators.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_joins/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts eventSequences/for_EventSequence/when_appending/with_subject_annotations.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_tags/with_standard_decorators.standard.spec.ts telemetry/for_ChronicleTelemetry/when_exposing_names/with_convention_names.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all_events.standard.spec.ts events/for_observerFilters/when_registering/with_standard_decorators.standard.spec.ts reactors/for_Reactors/against_a_kernel/when_filtering_source_and_stream_types.integration.spec.ts testing/for_observerScenarios/when_selecting_filters/with_source_and_stream_types.spec.ts readModels/for_ReadModelWatcher/watchCompatibility.standard.spec.ts for_EventStore/when_implementing_a_legacy_event_store.spec.ts",
+        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/declarative/addChildCompatibility.standard.spec.ts projections/declarative/for_CompositeKeyBuilder/when_typing_constant_parts.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts testing/for_EventScenario/when_appending_concept_fields/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_scoped_constraints/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_event_sequence_constraints/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_event_sequence_constraints/other_sequence_extended_key.standard.spec.ts events/constraints/for_Constraints/when_scoping_to_event_sequences/with_standard_decorators.standard.spec.ts schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts events/for_handles/when_decorating_a_method.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_arithmetic/with_standard_decorators.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_joins/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts eventSequences/for_EventSequence/when_appending/with_subject_annotations.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_tags/with_standard_decorators.standard.spec.ts telemetry/for_ChronicleTelemetry/when_exposing_names/with_convention_names.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all_events.standard.spec.ts events/for_observerFilters/when_registering/with_standard_decorators.standard.spec.ts reactors/for_Reactors/against_a_kernel/when_filtering_source_and_stream_types.integration.spec.ts testing/for_observerScenarios/when_selecting_filters/with_source_and_stream_types.spec.ts readModels/for_ReadModelWatcher/watchCompatibility.standard.spec.ts for_EventStore/when_implementing_a_legacy_event_store.spec.ts",
         "test:native": "node ./scripts/check-native-esm.mjs"
     },
     "dependencies": {
         "@bufbuild/protobuf": "^2.16.0",
-        "@cratis/chronicle.contracts": "19.30.0",
+        "@cratis/chronicle.contracts": "19.31.10",
         "@grpc/grpc-js": "^1.14.5",
         "@opentelemetry/api": "^1.9.1",
         "glob": "^13.0.6",
@@ -188,14 +188,14 @@
         "undici": "^8.11.2"
     },
     "devDependencies": {
-        "@cratis/fundamentals": "7.20.0",
+        "@cratis/fundamentals": "7.22.4",
         "@opentelemetry/context-async-hooks": "2.11.0",
         "@opentelemetry/core": "2.11.0",
         "@opentelemetry/instrumentation-grpc": "0.222.0",
         "@opentelemetry/instrumentation-http": "0.222.0",
         "@opentelemetry/sdk-metrics": "2.11.0",
         "@opentelemetry/sdk-trace-base": "2.11.0",
-        "@types/node": "^26.6.3",
+        "@types/node": "^26.6.4",
         "@typescript/native": "npm:typescript@^7.0.2",
         "esbuild": "^0.28.2",
         "typescript": "npm:@typescript/typescript6@^6.0.2",
@@ -203,6 +203,6 @@
         "vitest": "^5.0.3"
     },
     "peerDependencies": {
-        "@cratis/fundamentals": "^7.20.0"
+        "@cratis/fundamentals": "^7.22.4"
     }
 }

package/projections/eventContextPropertyExpression.ts

@@ -23,8 +23,9 @@ const contextProperties = {
     correlationId: true,
     causation: true,
     tags: true
-    // eventSource is deliberately not projectable: its kernel resolution is not part of the supported expression set.
-} satisfies Record<Exclude<keyof EventContext, 'eventSource'>, true>;
+    // eventSource and namedTags are deliberately not projectable: their kernel resolution is not part of the
+    // supported expression set.
+} satisfies Record<Exclude<keyof EventContext, 'eventSource' | 'namedTags'>, true>;
 
 // Mirror the kernel's DerivedPropertyFunctions registry: Week() applies to dates only.
 const derivedFunctions: Record<string, string> = { week: 'Week' };

package/testing/EventScenario.fixtures.spec.ts

@@ -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', 'constraints-field-types.json'].includes(name)).map(name => ({
+        'constraints-ignore-casing.json', 'constraints-scopes.json', 'constraints-field-types.json', 'constraints-event-sequences.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.ts

@@ -85,9 +85,15 @@ export class EventScenario {
                         }
                     }
                 }
-                constraints = new InProcessConstraints(definitions, new Map(eventTypes.map(type =>
-                    [getEventTypeFor(type).id.value, getEventTypeMetadata(type)!.schema])));
-                for (const [name, capture] of definitions) {
+                // The scenario appends to the event log only. A definition scoped to other event sequences is neither
+                // validated nor indexed there by the kernel (constraints-event-sequences.json), so it takes no part.
+                const eventLog = EventSequenceId.eventLog.value;
+                const applicable = new Map([...definitions].filter(([, capture]) =>
+                    !capture.eventSequences?.length || capture.eventSequences.includes(eventLog)));
+                const inapplicable = new Set([...definitions.keys()].filter(name => !applicable.has(name)));
+                constraints = new InProcessConstraints(applicable, new Map(eventTypes.map(type =>
+                    [getEventTypeFor(type).id.value, getEventTypeMetadata(type)!.schema])), inapplicable);
+                for (const [name, capture] of applicable) {
                     const ids = capture.uniqueConstraint?.eventDefinitions.map(entry => entry.eventTypeId) ??
                         capture.uniqueEventType?.eventTypeIds ?? [capture.uniqueEventType?.eventTypeId];
                     const removedWith = [...(capture.uniqueConstraint?.removedWithEventTypeIds ?? []),
@@ -121,7 +127,7 @@ export class EventScenario {
                                 `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 ||
+                        if (extendedKey && (applicable.size !== 1 || capture.uniqueConstraint!.eventDefinitions.length !== 1 ||
                             removedWith.some(id => id !== undefined))) {
                             throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
                                 'Guid and numeric keys require one isolated definition covering one event type without removers; shared definitions and removal combinations are not fixture-backed.');

package/testing/InProcessConstraints.ts

@@ -69,7 +69,8 @@ export class InProcessConstraints {
     private readonly _propertyRemovalTypes = new Set<string>();
 
     constructor(private readonly _definitions: ReadonlyMap<string, ConstraintCapture>,
-        private readonly _schemas: ReadonlyMap<string, JsonSchema> = new Map()) {
+        private readonly _schemas: ReadonlyMap<string, JsonSchema> = new Map(),
+        private readonly _inapplicable: ReadonlySet<string> = new Set()) {
         const coveredTypes = new Map<string, string>();
         const removalOwners = new Map<string, string>();
         for (const [name, capture] of _definitions) {
@@ -161,6 +162,9 @@ export class InProcessConstraints {
 
     hasRemovalType(eventTypeId: string): boolean { return this._removalTypes.has(eventTypeId); }
 
+    /** Whether a named definition is scoped to event sequences other than the scenario's, so it takes no part. */
+    isInapplicable(name: string): boolean { return this._inapplicable.has(name); }
+
     isConstrainedProperty(eventTypeId: string, property: string): boolean {
         return this._constrainedProperties.get(eventTypeId)?.has(property) ?? false;
     }

package/testing/InProcessEventSequence.ts

@@ -17,7 +17,7 @@ import { EventTypeId } from '../events/EventTypeId.js';
 import { EventTypeGeneration } from '../events/EventTypeGeneration.js';
 import { Identity } from '../identity/Identity.js';
 import type { AppendOptions } from '../eventSequences/AppendOptions.js';
-import { singleAppendRoute } from './singleAppendRoute.js';
+import { hasNamedTags, singleAppendRoute } from './singleAppendRoute.js';
 import type { AppendResult } from '../eventSequences/AppendResult.js';
 import type { AppendedEventWithResult } from '../eventSequences/AppendedEventWithResult.js';
 import type { EventForEventSourceId } from '../eventSequences/EventForEventSourceId.js';
@@ -110,7 +110,8 @@ export class InProcessEventSequence implements IEventSequence {
             if (eventType.generation.value !== 1 || eventType.tombstone) {
                 throw this.unsupported('artifacts.eventTypes', type.name, 'Only generation 1, non-tombstone events are proven.');
             }
-            if (options.constraints !== 'disabled' && getRemovedConstraintNames(type).length &&
+            if (options.constraints !== 'disabled' &&
+                getRemovedConstraintNames(type).some(name => !this._constraints?.isInapplicable(name)) &&
                 !this._constraints?.hasRemovalType(eventType.id.value)) {
                 throw this.unsupported('artifacts.eventTypes.constraints', type.name, 'Constraint removal is not fixture-backed.');
             }
@@ -215,7 +216,8 @@ export class InProcessEventSequence implements IEventSequence {
                     subject: resolveStoredSubject(prepared.subject, eventSourceId), hash, causedBy: prepared.identity, observationState: EventObservationState.Initial,
                     eventType: prepared.eventType, occurred, correlationId: prepared.correlationId.toString(),
                     causation: prepared.causationChain.map(item => ({ type: item.type.name, occurred: item.occurred, properties: { ...item.properties } })),
-                    tags: prepared.tags.map(tag => new Tag(tag))
+                    tags: prepared.tags.map(tag => new Tag(tag)),
+                    namedTags: []
                 }
             };
             const violations = this.validateConstraints([...this._history, ...(this._stagedSeeds ?? [])], [stored]);
@@ -254,10 +256,13 @@ export class InProcessEventSequence implements IEventSequence {
             for (const entry of entries) {
                 if (typeof sourceOrEvents === 'string') break;
                 if (!entry || typeof entry !== 'object' || Reflect.ownKeys(entry).some(key =>
-                    !['eventSourceId', 'event', 'eventSourceType', 'eventStreamType', 'eventStreamId', 'subject', 'occurred', 'tags'].includes(String(key)))) {
+                    !['eventSourceId', 'event', 'eventSourceType', 'eventStreamType', 'eventStreamId', 'subject', 'occurred', 'tags', 'namedTags'].includes(String(key)))) {
                     throw this.unsupported('appendMany.entry', this.id.value, 'Unrecognized per-entry metadata.');
                 }
                 const individual = entry as EventForEventSourceId;
+                if (hasNamedTags(individual.namedTags)) {
+                    throw this.unsupported('appendMany.namedTags', this.id.value, 'Named tags are not fixture-backed.');
+                }
                 if (individual.occurred !== undefined) this.checkedDate(individual.occurred, 'appendMany.occurred');
                 if (individual.subject !== undefined && individual.subject !== null && typeof individual.subject !== 'string') {
                     throw this.unsupported('appendMany.subject', this.id.value, 'Subject must be a string.');
@@ -271,7 +276,8 @@ export class InProcessEventSequence implements IEventSequence {
             try {
                 const batchOptions: AppendOptions | undefined = shared?.correlationId === undefined && this._correlationId
                     ? { correlationId: this._correlationId(), sourceType: shared?.sourceType, streamType: shared?.streamType,
-                        streamId: shared?.streamId, subject: shared?.subject, occurred: shared?.occurred, tags: shared?.tags }
+                        streamId: shared?.streamId, subject: shared?.subject, occurred: shared?.occurred, tags: shared?.tags,
+                        namedTags: shared?.namedTags }
                     : shared;
                 if (batchOptions?.correlationId !== undefined) this.validateGuid(batchOptions.correlationId, 'appendMany.correlationId');
                 prepared = typeof sourceOrEvents === 'string'
@@ -318,7 +324,8 @@ export class InProcessEventSequence implements IEventSequence {
                     eventStreamId: wire.EventStreamId || 'Default', subject: resolveStoredSubject(wire.Subject, eventSourceId), hash, causedBy: identity,
                     observationState: EventObservationState.Initial, eventType, occurred, correlationId: correlationId.toString(),
                     causation: batchCausationChain.map(item => ({ type: item.type.name, occurred: item.occurred, properties: { ...item.properties } })),
-                    tags: wire.Tags.map(tag => new Tag(tag))
+                    tags: wire.Tags.map(tag => new Tag(tag)),
+                    namedTags: []
                 } };
                 return { stored, result: this.success(sequenceNumber, event.constructor.name) };
             });
@@ -411,7 +418,10 @@ export class InProcessEventSequence implements IEventSequence {
         if (!options || typeof options !== 'object' || Array.isArray(options)) {
             throw this.unsupported('appendMany.options', this.id.value, 'Append options must be an object.');
         }
-        const allowed = ['correlationId', 'sourceType', 'streamType', 'streamId', 'subject', 'occurred', 'tags'];
+        if (hasNamedTags(options.namedTags)) {
+            throw this.unsupported('appendMany.namedTags', this.id.value, 'Named tags are not fixture-backed.');
+        }
+        const allowed = ['correlationId', 'sourceType', 'streamType', 'streamId', 'subject', 'occurred', 'tags', 'namedTags'];
         if (Reflect.ownKeys(options).some(key => !allowed.includes(String(key))) ||
             options.concurrencyScope !== undefined || options.concurrencyScopes !== undefined || options.eventSourceId !== undefined) {
             throw this.unsupported('appendMany.options', this.id.value, 'Concurrency and unrecognized metadata are not fixture-backed.');
@@ -492,7 +502,8 @@ export class InProcessEventSequence implements IEventSequence {
             context: { ...event.context, eventType, occurred: new Date(event.context.occurred),
                 causedBy: causedBy && new Identity(causedBy.subject, causedBy.name, causedBy.userName, causedBy.onBehalfOf),
                 causation: event.context.causation.map(item => ({ ...item, occurred: item.occurred && new Date(item.occurred), properties: { ...item.properties } })),
-                tags: event.context.tags.map(item => new Tag(item.value)) }
+                tags: event.context.tags.map(item => new Tag(item.value)),
+                namedTags: [...(event.context.namedTags ?? [])] }
         };
     }
 

package/testing/ReactorScenario.ts

@@ -13,11 +13,13 @@ import type { AppendedEvent } from '../events/AppendedEvent.js';
 import type { EventContext } from '../events/EventContext.js';
 import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
 import { getFilterTagsFor } from '../events/filterEventsByTagDecorator.js';
+import { mergeNamedTags } from '../events/mergeNamedTags.js';
 import { getEventSourceTypeFor } from '../events/eventSourceTypeDecorator.js';
 import { getDeclaredEventStreamTypeFor, getEventStreamTypeFor } from '../events/eventStreamTypeDecorator.js';
 import type { IEventLog } from '../eventSequences/IEventLog.js';
 import type { EventForEventSourceId } from '../eventSequences/EventForEventSourceId.js';
 import type { AppendOptions } from '../eventSequences/AppendOptions.js';
+import { ensureNamedTagBatchIsSupported } from '../eventSequences/ensureNamedTagBatchIsSupported.js';
 import { EventStoreName } from '../EventStoreName.js';
 import { EventStoreNamespaceName } from '../EventStoreNamespaceName.js';
 import type { IEventStore } from '../IEventStore.js';
@@ -297,6 +299,10 @@ export class ReactorScenario {
             throw new UnsupportedReactorOperation('handler.return', this._reactor.name,
                 'Only registered events and production EventForEventSourceId wrappers may be recorded; commands and unknown values are unsupported.');
         }
+        // Production validates named tags before appending, failing the delivery on an invalid tag; so does recording.
+        for (const target of events) mergeNamedTags(target.namedTags);
+        ensureNamedTagBatchIsSupported(events.some(event => mergeNamedTags(event.namedTags).length > 0),
+            events.some(event => event.eventSource !== undefined));
         for (const target of events) {
             this._effects.push(Object.freeze({ kind: 'event', value: target.event, target, triggeringContext: context,
                 handler, deliveryIndex }));

package/testing/for_EventScenario/when_appending_event_sequence_constraints/event_sequence_scenario_behaviors.fixture.ts

@@ -0,0 +1,101 @@
+// 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 { chai, describe, it, vi, type Assertion } from 'vitest';
+import type { Constructor } from '@cratis/fundamentals';
+import { getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import { compileConstraints } from '../../../events/constraints/Constraints.js';
+import { EventScenario } from '../../index.js';
+import { InProcessConstraints } from '../../InProcessConstraints.js';
+
+chai.should();
+function should(value: unknown): Assertion { return (value as { should: Assertion }).should; }
+
+type Entry = { source: string; type: string; value: string };
+type Definition = { kind: string; name: string; events?: Array<{ type: string; properties: string[] }>; eventTypes?: string[];
+    ignoreCasing?: boolean; removedWithEventTypeIds: string[]; message: string; eventSequences: string[] };
+type History = { sequence: string; source: string; sourceType?: string; streamType?: string; streamId?: string;
+    type: string; content: Record<string, unknown>; hash?: string };
+type Outcome = { success: boolean; sequences: string[]; errors: 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> }>; history: History[]; next: string };
+type SequenceCase = { name: string; kind: string; eventSchemas: Record<string, { eventTypeId: string; properties: Record<string, string> }>;
+    constraintDefinitions: Definition[]; isolatedConstraintOperations: Array<{ mode: string; events: Entry[] }> };
+type Fixture = { eventSequenceCases: SequenceCase[]; expected: { cases: Array<{ name: string; result: { outcomes: Outcome[] } }> } };
+
+/**
+ * Replays constraints-event-sequences.json: a definition applying to the event log behaves as unscoped, and one
+ * applying only to other event sequences is neither validated nor indexed on the scenario's event log.
+ * @param types - Event constructors by fixture alias.
+ * @param constraints - Selects the constraint classes for a case name.
+ */
+export function eventSequenceScenarioBehaviors(
+    types: Record<string, new (value: string) => object>,
+    constraints: (caseName: string) => Constructor[]
+): void {
+    const fixture = JSON.parse(readFileSync(new URL('../../fixtures/constraints-event-sequences.json', import.meta.url), 'utf8')) as Fixture;
+    const historyOf = (scenario: EventScenario): History[] => scenario.appendedEvents.map(event => ({
+        sequence: event.context.sequenceNumber.toString(), source: event.context.eventSourceId,
+        sourceType: event.context.eventSourceType, streamType: event.context.eventStreamType, streamId: event.context.eventStreamId,
+        type: event.eventType.id.value, content: event.content, hash: event.context.hash
+    }));
+    const aliases = Object.fromEntries(Object.entries(types).map(([alias, type]) => [getEventTypeMetadata(type)!.eventType.id.value, alias]));
+
+    it('should retain every event sequence case', () => {
+        should(fixture.eventSequenceCases.map(test => test.name)).deep.equal([
+            'property-event-log', 'property-event-log-and-outbox', 'property-outbox',
+            'cycle-event-log', 'cycle-outbox', 'once-event-log', 'once-outbox'
+        ]);
+        should(fixture.expected.cases.map(test => test.name)).deep.equal(fixture.eventSequenceCases.map(test => test.name));
+    });
+
+    for (const [caseIndex, test] of fixture.eventSequenceCases.entries()) {
+        describe(`with ${test.name}`, () => {
+            it('should match the installed definitions and kernel violations, history and next sequence', async () => {
+                const selected = Object.keys(test.eventSchemas).map(alias => types[alias]);
+                const selectedConstraints = constraints(test.name);
+                const compiled = compileConstraints({ eventTypes: selected, constraints: selectedConstraints });
+                should([...compiled].map(([name, capture]) => ({
+                    kind: capture.uniqueConstraint ? 'uniqueProperty' : 'uniqueEventType', name,
+                    ...(capture.uniqueConstraint ? {
+                        events: capture.uniqueConstraint.eventDefinitions.map(entry => ({ type: aliases[entry.eventTypeId], properties: entry.properties })),
+                        ignoreCasing: capture.uniqueConstraint.ignoreCasing
+                    } : { eventTypes: (capture.uniqueEventType!.eventTypeIds ?? [capture.uniqueEventType!.eventTypeId]).map(id => aliases[id]) }),
+                    removedWithEventTypeIds: (capture.uniqueConstraint?.removedWithEventTypeIds ?? capture.uniqueEventType?.removedWithEventTypeIds ?? []).map(id => aliases[id]),
+                    message: capture.uniqueConstraint?.message ?? capture.uniqueEventType?.message ?? '',
+                    eventSequences: capture.eventSequences ?? []
+                }))).deep.equal(test.constraintDefinitions);
+                const scenario = new EventScenario({ artifacts: { eventTypes: selected, constraints: selectedConstraints } });
+                const validate = vi.spyOn(InProcessConstraints.prototype, 'validate');
+                const expected = fixture.expected.cases[caseIndex].result.outcomes;
+                should(expected.length).equal(test.isolatedConstraintOperations.length);
+                try {
+                    for (const [index, operation] of test.isolatedConstraintOperations.entries()) {
+                        const before = historyOf(scenario);
+                        const entries = operation.events.map(entry => ({ eventSourceId: entry.source, event: new types[entry.type](entry.value) }));
+                        const results = operation.mode === 'single'
+                            ? [await scenario.append(entries[0].eventSourceId, entries[0].event)]
+                            : await scenario.appendMany(entries);
+                        const outcome = expected[index];
+                        const raw = validate.mock.results.at(-1)!.value as ReturnType<InProcessConstraints['validate']>;
+                        should(raw.map(({ SequenceNumber, ...violation }) => ({ ...violation, SequenceNumber: SequenceNumber.toString() })))
+                            .deep.equal(outcome.wireViolations);
+                        for (const [position, result] of results.entries()) {
+                            should(result.isSuccess).equal(outcome.success);
+                            should(result.sequenceNumber.value.toString()).equal(outcome.success ? outcome.sequences[position] : '0');
+                            should(result.constraintViolations.map(violation => ({ id: violation.constraintId, message: violation.message, details: violation.details })))
+                                .deep.equal(outcome.violations);
+                            should(result.errors.map(error => error.message)).deep.equal(outcome.errors);
+                        }
+                        if (!outcome.success) should(historyOf(scenario)).deep.equal(before);
+                        should(historyOf(scenario)).deep.equal(outcome.history);
+                        should((await scenario.eventLog.getNextSequenceNumber()).value.toString()).equal(outcome.next);
+                    }
+                } finally {
+                    validate.mockRestore();
+                }
+            });
+        });
+    }
+}

package/testing/for_EventScenario/when_appending_event_sequence_constraints/other_sequence_extended_key.legacy.spec.ts

@@ -0,0 +1,28 @@
+// 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 { describe } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import { otherSequenceExtendedKeyBehaviors } from './other_sequence_extended_key_behaviors.fixture.js';
+
+@eventType('OracleOtherSequenceNumber')
+class NumberClaimed { @field(Number) key = 1; }
+@eventType('OracleOtherSequenceOutbox')
+class OutboxClaimed { @field(String) label = 'x'; }
+
+@constraint('OracleOtherSequenceNumberKey')
+class NumberKey {
+    define(builder: IConstraintBuilder) { builder.forEventLog().unique(key => key.on(NumberClaimed, event => event.key)); }
+}
+@constraint('OracleOtherSequenceOutboxKey')
+class OutboxKey {
+    define(builder: IConstraintBuilder) { builder.forEventSequences('outbox').unique(key => key.on(OutboxClaimed, event => event.label)); }
+}
+
+describe('when appending extended keys beside other event sequence constraints with  decorators', () => {
+    otherSequenceExtendedKeyBehaviors(NumberClaimed, OutboxClaimed, [NumberKey, OutboxKey]);
+});

package/testing/for_EventScenario/when_appending_event_sequence_constraints/other_sequence_extended_key.standard.spec.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { describe } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import { otherSequenceExtendedKeyBehaviors } from './other_sequence_extended_key_behaviors.fixture.js';
+
+@eventType('OracleOtherSequenceNumber')
+class NumberClaimed { @field(Number) key = 1; }
+@eventType('OracleOtherSequenceOutbox')
+class OutboxClaimed { @field(String) label = 'x'; }
+
+@constraint('OracleOtherSequenceNumberKey')
+class NumberKey {
+    define(builder: IConstraintBuilder) { builder.forEventLog().unique(key => key.on(NumberClaimed, event => event.key)); }
+}
+@constraint('OracleOtherSequenceOutboxKey')
+class OutboxKey {
+    define(builder: IConstraintBuilder) { builder.forEventSequences('outbox').unique(key => key.on(OutboxClaimed, event => event.label)); }
+}
+
+describe('when appending extended keys beside other event sequence constraints with  decorators', () => {
+    otherSequenceExtendedKeyBehaviors(NumberClaimed, OutboxClaimed, [NumberKey, OutboxKey]);
+});