@cratis/chronicle 3.0.0 → 3.1.0

package/dist/eventSequences/CompleteStreamError.js

@@ -0,0 +1,20 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Represents the errors that can occur when completing a stream on an {@link IEventSequence}.
+ */
+export var CompleteStreamError;
+(function (CompleteStreamError) {
+    /**
+     * The stream was already completed previously. Completing a stream is idempotent at the storage
+     * level, but the caller is informed via this error so it can distinguish a freshly completed
+     * stream from one that was already in the completed state.
+     */
+    CompleteStreamError["AlreadyCompleted"] = "AlreadyCompleted";
+    /**
+     * The default stream (the default event stream type paired with the default event stream identifier)
+     * cannot be completed, since doing so would block all future appends to the event sequence.
+     */
+    CompleteStreamError["DefaultStreamCannotBeCompleted"] = "DefaultStreamCannotBeCompleted";
+})(CompleteStreamError || (CompleteStreamError = {}));
+//# sourceMappingURL=CompleteStreamError.js.map

package/dist/eventSequences/CompleteStreamError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompleteStreamError.js","sourceRoot":"","sources":["../../eventSequences/CompleteStreamError.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG;AAErG;;GAEG;AACH,MAAM,CAAN,IAAY,mBAaX;AAbD,WAAY,mBAAmB;IAC3B;;;;OAIG;IACH,4DAAqC,CAAA;IAErC;;;OAGG;IACH,wFAAiE,CAAA;AACrE,CAAC,EAbW,mBAAmB,KAAnB,mBAAmB,QAa9B"}

package/dist/eventSequences/CompleteStreamResult.d.ts

@@ -0,0 +1,14 @@
+import { CompleteStreamError } from './CompleteStreamError';
+import { EventSequenceNumber } from './EventSequenceNumber';
+/**
+ * Represents the outcome of completing a stream on an {@link IEventSequence}: either the tail
+ * sequence number at the moment of completion, or a typed error describing why it was rejected.
+ */
+export type CompleteStreamResult = {
+    readonly isSuccess: true;
+    readonly sequenceNumber: EventSequenceNumber;
+} | {
+    readonly isSuccess: false;
+    readonly error: CompleteStreamError;
+};
+//# sourceMappingURL=CompleteStreamResult.d.ts.map

package/dist/eventSequences/CompleteStreamResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompleteStreamResult.d.ts","sourceRoot":"","sources":["../../eventSequences/CompleteStreamResult.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAC1B;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAC"}

package/dist/eventSequences/CompleteStreamResult.js

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export {};
+//# sourceMappingURL=CompleteStreamResult.js.map

package/dist/eventSequences/CompleteStreamResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompleteStreamResult.js","sourceRoot":"","sources":["../../eventSequences/CompleteStreamResult.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/ConcurrencyViolation.d.ts

@@ -0,0 +1,13 @@
+import { EventSequenceNumber } from './EventSequenceNumber';
+/**
+ * Represents a concurrency violation that occurred during an append operation.
+ */
+export interface ConcurrencyViolation {
+    /** The event source identifier where the violation occurred. */
+    readonly eventSourceId: string;
+    /** The expected sequence number. */
+    readonly expectedSequenceNumber: EventSequenceNumber;
+    /** The actual sequence number. */
+    readonly actualSequenceNumber: EventSequenceNumber;
+}
+//# sourceMappingURL=ConcurrencyViolation.d.ts.map

package/dist/eventSequences/ConcurrencyViolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyViolation.d.ts","sourceRoot":"","sources":["../../eventSequences/ConcurrencyViolation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,gEAAgE;IAChE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,oCAAoC;IACpC,QAAQ,CAAC,sBAAsB,EAAE,mBAAmB,CAAC;IAErD,kCAAkC;IAClC,QAAQ,CAAC,oBAAoB,EAAE,mBAAmB,CAAC;CACtD"}

package/dist/eventSequences/ConcurrencyViolation.js

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export {};
+//# sourceMappingURL=ConcurrencyViolation.js.map

