@cratis/chronicle 4.0.0 → 5.1.0

package/eventSequences/EventSequence.ts

@@ -3,7 +3,7 @@
 
 import { ChronicleConnection } from '../connection';
 import { SpanStatusCode } from '@opentelemetry/api';
-import type { AppendedEvent as ContractsAppendedEvent } from '@cratis/chronicle.contracts';
+import type { AppendedEventResponse as ContractsAppendedEvent } from '@cratis/chronicle.contracts';
 import { Constructor, Guid, JsonSerializer } from '@cratis/fundamentals';
 import { getEventTypeFor } from '../events/eventTypeDecorator';
 import type { AppendedEvent } from '../events/AppendedEvent';
@@ -40,6 +40,7 @@ import { identityProvider, Identity } from '../identity';
 import { causationManager, CausationType } from '../auditing';
 import { correlationIdManager } from '../correlation';
 import { fromContractsGuid, toContractsGuid } from '../connection/Guid';
+import { ensureCommandResponse, ensureCommandSuccess, ensureQuerySuccess } from '../connection/callResults';
 import type { ConcurrencyScope } from './ConcurrencyScope';
 import { IUnitOfWorkManager } from '../transactions/IUnitOfWorkManager';
 
@@ -67,7 +68,7 @@ export class EventSequence implements IEventSequence {
         const correlationId = options?.correlationId === undefined
             ? Guid.as(correlationIdManager.current.value)
             : Guid.as(options.correlationId);
-        const content = JsonSerializer.serialize(event);
+        const content = JSON.parse(JsonSerializer.serialize(event));
 
         // Merge static tags declared on the event type with tags supplied at append time.
         const tags = mergeTags(getTagsFor(event.constructor as Function), options?.tags);
@@ -119,12 +120,13 @@ export class EventSequence implements IEventSequence {
                     Subject: eventSourceId
                 });
 
+                const appendResponse = ensureCommandResponse('append event', response);
                 const duration = Date.now() - startTime;
                 const result = this.mapAppendResponse(
-                    response.SequenceNumber,
-                    response.ConstraintViolations ?? [],
-                    response.Errors ?? [],
-                    response.ConcurrencyViolation
+                    appendResponse.SequenceNumber,
+                    appendResponse.ConstraintViolations ?? [],
+                    appendResponse.Errors ?? [],
+                    appendResponse.ConcurrencyViolation
                 );
                 span.setAttribute('chronicle.sequence_number', result.sequenceNumber.value.toString());
                 span.setStatus({ code: SpanStatusCode.OK });
@@ -247,13 +249,7 @@ export class EventSequence implements IEventSequence {
                     Generation: eventType.generation.value,
                     Tombstone: eventType.tombstone
                 },
-                Content: JsonSerializer.serialize(event),
-                Causation: batchCausationChain.map(c => ({
-                    Occurred: { Value: c.occurred.toISOString() },
-                    Type: c.type.name,
-                    Properties: { ...c.properties }
-                })),
-                CausedBy: toContractsCausedBy(identity),
+                Content: JSON.parse(JsonSerializer.serialize(event)),
                 Tags: tags,
                 Occurred: undefined,
                 Subject: subject ?? eventSourceId
@@ -279,7 +275,7 @@ export class EventSequence implements IEventSequence {
             span.setAttribute('chronicle.events_count', eventsForEventSourceIds.length);
             const startTime = Date.now();
             try {
-                const response = await this._connection.eventSequences.appendMany({
+                const response = await this._connection.eventSequences.appendManyForEventSources({
                     EventStore: this._eventStoreName,
                     Namespace: this._namespace,
                     EventSequenceId: this.id.value,
@@ -291,21 +287,23 @@ export class EventSequence implements IEventSequence {
                         Properties: { ...c.properties }
                     })),
                     CausedBy: toContractsCausedBy(identity),
-                    ConcurrencyScopes: {
-                        ...Object.fromEntries(distinctEventSourceIds.map(eventSourceId => [eventSourceId, resolveConcurrencyScope(eventSourceId)]))
-                    }
+                    ConcurrencyScopes: distinctEventSourceIds.map(eventSourceId => ({
+                        EventSourceId: eventSourceId,
+                        Scope: resolveConcurrencyScope(eventSourceId)
+                    }))
                 });
 
+                const appendManyResponse = ensureCommandResponse('append many events', response);
                 const duration = Date.now() - startTime;
                 // 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: bigint, index: number) =>
+                const firstConcurrencyViolation = (appendManyResponse.ConcurrencyViolations ?? [])[0];
+                const result = (appendManyResponse.SequenceNumbers ?? []).map((sequenceNumber: bigint, index: number) =>
                     this.mapAppendResponse(
                         sequenceNumber,
-                        response.ConstraintViolations ?? [],
-                        (response.Errors ?? []).filter((_: string, errorIndex: number) => errorIndex === index),
+                        appendManyResponse.ConstraintViolations ?? [],
+                        (appendManyResponse.Errors ?? []).filter((_: string, errorIndex: number) => errorIndex === index),
                         firstConcurrencyViolation
                     )
                 );
@@ -398,18 +396,19 @@ export class EventSequence implements IEventSequence {
                 span.setAttribute('chronicle.event_source_id', eventSourceId);
             }
             try {
-                const response = await this._connection.eventSequences.getTailSequenceNumber({
+                const response = await this._connection.eventSequences.tailSequenceNumber({
                     EventStore: this._eventStoreName,
                     Namespace: this._namespace,
                     EventSequenceId: this.id.value,
                     EventSourceId: eventSourceId ?? '',
-                    EventTypes: this.toContractEventTypes(filterEventTypes ?? []),
+                    EventTypeIds: this.joinEventTypeIds(filterEventTypes ?? []),
                     EventSourceType: eventSourceType ?? 'Default',
                     EventStreamId: eventStreamId ?? '',
                     EventStreamType: eventStreamType ?? 'Default'
                 });
 
-                const result = new EventSequenceNumber(response.SequenceNumber ?? 0n);
+                const data = ensureQuerySuccess('get tail sequence number', response);
+                const result = new EventSequenceNumber(data?.SequenceNumber ?? 0n);
                 span.setAttribute('chronicle.sequence_number', result.value.toString());
                 span.setStatus({ code: SpanStatusCode.OK });
                 return result;
@@ -444,7 +443,7 @@ export class EventSequence implements IEventSequence {
                     EventSourceId: eventSourceId
                 });
 
-                const result = response.HasEvents ?? false;
+                const result = ensureQuerySuccess('has events for event source', response)?.HasEvents ?? false;
                 span.setAttribute('chronicle.has_events', result);
                 span.setStatus({ code: SpanStatusCode.OK });
                 return result;
@@ -464,7 +463,8 @@ export class EventSequence implements IEventSequence {
         eventTypes: Constructor[],
         eventStreamType?: string,
         eventStreamId?: string,
-        eventSourceType?: string
+        // Kept for IEventSequence signature compatibility; the wire no longer carries an event source type for this query.
+        _eventSourceType?: string
     ): Promise<AppendedEvent[]> {
         return ChronicleTracer.startActiveSpan('chronicle.event_sequences.get_for_event_source_id_and_event_types', async span => {
             span.setAttribute('chronicle.event_store', this._eventStoreName);
@@ -472,18 +472,17 @@ export class EventSequence implements IEventSequence {
             span.setAttribute('chronicle.event_sequence_id', this.id.value);
             span.setAttribute('chronicle.event_source_id', eventSourceId);
             try {
-                const response = await this._connection.eventSequences.getForEventSourceIdAndEventTypes({
+                const response = await this._connection.eventSequences.forEventSourceIdAndEventTypes({
                     EventStore: this._eventStoreName,
                     Namespace: this._namespace,
                     EventSequenceId: this.id.value,
-                    EventSourceType: eventSourceType ?? 'Default',
                     EventSourceId: eventSourceId,
                     EventStreamType: eventStreamType ?? 'Default',
                     EventStreamId: eventStreamId ?? '',
-                    EventTypes: this.toContractEventTypes(eventTypes)
+                    EventTypeIds: this.joinEventTypeIds(eventTypes)
                 });
 
-                const result = (response.Events ?? []).map(event => this.toClientAppendedEvent(event));
+                const result = ensureQuerySuccess('get events for event source id and event types', response).map(event => this.toClientAppendedEvent(event));
                 span.setStatus({ code: SpanStatusCode.OK });
                 return result;
             } catch (error) {
@@ -508,17 +507,16 @@ export class EventSequence implements IEventSequence {
             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({
+                const response = await this._connection.eventSequences.fromSequenceNumber({
                     EventStore: this._eventStoreName,
                     Namespace: this._namespace,
                     EventSequenceId: this.id.value,
                     FromEventSequenceNumber: sequenceNumber.value,
-                    ToEventSequenceNumber: 0n,
                     EventSourceId: eventSourceId ?? '',
-                    EventTypes: this.toContractEventTypes(filterEventTypes ?? [])
+                    EventTypeIds: this.joinEventTypeIds(filterEventTypes ?? [])
                 });
 
-                const result = (response.Events ?? []).map(event => this.toClientAppendedEvent(event));
+                const result = ensureQuerySuccess('get events from sequence number', response).map(event => this.toClientAppendedEvent(event));
                 span.setStatus({ code: SpanStatusCode.OK });
                 return result;
             } catch (error) {
@@ -536,7 +534,6 @@ export class EventSequence implements IEventSequence {
         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);
@@ -544,20 +541,19 @@ export class EventSequence implements IEventSequence {
             span.setAttribute('chronicle.event_sequence_id', this.id.value);
             span.setAttribute('chronicle.sequence_number', sequenceNumber.value.toString());
             try {
-                await this._connection.eventSequences.redact({
+                ensureCommandSuccess('redact event', 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) });
@@ -574,15 +570,7 @@ export class EventSequence implements IEventSequence {
         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 as unknown as Function);
-            return {
-                Id: eventType.id.value,
-                Generation: eventType.generation.value,
-                Tombstone: eventType.tombstone
-            };
-        });
+        const wireEventTypeIds = (eventTypes ?? []).map(constructor => getEventTypeFor(constructor as unknown as Function).id.value);
 
         return ChronicleTracer.startActiveSpan('chronicle.event_sequences.redact_for_event_source', async span => {
             span.setAttribute('chronicle.event_store', this._eventStoreName);
@@ -590,21 +578,20 @@ export class EventSequence implements IEventSequence {
             span.setAttribute('chronicle.event_sequence_id', this.id.value);
             span.setAttribute('chronicle.event_source_id', eventSourceId);
             try {
-                await this._connection.eventSequences.redactForEventSource({
+                ensureCommandSuccess('redact event source', await this._connection.eventSequences.redactForEventSource({
                     EventStore: this._eventStoreName,
                     Namespace: this._namespace,
                     EventSequenceId: this.id.value,
                     EventSourceId: eventSourceId,
                     Reason: reason,
-                    EventTypes: wireEventTypes,
-                    CorrelationId: toContractsGuid(correlationId),
+                    EventTypes: wireEventTypeIds,
                     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) });
@@ -649,9 +636,10 @@ export class EventSequence implements IEventSequence {
                     EventStreamId: eventStreamId
                 });
 
-                const result: CompleteStreamResult = response.IsSuccess
-                    ? { isSuccess: true, sequenceNumber: new EventSequenceNumber(response.SequenceNumber ?? 0n) }
-                    : { isSuccess: false, error: this.toClientCompleteStreamError(response.Error) };
+                const completeStreamResponse = ensureCommandResponse('complete stream', response);
+                const result: CompleteStreamResult = completeStreamResponse.IsSuccess
+                    ? { isSuccess: true, sequenceNumber: new EventSequenceNumber(completeStreamResponse.SequenceNumber ?? 0n) }
+                    : { isSuccess: false, error: this.toClientCompleteStreamError(completeStreamResponse.Error) };
 
                 span.setStatus({ code: SpanStatusCode.OK });
                 return result;
@@ -671,15 +659,8 @@ export class EventSequence implements IEventSequence {
         return error === 1 ? CompleteStreamError.DefaultStreamCannotBeCompleted : CompleteStreamError.AlreadyCompleted;
     }
 
-    private toContractEventTypes(eventTypes: Constructor[]) {
-        return eventTypes.map(constructor => {
-            const eventType = getEventTypeFor(constructor as unknown as Function);
-            return {
-                Id: eventType.id.value,
-                Generation: eventType.generation.value,
-                Tombstone: eventType.tombstone
-            };
-        });
+    private joinEventTypeIds(eventTypes: Constructor[]): string {
+        return eventTypes.map(constructor => getEventTypeFor(constructor as unknown as Function).id.value).join(',');
     }
 
     private toClientAppendedEvent(wireEvent: ContractsAppendedEvent): AppendedEvent {

package/events/EventTypes.ts

@@ -4,6 +4,7 @@
 import { Constructor } from '@cratis/fundamentals';
 import { IClientArtifactsProvider } from '../artifacts';
 import { ChronicleConnection } from '../connection';
+import { ensureCommandSuccess } from '../connection/callResults';
 import { EventTypeId } from './EventTypeId';
 import { IEventTypes } from './IEventTypes';
 import { getEventTypeMetadata, getEventTypeJsonSchemaFor } from './eventTypeDecorator';
@@ -163,11 +164,11 @@ export class EventTypes implements IEventTypes {
             return;
         }
 
-        await this._connection.eventTypes.register({
+        ensureCommandSuccess('register event types', await this._connection.eventTypes.registerEventTypes({
             EventStore: this._eventStore,
             Types: registrations,
             DisableValidation: false
-        });
+        }));
     }
 
     /** @inheritdoc */

package/jobs/Jobs.ts

@@ -4,7 +4,7 @@
 import type { JobSummaryResponse, JobStepSummaryResponse } from '@cratis/chronicle.contracts';
 import { Guid } from '@cratis/fundamentals';
 import { ChronicleConnection } from '../connection';
-import { ensureCommandSuccess, ensureQuerySuccess, firstQueryResult } from '../connection/callResults';
+import { ensureCommandSuccess, ensureQuerySuccess } from '../connection/callResults';
 import { fromContractsGuid, toContractsGuid } from '../connection/Guid';
 import { IJobs } from './IJobs';
 import { JobId } from './JobId';
@@ -49,10 +49,10 @@ export class Jobs implements IJobs {
 
     /** @inheritdoc */
     async getJobs(): Promise<JobSummaryResponse[]> {
-        const response = await firstQueryResult('get jobs', this._connection.jobs.allJobs({
+        const response = await this._connection.jobs.allJobs({
             EventStore: this._eventStore,
             Namespace: this._namespace
-        }));
+        });
 
         return ensureQuerySuccess('get jobs', response);
     }

package/observation/toObserverRunningState.ts

@@ -17,7 +17,7 @@ export function toObserverRunningState(state: ContractObserverRunningState): Obs
             return ObserverRunningState.Suspended;
         case ContractObserverRunningState.Replaying:
             return ObserverRunningState.Replaying;
-        case ContractObserverRunningState.Disconnected:
+        case ContractObserverRunningState.OBSERVER_RUNNING_STATE_Disconnected:
             return ObserverRunningState.Disconnected;
         case ContractObserverRunningState.Quarantined:
             return ObserverRunningState.Quarantined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "4.0.0",
+    "version": "5.1.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",
@@ -159,20 +159,20 @@
         "test": "vitest run"
     },
     "dependencies": {
-        "@bufbuild/protobuf": "^2.14.1",
-        "@cratis/chronicle.contracts": "17.0.0",
+        "@bufbuild/protobuf": "^2.15.0",
+        "@cratis/chronicle.contracts": "18.2.0",
         "@grpc/grpc-js": "^1.14.4",
         "@opentelemetry/api": "^1.9.1",
         "nice-grpc": "^2.1.17",
         "nice-grpc-common": "^2.0.4",
         "reflect-metadata": "^0.2.2",
-        "undici": "^8.10.1"
+        "undici": "^8.10.2"
     },
     "devDependencies": {
-        "@cratis/fundamentals": "7.18.2",
-        "@types/node": "^26.4.0",
+        "@cratis/fundamentals": "7.19.2",
+        "@types/node": "^26.5.1",
         "typescript": "^6.0.3",
-        "vitest": "^4.1.11"
+        "vitest": "^5.0.0"
     },
     "peerDependencies": {
         "@cratis/fundamentals": "^7.14.0"

package/projections/declarative/FromEveryBuilder.ts

@@ -38,6 +38,36 @@ export class FromEveryBuilder<TReadModel> implements IFromEveryBuilder<TReadMode
         );
     }
 
+    /** @inheritdoc */
+    count(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName: string): IFromEveryBuilder<TReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        const property = handler.property;
+        this.entry.properties[`${property}.$eventContext.${contextPropertyName}`] = '$count';
+        return this;
+    }
+
+    /** @inheritdoc */
+    increment(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName: string): IFromEveryBuilder<TReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        const property = handler.property;
+        this.entry.properties[`${property}.$eventContext.${contextPropertyName}`] = '$increment';
+        return this;
+    }
+
+    /** @inheritdoc */
+    decrement(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName: string): IFromEveryBuilder<TReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        const property = handler.property;
+        this.entry.properties[`${property}.$eventContext.${contextPropertyName}`] = '$decrement';
+        return this;
+    }
+
     /** @inheritdoc */
     excludeChildProjections(): IFromEveryBuilder<TReadModel> {
         this.entry.includeChildren = false;

package/projections/declarative/IFromEveryBuilder.ts

@@ -16,6 +16,31 @@ export interface IFromEveryBuilder<TReadModel> {
      */
     set(readModelPropertyAccessor: PropertyAccessor<TReadModel>): IAllSetBuilder<TReadModel, IFromEveryBuilder<TReadModel>>;
 
+    /**
+     * Counts every projected event into a dictionary property, using a dynamic key resolved from an event context property.
+     * The dictionary value at the resolved key is incremented by one for each matching event.
+     * @param readModelPropertyAccessor - Accessor for the read model dictionary property (Record<string, number>).
+     * @param contextPropertyName - The event context property name used as the dictionary key (e.g., 'eventType').
+     * @returns This builder for fluent chaining.
+     */
+    count(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName: string): IFromEveryBuilder<TReadModel>;
+
+    /**
+     * Increments a dictionary property by one for every projected event, using a dynamic key resolved from an event context property.
+     * @param readModelPropertyAccessor - Accessor for the read model dictionary property (Record<string, number>).
+     * @param contextPropertyName - The event context property name used as the dictionary key (e.g., 'eventType').
+     * @returns This builder for fluent chaining.
+     */
+    increment(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName: string): IFromEveryBuilder<TReadModel>;
+
+    /**
+     * Decrements a dictionary property by one for every projected event, using a dynamic key resolved from an event context property.
+     * @param readModelPropertyAccessor - Accessor for the read model dictionary property (Record<string, number>).
+     * @param contextPropertyName - The event context property name used as the dictionary key (e.g., 'eventType').
+     * @returns This builder for fluent chaining.
+     */
+    decrement(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName: string): IFromEveryBuilder<TReadModel>;
+
     /**
      * Excludes child projections from the fromEvery definition.
      * @returns This builder for fluent chaining.

package/projections/declarative/ProjectionBuilderFor.spec.ts

@@ -27,6 +27,9 @@ class Inventory {
     total!: number;
     removedTotal!: number;
     thingsHappenedCount!: number;
+    countsByEventType!: Record<string, number>;
+    incrementsByEventType!: Record<string, number>;
+    decrementsByEventType!: Record<string, number>;
 }
 
 interface FromRecord {
@@ -39,6 +42,11 @@ interface JoinRecord {
     Value: { Properties: Record<string, string> };
 }
 
+interface AllDefinition {
+    Properties: Record<string, string>;
+    IncludeChildren: boolean;
+}
+
 describe('ProjectionBuilderFor', () => {
     describe('when using add on a from builder', () => {
         it('should produce a $add expression targeting the event property', () => {
@@ -112,4 +120,54 @@ describe('ProjectionBuilderFor', () => {
             expect(entry.Value.Properties.thingsHappenedCount).toBe('$count');
         });
     });
+
+    describe('when using count with event context property on fromEvery', () => {
+        it('should produce a $count expression with dictionary key from event context', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.fromEvery(fromEvery => fromEvery.count(model => model.countsByEventType, 'eventType'));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { All: AllDefinition };
+
+            expect(definition.All.Properties['countsByEventType.$eventContext.eventType']).toBe('$count');
+        });
+    });
+
+    describe('when using increment with event context property on fromEvery', () => {
+        it('should produce a $increment expression with dictionary key from event context', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.fromEvery(fromEvery => fromEvery.increment(model => model.incrementsByEventType, 'eventType'));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { All: AllDefinition };
+
+            expect(definition.All.Properties['incrementsByEventType.$eventContext.eventType']).toBe('$increment');
+        });
+    });
+
+    describe('when using decrement with event context property on fromEvery', () => {
+        it('should produce a $decrement expression with dictionary key from event context', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.fromEvery(fromEvery => fromEvery.decrement(model => model.decrementsByEventType, 'eventType'));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { All: AllDefinition };
+
+            expect(definition.All.Properties['decrementsByEventType.$eventContext.eventType']).toBe('$decrement');
+        });
+    });
+
+    describe('when using multiple fromEvery operations', () => {
+        it('should produce all operations in the All.Properties definition', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.fromEvery(fromEvery => {
+                fromEvery.count(model => model.countsByEventType, 'eventType');
+                fromEvery.increment(model => model.incrementsByEventType, 'correlationId');
+                fromEvery.set(model => model.id).toEventSourceId();
+            });
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { All: AllDefinition };
+
+            expect(definition.All.Properties['countsByEventType.$eventContext.eventType']).toBe('$count');
+            expect(definition.All.Properties['incrementsByEventType.$eventContext.correlationId']).toBe('$increment');
+            expect(definition.All.Properties.id).toBe('$eventSourceId');
+        });
+    });
 });

package/readModels/ReadModels.ts

@@ -13,6 +13,7 @@ import { Guid, JsonSerializer } from '@cratis/fundamentals';
 import { IClientArtifactsProvider } from '../artifacts';
 import { toContractsGuid } from '../connection/Guid';
 import { ChronicleConnection } from '../connection';
+import { ensureQuerySuccess } from '../connection/callResults';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
 import { getProjectionMetadata } from '../projections/declarative/projection';
 import { hasFromEventMetadata } from '../projections/modelBound/fromEvent';
@@ -115,16 +116,17 @@ export class ReadModels implements IReadModels {
     /** @inheritdoc */
     async getSnapshotsById<TReadModel>(readModelType: Constructor<TReadModel>, key: string): Promise<ReadModelSnapshot<TReadModel>[]> {
         const readModel = this.resolveReadModel(readModelType);
-        const response = await this._connection.readModels.getSnapshotsByKey({
+        const response = ensureQuerySuccess('get read model snapshots', await this._connection.readModelExplorer.allSnapshotsForReadModel({
             EventStore: this._eventStore,
             Namespace: this._namespace,
-            ReadModelIdentifier: readModel.identifier,
+            ReadModel: readModel.identifier,
             EventSequenceId: readModel.eventSequenceId,
-            ReadModelKey: key
-        });
+            ReadModelKey: key,
+            Grouping: ''
+        }));
 
-        const snapshots: ReadModelSnapshot<TReadModel>[] = response.Snapshots.map(snapshot => ({
-            readModel: this.deserializeReadModel(readModelType, snapshot.ReadModel),
+        const snapshots: ReadModelSnapshot<TReadModel>[] = response.map(snapshot => ({
+            readModel: this.deserializeReadModel(readModelType, snapshot.Instance),
             events: (snapshot.Events ?? []) as AppendedEvent[],
             occurred: snapshot.Occurred?.Value ? new Date(snapshot.Occurred.Value) : undefined,
             correlationId: snapshot.CorrelationId

package/seeding/EventSeeding.ts

@@ -4,6 +4,7 @@
 import { diag } from '@opentelemetry/api';
 import { IClientArtifactsProvider } from '../artifacts';
 import { ChronicleConnection } from '../connection';
+import { ensureCommandSuccess } from '../connection/callResults';
 import { EventStoreNamespaceName } from '../EventStoreNamespaceName';
 import { getEventTypeFor } from '../events/eventTypeDecorator';
 import { getTagsFor } from '../events/tagDecorator';
@@ -94,7 +95,7 @@ export class EventSeeding implements IEventSeeding {
             }))
         };
 
-        await this._connection.eventSeeding.seed(request);
+        ensureCommandSuccess('seed events', await this._connection.eventSeeding.seedEvents(request));
         this._entries.length = 0;
     }
 

package/webhooks/Webhooks.ts

@@ -1,10 +1,11 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { ObserverOwner, type WebhookDefinition } from '@cratis/chronicle.contracts';
+import { type WebhookDefinition } from '@cratis/chronicle.contracts';
 import { Constructor } from '@cratis/fundamentals';
 import { IClientArtifactsProvider } from '../artifacts';
 import { ChronicleConnection } from '../connection';
+import { ensureCommandSuccess, ensureQuerySuccess } from '../connection/callResults';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
 import { IEventTypes } from '../events/IEventTypes';
 import { IWebhook } from './IWebhook';
@@ -59,11 +60,10 @@ export class Webhooks implements IWebhooks {
             return;
         }
 
-        await this._connection.webhooks.add({
+        ensureCommandSuccess('register discovered webhooks', await this._connection.webhooks.addWebhooks({
             EventStore: this._eventStore,
-            Owner: ObserverOwner.Client,
             Webhooks: [...this._discovered.values()]
-        });
+        }));
     }
 
     /** @inheritdoc */
@@ -79,26 +79,40 @@ export class Webhooks implements IWebhooks {
             configure
         );
 
-        await this._connection.webhooks.add({
+        ensureCommandSuccess('register webhook', await this._connection.webhooks.addWebhooks({
             EventStore: this._eventStore,
-            Owner: ObserverOwner.Client,
             Webhooks: [definition]
-        });
+        }));
     }
 
     /** @inheritdoc */
     async getWebhooks(): Promise<WebhookDefinition[]> {
         const response = await this._connection.webhooks.getWebhooks({ EventStore: this._eventStore });
-        return response.items ?? [];
+        const details = ensureQuerySuccess('get webhooks', response) ?? [];
+
+        // The kernel does not return authorization details on read-back, so the reconstructed target
+        // always carries no authorization, mirroring the C# client's WebhookTarget mapping.
+        return details.map(webhook => ({
+            EventSequenceId: webhook.EventSequenceId,
+            Identifier: webhook.Identifier,
+            EventTypes: webhook.EventTypes,
+            Target: {
+                Url: webhook.Url,
+                Authorization: undefined,
+                Headers: webhook.Headers
+            },
+            IsReplayable: webhook.IsReplayable,
+            IsActive: webhook.IsActive
+        }));
     }
 
     /** @inheritdoc */
     async remove(webhookId: WebhookId | string): Promise<void> {
         const id = typeof webhookId === 'string' ? webhookId : webhookId.value;
-        await this._connection.webhooks.remove({
+        ensureCommandSuccess('remove webhook', await this._connection.webhooks.removeWebhooks({
             EventStore: this._eventStore,
             Webhooks: [id]
-        });
+        }));
     }
 
     private buildDefinition(