package/dist/eventSequences/ConcurrencyViolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyViolation.js","sourceRoot":"","sources":["../../eventSequences/ConcurrencyViolation.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/EventForEventSourceId.d.ts

@@ -6,5 +6,13 @@ export interface EventForEventSourceId {
     readonly eventSourceId: string;
     /** The event payload to append. */
     readonly event: object;
+    /** Optional event stream type to append to. Defaults to the default stream type. */
+    readonly eventStreamType?: string;
+    /** Optional event stream identifier to append to. Defaults to the event source id. */
+    readonly eventStreamId?: string;
+    /** Optional event source type to append to. Defaults to the default source type. */
+    readonly eventSourceType?: string;
+    /** Optional subject identifying the target the event is about. Defaults to the event source id. */
+    readonly subject?: string;
 }
 //# sourceMappingURL=EventForEventSourceId.d.ts.map

package/dist/eventSequences/EventForEventSourceId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventForEventSourceId.d.ts","sourceRoot":"","sources":["../../eventSequences/EventForEventSourceId.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B"}
+{"version":3,"file":"EventForEventSourceId.d.ts","sourceRoot":"","sources":["../../eventSequences/EventForEventSourceId.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,oFAAoF;IACpF,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAElC,sFAAsF;IACtF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,oFAAoF;IACpF,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAElC,mGAAmG;IACnG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC7B"}

package/dist/eventSequences/EventSequence.d.ts

@@ -1,6 +1,11 @@
 import { ChronicleConnection } from '../connection';
+import { Constructor } from '@cratis/fundamentals';
+import type { AppendedEvent } from '../events/AppendedEvent';
+import { AppendedEventWithResult } from './AppendedEventWithResult';
+import { AppendOperationsBroadcaster } from './AppendOperationsBroadcaster';
 import { AppendOptions } from './AppendOptions';
 import { AppendResult } from './AppendResult';
+import { CompleteStreamResult } from './CompleteStreamResult';
 import { EventForEventSourceId } from './EventForEventSourceId';
 import { IEventSequence } from './IEventSequence';
 import { ITransactionalEventSequence } from './ITransactionalEventSequence';
@@ -18,6 +23,7 @@ export declare class EventSequence implements IEventSequence {
     private readonly _connection;
     private readonly _unitOfWorkManager;
     readonly transactional: ITransactionalEventSequence;
+    readonly appendOperations: AppendOperationsBroadcaster<AppendedEventWithResult[]>;
     constructor(id: EventSequenceId, _eventStoreName: string, _namespace: string, _connection: ChronicleConnection, _unitOfWorkManager: IUnitOfWorkManager);
     /** @inheritdoc */
     append(eventSourceId: string, event: object, options?: AppendOptions): Promise<AppendResult>;
@@ -25,10 +31,38 @@ export declare class EventSequence implements IEventSequence {
     appendMany(eventSourceId: string, events: object[], options?: AppendOptions): Promise<AppendResult[]>;
     appendMany(events: EventForEventSourceId[], options?: AppendOptions): Promise<AppendResult[]>;
     /** @inheritdoc */
-    getTailSequenceNumber(eventSourceId?: string): Promise<EventSequenceNumber>;
+    getNextSequenceNumber(): Promise<EventSequenceNumber>;
+    /** @inheritdoc */
+    getTailSequenceNumber(eventSourceId?: string, eventSourceType?: string, eventStreamType?: string, eventStreamId?: string, filterEventTypes?: Constructor[]): Promise<EventSequenceNumber>;
+    /** @inheritdoc */
+    getTailSequenceNumberForObserver(observerType: Constructor): Promise<EventSequenceNumber>;
     /** @inheritdoc */
     hasEventsFor(eventSourceId: string): Promise<boolean>;
+    /** @inheritdoc */
+    getForEventSourceIdAndEventTypes(eventSourceId: string, eventTypes: Constructor[], eventStreamType?: string, eventStreamId?: string, eventSourceType?: string): Promise<AppendedEvent[]>;
+    /** @inheritdoc */
+    getFromSequenceNumber(sequenceNumber: EventSequenceNumber, eventSourceId?: string, filterEventTypes?: Constructor[]): Promise<AppendedEvent[]>;
+    /** @inheritdoc */
+    redact(sequenceNumber: EventSequenceNumber, reason: string): Promise<void>;
+    /** @inheritdoc */
+    redactForEventSource(eventSourceId: string, reason: string, eventTypes?: Constructor[]): Promise<void>;
+    /**
+     * Resolves which registered event type classes a given observer (reactor/reducer) type handles,
+     * using the same naming convention the observation runtimes use to dispatch events to handler
+     * methods: an event type named `SomethingHappened` dispatches to a method named `somethingHappened`.
+     */
+    private getEventTypesHandledBy;
+    /** @inheritdoc */
+    completeStream(eventStreamType: string, eventStreamId: string): Promise<CompleteStreamResult>;
+    private toClientCompleteStreamError;
+    private toContractEventTypes;
+    private toClientAppendedEvent;
     private mapAppendResponse;
+    /**
+     * Waits for all observers affected by an append to either process up to the given tail sequence
+     * number or fail. Backs {@link AppendResult.waitForCompletion}.
+     */
+    private waitForObserverCompletion;
     private toContractConcurrencyScope;
 }
 //# sourceMappingURL=EventSequence.d.ts.map

package/dist/eventSequences/EventSequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventSequence.d.ts","sourceRoot":"","sources":["../../eventSequences/EventSequence.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAIpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAS5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE;;;GAGG;AACH,qBAAa,aAAc,YAAW,cAAc;IAI5C,QAAQ,CAAC,EAAE,EAAE,eAAe;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAPvC,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAC;gBAGvC,EAAE,EAAE,eAAe,EACX,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,mBAAmB,EAChC,kBAAkB,EAAE,kBAAkB;IAK3D,kBAAkB;IACZ,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA+FlG,kBAAkB;IACZ,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IACrG,UAAU,CAAC,MAAM,EAAE,qBAAqB,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAmJnG,kBAAkB;IACZ,qBAAqB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkCjF,kBAAkB;IACZ,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4B3D,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,0BAA0B;CAcrC"}
+{"version":3,"file":"EventSequence.d.ts","sourceRoot":"","sources":["../../eventSequences/EventSequence.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,WAAW,EAAwB,MAAM,sBAAsB,CAAC;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAO7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAa5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE;;;GAGG;AACH,qBAAa,aAAc,YAAW,cAAc;IAK5C,QAAQ,CAAC,EAAE,EAAE,eAAe;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IARvC,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAC;IACpD,QAAQ,CAAC,gBAAgB,yDAAgE;gBAG5E,EAAE,EAAE,eAAe,EACX,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,mBAAmB,EAChC,kBAAkB,EAAE,kBAAkB;IAK3D,kBAAkB;IACZ,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAmHlG,kBAAkB;IACZ,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IACrG,UAAU,CAAC,MAAM,EAAE,qBAAqB,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAwLnG,kBAAkB;IACZ,qBAAqB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAQ3D,kBAAkB;IACZ,qBAAqB,CACvB,aAAa,CAAC,EAAE,MAAM,EACtB,eAAe,CAAC,EAAE,MAAM,EACxB,eAAe,CAAC,EAAE,MAAM,EACxB,aAAa,CAAC,EAAE,MAAM,EACtB,gBAAgB,CAAC,EAAE,WAAW,EAAE,GACjC,OAAO,CAAC,mBAAmB,CAAC;IAkC/B,kBAAkB;IACZ,gCAAgC,CAAC,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAK/F,kBAAkB;IACZ,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4B3D,kBAAkB;IACZ,gCAAgC,CAClC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,WAAW,EAAE,EACzB,eAAe,CAAC,EAAE,MAAM,EACxB,aAAa,CAAC,EAAE,MAAM,EACtB,eAAe,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,aAAa,EAAE,CAAC;IA+B3B,kBAAkB;IACZ,qBAAqB,CACvB,cAAc,EAAE,mBAAmB,EACnC,aAAa,CAAC,EAAE,MAAM,EACtB,gBAAgB,CAAC,EAAE,WAAW,EAAE,GACjC,OAAO,CAAC,aAAa,EAAE,CAAC;IA8B3B,kBAAkB;IACZ,MAAM,CAAC,cAAc,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqChF,kBAAkB;IACZ,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8C5G;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAW9B,kBAAkB;IACZ,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAgCnG,OAAO,CAAC,2BAA2B;IAMnC,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,iBAAiB;IAoCzB;;;OAGG;YACW,yBAAyB;IAwBvC,OAAO,CAAC,0BAA0B;CAcrC"}

package/dist/eventSequences/EventSequence.js

@@ -3,14 +3,24 @@
 import { SpanStatusCode } from '@opentelemetry/api';
 import { Guid, JsonSerializer } from '@cratis/fundamentals';
 import { getEventTypeFor } from '../events/eventTypeDecorator';
+import { EventType } from '../events/EventType';
+import { EventTypeId } from '../events/EventTypeId';
+import { EventTypeGeneration } from '../events/EventTypeGeneration';
+import { DecoratorType } from '../types/DecoratorType';
+import { TypeDiscoverer } from '../types/TypeDiscoverer';
+import { toClientFailedPartition } from '../observation/toClientFailedPartition';
+import { AppendOperationsBroadcaster } from './AppendOperationsBroadcaster';
+import { CompleteStreamError } from './CompleteStreamError';
 import { EventSequenceNumber } from './EventSequenceNumber';
 import { TransactionalEventSequence } from './TransactionalEventSequence';
+/** Default timeout for {@link AppendResult.waitForCompletion}, matching the C# client's default. */
+const DEFAULT_WAIT_FOR_COMPLETION_TIMEOUT_MS = 5000;
 import { ChronicleTracer } from '../Tracing';
 import { ChronicleMetrics } from '../Metrics';
 import { identityProvider } from '../identity';
 import { causationManager, CausationType } from '../auditing';
 import { correlationIdManager } from '../correlation';
-import { toContractsGuid } from '../connection/Guid';
+import { fromContractsGuid, toContractsGuid } from '../connection/Guid';
 /**
  * Implements {@link IEventSequence} by communicating with the Chronicle Kernel
  * via gRPC using the {@link ChronicleConnection}.
@@ -22,6 +32,7 @@ export class EventSequence {
     _connection;
     _unitOfWorkManager;
     transactional;
+    appendOperations = new AppendOperationsBroadcaster();
     constructor(id, _eventStoreName, _namespace, _connection, _unitOfWorkManager) {
         this.id = id;
         this._eventStoreName = _eventStoreName;
@@ -82,7 +93,7 @@ export class EventSequence {
                     Subject: eventSourceId
                 });
                 const duration = Date.now() - startTime;
-                const result = this.mapAppendResponse(response.SequenceNumber, response.ConstraintViolations ?? [], response.Errors ?? []);
+                const result = this.mapAppendResponse(response.SequenceNumber, response.ConstraintViolations ?? [], response.Errors ?? [], response.ConcurrencyViolation);
                 span.setAttribute('chronicle.sequence_number', result.sequenceNumber.value.toString());
                 span.setStatus({ code: SpanStatusCode.OK });
                 ChronicleMetrics.eventsAppended.add(1, metricAttributes);
@@ -101,6 +112,23 @@ export class EventSequence {
                         'chronicle.event_sequence_id': this.id.value
                     });
                 }
+                if (this.appendOperations.hasSubscribers) {
+                    this.appendOperations.publish([{
+                            event: {
+                                context: {
+                                    sequenceNumber: result.sequenceNumber.value,
+                                    eventSourceId,
+                                    eventType,
+                                    occurred: new Date(),
+                                    correlationId: correlationId.toString(),
+                                    causation: causationChain.map(c => ({ type: c.type.name, properties: { ...c.properties } }))
+                                },
+                                eventType,
+                                content: event
+                            },
+                            result
+                        }]);
+                }
                 return result;
             }
             catch (error) {
@@ -148,14 +176,20 @@ export class EventSequence {
         causationManager.add(CausationType.appendManyEvents, { count: String(eventsForEventSourceIds.length) });
         const batchCausationChain = causationManager.getCurrentChain();
         const identity = identityProvider.getCurrent();
-        const concurrencyScope = this.toContractConcurrencyScope(appendOptions?.concurrencyScope);
-        const eventsToAppend = eventsForEventSourceIds.map(({ eventSourceId, event }) => {
+        // Each distinct event source id in the batch gets its own concurrency scope: an explicit
+        // entry in options.concurrencyScopes wins, falling back to the shared options.concurrencyScope
+        // when no per-source entry is given — mirroring C#'s AppendMany(IEnumerable<EventForEventSourceId>, ...)
+        // overload, which takes an IDictionary<EventSourceId, ConcurrencyScope> rather than one shared scope.
+        const concurrencyScopesByEventSourceId = appendOptions?.concurrencyScopes;
+        const defaultConcurrencyScope = appendOptions?.concurrencyScope;
+        const resolveConcurrencyScope = (eventSourceId) => this.toContractConcurrencyScope(concurrencyScopesByEventSourceId?.[eventSourceId] ?? defaultConcurrencyScope);
+        const eventsToAppend = eventsForEventSourceIds.map(({ eventSourceId, event, eventStreamType, eventStreamId, eventSourceType, subject }) => {
             const eventType = getEventTypeFor(event.constructor);
             return {
-                EventSourceType: 'Default',
+                EventSourceType: eventSourceType ?? 'Default',
                 EventSourceId: eventSourceId,
-                EventStreamType: 'Default',
-                EventStreamId: eventSourceId,
+                EventStreamType: eventStreamType ?? 'Default',
+                EventStreamId: eventStreamId ?? eventSourceId,
                 EventType: {
                     Id: eventType.id.value,
                     Generation: eventType.generation.value,
@@ -168,10 +202,9 @@ export class EventSequence {
                     Properties: { ...c.properties }
                 })),
                 CausedBy: toContractsCausedBy(identity),
-                ConcurrencyScope: concurrencyScope,
                 Tags: [],
                 Occurred: undefined,
-                Subject: eventSourceId
+                Subject: subject ?? eventSourceId
             };
         });
         const distinctEventSourceIds = [...new Set(eventsForEventSourceIds.map(_ => _.eventSourceId))];
@@ -204,11 +237,15 @@ export class EventSequence {
                     })),
                     CausedBy: toContractsCausedBy(identity),
                     ConcurrencyScopes: {
-                        ...Object.fromEntries(distinctEventSourceIds.map(eventSourceId => [eventSourceId, concurrencyScope]))
+                        ...Object.fromEntries(distinctEventSourceIds.map(eventSourceId => [eventSourceId, resolveConcurrencyScope(eventSourceId)]))
                     }
                 });
                 const duration = Date.now() - startTime;
-                const result = (response.SequenceNumbers ?? []).map((sequenceNumber, index) => this.mapAppendResponse(sequenceNumber, response.ConstraintViolations ?? [], (response.Errors ?? []).filter((_, errorIndex) => errorIndex === index)));
+                // Mirrors the C# client: every per-event AppendResult in a batch carries all
+                // constraint violations and the first concurrency violation of the whole batch —
+                // the wire response doesn't correlate either back to a specific event index.
+                const firstConcurrencyViolation = (response.ConcurrencyViolations ?? [])[0];
+                const result = (response.SequenceNumbers ?? []).map((sequenceNumber, index) => this.mapAppendResponse(sequenceNumber, response.ConstraintViolations ?? [], (response.Errors ?? []).filter((_, errorIndex) => errorIndex === index), firstConcurrencyViolation));
                 span.setStatus({ code: SpanStatusCode.OK });
                 ChronicleMetrics.batchAppendsPerformed.add(1, batchMetricAttributes);
                 ChronicleMetrics.eventsAppended.add(eventsForEventSourceIds.length, batchMetricAttributes);
@@ -229,6 +266,29 @@ export class EventSequence {
                         'chronicle.event_sequence_id': this.id.value
                     });
                 }
+                if (this.appendOperations.hasSubscribers && result.length > 0) {
+                    const occurredAt = new Date();
+                    const causationEntries = batchCausationChain.map(c => ({ type: c.type.name, properties: { ...c.properties } }));
+                    this.appendOperations.publish(result.map((appendResult, index) => {
+                        const { eventSourceId, event } = eventsForEventSourceIds[index];
+                        const eventType = getEventTypeFor(event.constructor);
+                        return {
+                            event: {
+                                context: {
+                                    sequenceNumber: appendResult.sequenceNumber.value,
+                                    eventSourceId,
+                                    eventType,
+                                    occurred: occurredAt,
+                                    correlationId: correlationId.toString(),
+                                    causation: causationEntries
+                                },
+                                eventType,
+                                content: event
+                            },
+                            result: appendResult
+                        };
+                    }));
+                }
                 return result;
             }
             catch (error) {
@@ -247,7 +307,15 @@ export class EventSequence {
         });
     }
     /** @inheritdoc */
-    async getTailSequenceNumber(eventSourceId) {
+    async getNextSequenceNumber() {
+        const tail = await this.getTailSequenceNumber();
+        if (tail.value === EventSequenceNumber.unset.value) {
+            return EventSequenceNumber.first;
+        }
+        return new EventSequenceNumber(tail.value + 1n);
+    }
+    /** @inheritdoc */
+    async getTailSequenceNumber(eventSourceId, eventSourceType, eventStreamType, eventStreamId, filterEventTypes) {
         return ChronicleTracer.startActiveSpan('chronicle.event_sequences.get_tail_sequence_number', async (span) => {
             span.setAttribute('chronicle.event_store', this._eventStoreName);
             span.setAttribute('chronicle.namespace', this._namespace);
@@ -261,10 +329,10 @@ export class EventSequence {
                     Namespace: this._namespace,
                     EventSequenceId: this.id.value,
                     EventSourceId: eventSourceId ?? '',
-                    EventTypes: [],
-                    EventSourceType: 'Default',
-                    EventStreamId: '',
-                    EventStreamType: 'Default'
+                    EventTypes: this.toContractEventTypes(filterEventTypes ?? []),
+                    EventSourceType: eventSourceType ?? 'Default',
+                    EventStreamId: eventStreamId ?? '',
+                    EventStreamType: eventStreamType ?? 'Default'
                 });
                 const result = new EventSequenceNumber(response.SequenceNumber ?? 0n);
                 span.setAttribute('chronicle.sequence_number', result.value.toString());
@@ -282,6 +350,11 @@ export class EventSequence {
         });
     }
     /** @inheritdoc */
+    async getTailSequenceNumberForObserver(observerType) {
+        const eventTypes = this.getEventTypesHandledBy(observerType);
+        return this.getTailSequenceNumber(undefined, undefined, undefined, undefined, eventTypes);
+    }
+    /** @inheritdoc */
     async hasEventsFor(eventSourceId) {
         return ChronicleTracer.startActiveSpan('chronicle.event_sequences.has_events_for', async (span) => {
             span.setAttribute('chronicle.event_store', this._eventStoreName);
@@ -310,19 +383,277 @@ export class EventSequence {
             }
         });
     }
-    mapAppendResponse(sequenceNumber, constraintViolations, errors) {
+    /** @inheritdoc */
+    async getForEventSourceIdAndEventTypes(eventSourceId, eventTypes, eventStreamType, eventStreamId, eventSourceType) {
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.get_for_event_source_id_and_event_types', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.event_source_id', eventSourceId);
+            try {
+                const response = await this._connection.eventSequences.getForEventSourceIdAndEventTypes({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    EventSourceType: eventSourceType ?? 'Default',
+                    EventSourceId: eventSourceId,
+                    EventStreamType: eventStreamType ?? 'Default',
+                    EventStreamId: eventStreamId ?? '',
+                    EventTypes: this.toContractEventTypes(eventTypes)
+                });
+                const result = (response.Events ?? []).map(event => this.toClientAppendedEvent(event));
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /** @inheritdoc */
+    async getFromSequenceNumber(sequenceNumber, eventSourceId, filterEventTypes) {
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.get_from_sequence_number', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.sequence_number', sequenceNumber.value.toString());
+            try {
+                const response = await this._connection.eventSequences.getEventsFromEventSequenceNumber({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    FromEventSequenceNumber: sequenceNumber.value,
+                    ToEventSequenceNumber: 0n,
+                    EventSourceId: eventSourceId ?? '',
+                    EventTypes: this.toContractEventTypes(filterEventTypes ?? [])
+                });
+                const result = (response.Events ?? []).map(event => this.toClientAppendedEvent(event));
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /** @inheritdoc */
+    async redact(sequenceNumber, reason) {
+        causationManager.add(CausationType.redact, { sequenceNumber: sequenceNumber.value.toString() });
+        const causationChain = causationManager.getCurrentChain();
+        const identity = identityProvider.getCurrent();
+        const correlationId = Guid.as(correlationIdManager.current.value);
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.redact', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.sequence_number', sequenceNumber.value.toString());
+            try {
+                await this._connection.eventSequences.redact({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    SequenceNumber: sequenceNumber.value,
+                    Reason: reason,
+                    CorrelationId: toContractsGuid(correlationId),
+                    Causation: causationChain.map(c => ({
+                        Occurred: { Value: c.occurred.toISOString() },
+                        Type: c.type.name,
+                        Properties: { ...c.properties }
+                    })),
+                    CausedBy: toContractsCausedBy(identity)
+                });
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /** @inheritdoc */
+    async redactForEventSource(eventSourceId, reason, eventTypes) {
+        causationManager.add(CausationType.redactForEventSource, { eventSourceId });
+        const causationChain = causationManager.getCurrentChain();
+        const identity = identityProvider.getCurrent();
+        const correlationId = Guid.as(correlationIdManager.current.value);
+        const wireEventTypes = (eventTypes ?? []).map(constructor => {
+            const eventType = getEventTypeFor(constructor);
+            return {
+                Id: eventType.id.value,
+                Generation: eventType.generation.value,
+                Tombstone: eventType.tombstone
+            };
+        });
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.redact_for_event_source', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.event_source_id', eventSourceId);
+            try {
+                await this._connection.eventSequences.redactForEventSource({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    EventSourceId: eventSourceId,
+                    Reason: reason,
+                    EventTypes: wireEventTypes,
+                    CorrelationId: toContractsGuid(correlationId),
+                    Causation: causationChain.map(c => ({
+                        Occurred: { Value: c.occurred.toISOString() },
+                        Type: c.type.name,
+                        Properties: { ...c.properties }
+                    })),
+                    CausedBy: toContractsCausedBy(identity)
+                });
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /**
+     * Resolves which registered event type classes a given observer (reactor/reducer) type handles,
+     * using the same naming convention the observation runtimes use to dispatch events to handler
+     * methods: an event type named `SomethingHappened` dispatches to a method named `somethingHappened`.
+     */
+    getEventTypesHandledBy(observerType) {
+        const prototype = observerType.prototype;
+        const eventTypeClasses = TypeDiscoverer.default.getTypesByDecoratorType(DecoratorType.EventType);
+        return eventTypeClasses.filter(eventTypeClass => {
+            const className = eventTypeClass.name;
+            const methodName = className.charAt(0).toLowerCase() + className.slice(1);
+            return typeof prototype[methodName] === 'function';
+        });
+    }
+    /** @inheritdoc */
+    async completeStream(eventStreamType, eventStreamId) {
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.complete_stream', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.event_stream_type', eventStreamType);
+            span.setAttribute('chronicle.event_stream_id', eventStreamId);
+            try {
+                const response = await this._connection.eventSequences.completeStream({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    EventStreamType: eventStreamType,
+                    EventStreamId: eventStreamId
+                });
+                const result = response.IsSuccess
+                    ? { isSuccess: true, sequenceNumber: new EventSequenceNumber(response.SequenceNumber ?? 0n) }
+                    : { isSuccess: false, error: this.toClientCompleteStreamError(response.Error) };
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    toClientCompleteStreamError(error) {
+        // Mirrors the C# client's switch: any wire value other than DefaultStreamCannotBeCompleted
+        // (including UNRECOGNIZED) is treated as AlreadyCompleted.
+        return error === 1 ? CompleteStreamError.DefaultStreamCannotBeCompleted : CompleteStreamError.AlreadyCompleted;
+    }
+    toContractEventTypes(eventTypes) {
+        return eventTypes.map(constructor => {
+            const eventType = getEventTypeFor(constructor);
+            return {
+                Id: eventType.id.value,
+                Generation: eventType.generation.value,
+                Tombstone: eventType.tombstone
+            };
+        });
+    }
+    toClientAppendedEvent(wireEvent) {
+        const context = wireEvent.Context;
+        const eventType = new EventType(new EventTypeId(context.EventType?.Id ?? ''), new EventTypeGeneration(context.EventType?.Generation ?? EventTypeGeneration.firstValue), context.EventType?.Tombstone ?? false);
+        return {
+            context: {
+                sequenceNumber: context.SequenceNumber,
+                eventSourceId: context.EventSourceId,
+                eventType,
+                occurred: new Date(context.Occurred?.Value ?? ''),
+                correlationId: fromContractsGuid(context.CorrelationId).toString(),
+                causation: (context.Causation ?? []).map(c => ({
+                    type: c.Type,
+                    properties: { ...c.Properties }
+                }))
+            },
+            eventType,
+            content: JSON.parse(wireEvent.Content)
+        };
+    }
+    mapAppendResponse(sequenceNumber, constraintViolations, errors, concurrencyViolation) {
         const mappedViolations = constraintViolations.map(violation => ({
             constraintId: violation.ConstraintId ?? '',
             message: violation.Message ?? '',
             details: violation.Details ?? {}
         }));
         const mappedErrors = errors.map(message => ({ message }));
+        const mappedConcurrencyViolation = concurrencyViolation
+            ? {
+                eventSourceId: concurrencyViolation.EventSourceId ?? '',
+                expectedSequenceNumber: new EventSequenceNumber(concurrencyViolation.ExpectedSequenceNumber ?? 0n),
+                actualSequenceNumber: new EventSequenceNumber(concurrencyViolation.ActualSequenceNumber ?? 0n)
+            }
+            : undefined;
         const safeSequenceNumber = sequenceNumber === 18446744073709551615n ? 0n : sequenceNumber;
+        const eventSequenceNumber = new EventSequenceNumber(safeSequenceNumber);
+        const isSuccess = mappedViolations.length === 0 && mappedErrors.length === 0 && !mappedConcurrencyViolation;
         return {
-            sequenceNumber: new EventSequenceNumber(safeSequenceNumber),
+            sequenceNumber: eventSequenceNumber,
             constraintViolations: mappedViolations,
+            concurrencyViolation: mappedConcurrencyViolation,
             errors: mappedErrors,
-            isSuccess: mappedViolations.length === 0 && mappedErrors.length === 0
+            isSuccess,
+            waitForCompletion: (timeoutMs) => this.waitForObserverCompletion(eventSequenceNumber, isSuccess, timeoutMs)
+        };
+    }
+    /**
+     * Waits for all observers affected by an append to either process up to the given tail sequence
+     * number or fail. Backs {@link AppendResult.waitForCompletion}.
+     */
+    async waitForObserverCompletion(tailSequenceNumber, appendWasSuccessful, timeoutMs = DEFAULT_WAIT_FOR_COMPLETION_TIMEOUT_MS) {
+        if (!appendWasSuccessful) {
+            return { isSuccess: true, failedPartitions: [] };
+        }
+        const response = await this._connection.observers.waitForCompletion({
+            EventStore: this._eventStoreName,
+            Namespace: this._namespace,
+            EventSequenceId: this.id.value,
+            TailEventSequenceNumber: tailSequenceNumber.value
+        }, { signal: AbortSignal.timeout(timeoutMs) });
+        return {
+            isSuccess: response.IsSuccess,
+            failedPartitions: (response.FailedPartitions ?? []).map(failedPartition => toClientFailedPartition(failedPartition))
         };
     }
     toContractConcurrencyScope(scope) {