@ddd-ts/event-sourcing-inmemory 0.0.0-compute-timeout-on-process.7 → 0.0.0-compute-timeout-on-process.9

package/dist/in-memory.event-lake.aggregate-store.d.ts

@@ -1,41 +1,37 @@
-import { HasTrait } from "./traits/src/index.js";
-import { EventLakeStore, EventOf, EventSourced, IEventBus, IEventSourced, IIdentifiable, ISerializer, Identifiable, LakeId } from "@ddd-ts/core";
+import { LakeId, type IEventBus, EventLakeStore, type EventOf, type ISerializer, type IEventSourced, type IIdentifiable, EventSourced, Identifiable } from "@ddd-ts/core";
 import { InMemoryDatabase, InMemoryStore, InMemoryTransaction, InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
-
-//#region src/in-memory.event-lake.aggregate-store.d.ts
-declare const MakeInMemoryEventLakeAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => abstract new (database: InMemoryDatabase, collection: string, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus) => {
-  readonly database: InMemoryDatabase;
-  readonly collection: string;
-  getLakeId(instance: InstanceType<A>): LakeId;
-  transaction: InMemoryTransactionPerformer;
-  lakeStore: EventLakeStore<EventOf<InstanceType<A>>>;
-  readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}> & ISerializer<InstanceType<A>, {}>;
-  readonly eventBus?: IEventBus | undefined;
-  readonly $name?: string | undefined;
-  save(aggregate: InstanceType<A>, trx?: InMemoryTransaction): Promise<void>;
-  filter(predicate: (model: InstanceType<A>) => boolean, trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
-  clear(): void;
-  create(model: InstanceType<A>, trx?: InMemoryTransaction): Promise<void>;
-  saveAll(models: InstanceType<A>[], trx?: InMemoryTransaction): Promise<void>;
-  load(id: InstanceType<A>["id"], trx?: InMemoryTransaction): Promise<InstanceType<A> | undefined>;
-  loadAll(trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
-  loadMany(ids: InstanceType<A>["id"][], trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
-  delete(id: InstanceType<A>["id"], trx?: InMemoryTransaction): Promise<void>;
-  countAll(): Promise<number>;
-  streamAll(): AsyncIterable<InstanceType<A>>;
+import type { HasTrait } from "@ddd-ts/traits";
+export declare const MakeInMemoryEventLakeAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => abstract new (database: InMemoryDatabase, collection: string, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus) => {
+    readonly database: InMemoryDatabase;
+    readonly collection: string;
+    getLakeId(instance: InstanceType<A>): LakeId;
+    transaction: InMemoryTransactionPerformer;
+    lakeStore: EventLakeStore<EventOf<InstanceType<A>>>;
+    readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}> & ISerializer<InstanceType<A>, {}>;
+    readonly eventBus?: IEventBus | undefined;
+    readonly $name?: string | undefined;
+    save(aggregate: InstanceType<A>, trx?: InMemoryTransaction): Promise<void>;
+    filter(predicate: (model: InstanceType<A>) => boolean, trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
+    clear(): void;
+    create(model: InstanceType<A>, trx?: InMemoryTransaction): Promise<void>;
+    saveAll(models: InstanceType<A>[], trx?: InMemoryTransaction): Promise<void>;
+    load(id: InstanceType<A>["id"], trx?: InMemoryTransaction): Promise<InstanceType<A> | undefined>;
+    loadAll(trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
+    loadMany(ids: InstanceType<A>["id"][], trx?: InMemoryTransaction): Promise<InstanceType<A>[]>;
+    delete(id: InstanceType<A>["id"], trx?: InMemoryTransaction): Promise<void>;
+    countAll(): Promise<number>;
+    streamAll(): AsyncIterable<InstanceType<A>>;
 };
-declare abstract class InMemoryEventLakeAggregateStore<A extends IEventSourced & IIdentifiable> extends InMemoryStore<A> {
-  readonly database: InMemoryDatabase;
-  readonly collection: string;
-  readonly serializer: ISerializer<EventOf<A>> & ISerializer<A>;
-  readonly eventBus?: IEventBus | undefined;
-  readonly $name?: string | undefined;
-  transaction: InMemoryTransactionPerformer;
-  lakeStore: EventLakeStore<EventOf<A>>;
-  constructor(database: InMemoryDatabase, collection: string, serializer: ISerializer<EventOf<A>> & ISerializer<A>, eventBus?: IEventBus | undefined, $name?: string | undefined);
-  abstract getLakeId(instance: A): LakeId;
-  save(aggregate: A, trx?: InMemoryTransaction): Promise<void>;
+export declare abstract class InMemoryEventLakeAggregateStore<A extends IEventSourced & IIdentifiable> extends InMemoryStore<A> {
+    readonly database: InMemoryDatabase;
+    readonly collection: string;
+    readonly serializer: ISerializer<EventOf<A>> & ISerializer<A>;
+    readonly eventBus?: IEventBus | undefined;
+    readonly $name?: string | undefined;
+    transaction: InMemoryTransactionPerformer;
+    lakeStore: EventLakeStore<EventOf<A>>;
+    constructor(database: InMemoryDatabase, collection: string, serializer: ISerializer<EventOf<A>> & ISerializer<A>, eventBus?: IEventBus | undefined, $name?: string | undefined);
+    abstract getLakeId(instance: A): LakeId;
+    save(aggregate: A, trx?: InMemoryTransaction): Promise<void>;
 }
-//#endregion
-export { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore };
 //# sourceMappingURL=in-memory.event-lake.aggregate-store.d.ts.map

package/dist/in-memory.event-lake.aggregate-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.event-lake.aggregate-store.d.ts","names":[],"sources":["../src/in-memory.event-lake.aggregate-store.ts"],"mappings":";;;;;cAqBa,mCAAA,aACD,QAAA,QAAgB,YAAA,IAAgB,QAAA,QAAgB,YAAA,GAAa,SAAA,EAE5D,CAAA,mBAAC,QAAA,EAMkB,gBAAA,EAAgB,UAAA,UACR,UAAA,EACtB,WAAA,CAAY,YAAA,CAAa,CAAA,KACnC,WAAA,CAAY,OAAA,CAAQ,YAAA,CAAa,CAAA,KAAI,QAAA,GAC5B,SAAA;EAAA,mBAJe,gBAAA;EAAA;sBASC,YAAA,CAAa,CAAA,IAAK,MAAA;eASpC,4BAAA;;;sBAMgB,SAAA;EAAA;yCAeW,mBAAA,GAAmB,OAAA;;;;;;;;;;;;uBAxBvC,+BAAA,WACV,aAAA,GAAgB,aAAA,UAClB,aAAA,CAAc,CAAA;EAAA,SAIJ,QAAA,EAAU,gBAAA;EAAA,SACV,UAAA;EAAA,SACA,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA,KAAM,WAAA,CAAY,CAAA;EAAA,SAClD,QAAA,GAAW,SAAA;EAAA,SACX,KAAA;EAPlB,WAAA,EAAa,4BAAA;EACb,SAAA,EAAW,cAAA,CAAe,OAAA,CAAQ,CAAA;cAEhB,QAAA,EAAU,gBAAA,EACV,UAAA,UACA,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA,KAAM,WAAA,CAAY,CAAA,GAClD,QAAA,GAAW,SAAA,cACX,KAAA;EAAA,SAYT,SAAA,CAAU,QAAA,EAAU,CAAA,GAAI,MAAA;EAElB,IAAA,CAAK,SAAA,EAAW,CAAA,EAAG,GAAA,GAAM,mBAAA,GAAmB,OAAA;AAAA"}
+{"version":3,"file":"in-memory.event-lake.aggregate-store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.aggregate-store.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,SAAS,EACd,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,aAAa,EAElB,YAAY,EACZ,YAAY,EACb,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,4BAA4B,EAC7B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,eAAO,MAAM,mCAAmC,GAC9C,CAAC,SAAS,QAAQ,CAAC,OAAO,YAAY,CAAC,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,aAE5D,CAAC,6BAMkB,gBAAgB,cACd,MAAM,cACtB,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACtC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,aAC5B,SAAS;uBAJM,gBAAgB;yBACd,MAAM;wBAQP,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM;iBAS1C,4BAA4B;;;wBAMZ,SAAS;qBACZ,MAAM;2CAcQ,mBAAmB;;;;;;;;;;;CA1B5D,CAAC;AAEF,8BAAsB,+BAA+B,CACnD,CAAC,SAAS,aAAa,GAAG,aAAa,CACvC,SAAQ,aAAa,CAAC,CAAC,CAAC;aAIN,QAAQ,EAAE,gBAAgB;aAC1B,UAAU,EAAE,MAAM;aAClB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;aACpD,QAAQ,CAAC,EAAE,SAAS;aACpB,KAAK,CAAC,EAAE,MAAM;IAPhC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEpB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EACpD,QAAQ,CAAC,EAAE,SAAS,YAAA,EACpB,KAAK,CAAC,EAAE,MAAM,YAAA;IAYhC,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,GAAG,MAAM;IAExB,IAAI,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,mBAAmB;CAW5D"}

package/dist/in-memory.event-lake.aggregate-store.js

@@ -1,6 +1,6 @@
-import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.js";
-import { EventLakeStore, EventOf, EventSourced, IEventSourced, IIdentifiable, ISerializer, Identifiable, LakeId } from "@ddd-ts/core";
-import { InMemoryDatabase, InMemoryStore, InMemoryTransaction, InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+const require_in_memory_event_lake_storage_layer = require('./in-memory.event-lake.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
 
 //#region src/in-memory.event-lake.aggregate-store.ts
 const MakeInMemoryEventLakeAggregateStore = (AGGREGATE) => {
@@ -13,19 +13,19 @@ const MakeInMemoryEventLakeAggregateStore = (AGGREGATE) => {
 	}
 	return $InMemoryEventLakeAggregateStore;
 };
-var InMemoryEventLakeAggregateStore = class extends InMemoryStore {
+var InMemoryEventLakeAggregateStore = class extends _ddd_ts_store_inmemory.InMemoryStore {
 	transaction;
 	lakeStore;
 	constructor(database, collection, serializer, eventBus, $name) {
-		const storageLayer = new InMemoryEventLakeStorageLayer(database);
+		const storageLayer = new require_in_memory_event_lake_storage_layer.InMemoryEventLakeStorageLayer(database);
 		super(collection, database, serializer, $name);
 		this.database = database;
 		this.collection = collection;
 		this.serializer = serializer;
 		this.eventBus = eventBus;
 		this.$name = $name;
-		this.lakeStore = new EventLakeStore(storageLayer, serializer, eventBus);
-		this.transaction = new InMemoryTransactionPerformer(database);
+		this.lakeStore = new _ddd_ts_core.EventLakeStore(storageLayer, serializer, eventBus);
+		this.transaction = new _ddd_ts_store_inmemory.InMemoryTransactionPerformer(database);
 	}
 	async save(aggregate, trx) {
 		const changes = aggregate.changes;
@@ -39,5 +39,5 @@ var InMemoryEventLakeAggregateStore = class extends InMemoryStore {
 };
 
 //#endregion
-export { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore };
-//# sourceMappingURL=in-memory.event-lake.aggregate-store.js.map
+exports.InMemoryEventLakeAggregateStore = InMemoryEventLakeAggregateStore;
+exports.MakeInMemoryEventLakeAggregateStore = MakeInMemoryEventLakeAggregateStore;

package/dist/in-memory.event-lake.aggregate-store.mjs

@@ -0,0 +1,42 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.mjs";
+import { EventLakeStore, LakeId } from "@ddd-ts/core";
+import { InMemoryStore, InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-lake.aggregate-store.ts
+const MakeInMemoryEventLakeAggregateStore = (AGGREGATE) => {
+	class $InMemoryEventLakeAggregateStore extends InMemoryEventLakeAggregateStore {
+		constructor(database, collection, serializer, eventBus) {
+			super(database, collection, serializer, eventBus, AGGREGATE.name);
+			this.database = database;
+			this.collection = collection;
+		}
+	}
+	return $InMemoryEventLakeAggregateStore;
+};
+var InMemoryEventLakeAggregateStore = class extends InMemoryStore {
+	transaction;
+	lakeStore;
+	constructor(database, collection, serializer, eventBus, $name) {
+		const storageLayer = new InMemoryEventLakeStorageLayer(database);
+		super(collection, database, serializer, $name);
+		this.database = database;
+		this.collection = collection;
+		this.serializer = serializer;
+		this.eventBus = eventBus;
+		this.$name = $name;
+		this.lakeStore = new EventLakeStore(storageLayer, serializer, eventBus);
+		this.transaction = new InMemoryTransactionPerformer(database);
+	}
+	async save(aggregate, trx) {
+		const changes = aggregate.changes;
+		await this.transaction.performWith(trx, async (trx) => {
+			const lakeId = this.getLakeId(aggregate);
+			await super.save(aggregate, trx);
+			await this.lakeStore.append(lakeId, changes, trx);
+			aggregate.clearChanges();
+		});
+	}
+};
+
+//#endregion
+export { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore };

package/dist/in-memory.event-lake.aggregate-store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-lake.aggregate-store.spec.d.ts.map

package/dist/in-memory.event-lake.aggregate-store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.aggregate-store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.aggregate-store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.event-lake.storage-layer.d.ts

@@ -1,14 +1,10 @@
-import { EventId, EventLakeStorageLayer, ISerializedChange, ISerializedFact, LakeId } from "@ddd-ts/core";
-import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
+import { LakeId, type ISerializedChange, type ISerializedFact, type EventLakeStorageLayer, EventId } from "@ddd-ts/core";
+import type { ISerializedSavedChange } from "@ddd-ts/core/dist/interfaces/es-event";
 import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
-
-//#region src/in-memory.event-lake.storage-layer.d.ts
-declare class InMemoryEventLakeStorageLayer implements EventLakeStorageLayer {
-  readonly database: InMemoryDatabase;
-  constructor(database: InMemoryDatabase);
-  append(lakeId: LakeId, changes: ISerializedChange[], trx: InMemoryTransaction): Promise<ISerializedSavedChange$1[]>;
-  read(lakeId: LakeId, startAfter?: EventId, endAt?: EventId): AsyncIterable<ISerializedFact>;
+export declare class InMemoryEventLakeStorageLayer implements EventLakeStorageLayer {
+    readonly database: InMemoryDatabase;
+    constructor(database: InMemoryDatabase);
+    append(lakeId: LakeId, changes: ISerializedChange[], trx: InMemoryTransaction): Promise<ISerializedSavedChange[]>;
+    read(lakeId: LakeId, startAfter?: EventId, endAt?: EventId): AsyncIterable<ISerializedFact>;
 }
-//#endregion
-export { InMemoryEventLakeStorageLayer };
 //# sourceMappingURL=in-memory.event-lake.storage-layer.d.ts.map

package/dist/in-memory.event-lake.storage-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.event-lake.storage-layer.d.ts","names":[],"sources":["../src/in-memory.event-lake.storage-layer.ts"],"mappings":";;;;;cAUa,6BAAA,YAAyC,qBAAA;EAAA,SACxB,QAAA,EAAU,gBAAA;cAAV,QAAA,EAAU,gBAAA;EAEhC,MAAA,CACJ,MAAA,EAAQ,MAAA,EACR,OAAA,EAAS,iBAAA,IACT,GAAA,EAAK,mBAAA,GAAmB,OAAA,CAAA,wBAAA;EA+BnB,IAAA,CACL,MAAA,EAAQ,MAAA,EACR,UAAA,GAAa,OAAA,EACb,KAAA,GAAQ,OAAA,GACP,aAAA,CAAc,eAAA;AAAA"}
+{"version":3,"file":"in-memory.event-lake.storage-layer.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.storage-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,OAAO,EACR,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE/E,qBAAa,6BAA8B,YAAW,qBAAqB;aAC7C,QAAQ,EAAE,gBAAgB;gBAA1B,QAAQ,EAAE,gBAAgB;IAEhD,MAAM,CACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAAE,EAC5B,GAAG,EAAE,mBAAmB;IA+BnB,IAAI,CACT,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,OAAO,EACpB,KAAK,CAAC,EAAE,OAAO,GACd,aAAa,CAAC,eAAe,CAAC;CA6BlC"}

package/dist/in-memory.event-lake.storage-layer.js

@@ -1,6 +1,5 @@
-import { EventId, EventLakeStorageLayer, LakeId } from "@ddd-ts/core";
-import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
-import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
 
 //#region src/in-memory.event-lake.storage-layer.ts
 var InMemoryEventLakeStorageLayer = class {
@@ -52,5 +51,4 @@ var InMemoryEventLakeStorageLayer = class {
 };
 
 //#endregion
-export { InMemoryEventLakeStorageLayer };
-//# sourceMappingURL=in-memory.event-lake.storage-layer.js.map
+exports.InMemoryEventLakeStorageLayer = InMemoryEventLakeStorageLayer;

package/dist/in-memory.event-lake.storage-layer.mjs

@@ -0,0 +1,54 @@
+import { EventId, LakeId } from "@ddd-ts/core";
+import "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-lake.storage-layer.ts
+var InMemoryEventLakeStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	async append(lakeId, changes, trx) {
+		const result = [];
+		let revision = 0;
+		for (const change of changes) {
+			const ref = `${lakeId.serialize()}/${change.id}`;
+			const stored = {
+				...change,
+				ref,
+				revision
+			};
+			this.database.save(lakeId.serialize(), change.id, stored, trx.transaction);
+			result.push({
+				...change,
+				ref,
+				revision,
+				occurredAt: void 0
+			});
+			revision++;
+		}
+		return result;
+	}
+	async *read(lakeId, startAfter, endAt) {
+		const facts = this.database.loadAll(lakeId.serialize()).sort((a, b) => a.data.savedAt === b.data.savedAt ? a.data.data.revision - b.data.data.revision : a.data.savedAt < b.data.savedAt ? -1 : 1).map((e) => e.data);
+		let started = !startAfter;
+		for (const fact of facts) {
+			if (startAfter && fact.data.id === startAfter.serialize()) {
+				started = true;
+				continue;
+			}
+			if (endAt && fact.data.id === endAt.serialize()) {
+				yield {
+					...fact.data,
+					occurredAt: fact.data.savedAt
+				};
+				break;
+			}
+			if (started) yield {
+				...fact.data,
+				occurredAt: fact.data.savedAt
+			};
+		}
+	}
+};
+
+//#endregion
+export { InMemoryEventLakeStorageLayer };

package/dist/in-memory.event-lake.store.d.ts

@@ -1,10 +1,6 @@
-import { EventLakeStore, IEsEvent, ISerializer } from "@ddd-ts/core";
-import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
-
-//#region src/in-memory.event-lake.store.d.ts
-declare class InMemoryEventLakeStore<Event extends IEsEvent> extends EventLakeStore<Event> {
-  constructor(database: InMemoryDatabase, serializer: ISerializer<Event>);
+import { type IEsEvent, EventLakeStore, type ISerializer } from "@ddd-ts/core";
+import type { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+export declare class InMemoryEventLakeStore<Event extends IEsEvent> extends EventLakeStore<Event> {
+    constructor(database: InMemoryDatabase, serializer: ISerializer<Event>);
 }
-//#endregion
-export { InMemoryEventLakeStore };
 //# sourceMappingURL=in-memory.event-lake.store.d.ts.map

package/dist/in-memory.event-lake.store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.event-lake.store.d.ts","names":[],"sources":["../src/in-memory.event-lake.store.ts"],"mappings":";;;;cAIa,sBAAA,eACG,QAAA,UACN,cAAA,CAAe,KAAA;cACX,QAAA,EAAU,gBAAA,EAAkB,UAAA,EAAY,WAAA,CAAY,KAAA;AAAA"}
+{"version":3,"file":"in-memory.event-lake.store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,qBAAa,sBAAsB,CACjC,KAAK,SAAS,QAAQ,CACtB,SAAQ,cAAc,CAAC,KAAK,CAAC;gBACjB,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,CAAC,KAAK,CAAC;CAGvE"}

package/dist/in-memory.event-lake.store.js

@@ -1,13 +1,12 @@
-import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.js";
-import { EventLakeStore, IEsEvent, ISerializer } from "@ddd-ts/core";
+const require_in_memory_event_lake_storage_layer = require('./in-memory.event-lake.storage-layer.js');
+let _ddd_ts_core = require("@ddd-ts/core");
 
 //#region src/in-memory.event-lake.store.ts
-var InMemoryEventLakeStore = class extends EventLakeStore {
+var InMemoryEventLakeStore = class extends _ddd_ts_core.EventLakeStore {
 	constructor(database, serializer) {
-		super(new InMemoryEventLakeStorageLayer(database), serializer);
+		super(new require_in_memory_event_lake_storage_layer.InMemoryEventLakeStorageLayer(database), serializer);
 	}
 };
 
 //#endregion
-export { InMemoryEventLakeStore };
-//# sourceMappingURL=in-memory.event-lake.store.js.map
+exports.InMemoryEventLakeStore = InMemoryEventLakeStore;

package/dist/in-memory.event-lake.store.mjs

@@ -0,0 +1,12 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.mjs";
+import { EventLakeStore } from "@ddd-ts/core";
+
+//#region src/in-memory.event-lake.store.ts
+var InMemoryEventLakeStore = class extends EventLakeStore {
+	constructor(database, serializer) {
+		super(new InMemoryEventLakeStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+export { InMemoryEventLakeStore };

package/dist/in-memory.event-lake.store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-lake.store.spec.d.ts.map

package/dist/in-memory.event-lake.store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-lake.store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.event-stream.aggregate-store.d.ts

@@ -1,35 +1,30 @@
-import { HasTrait } from "./traits/src/index.js";
-import { InMemorySnapshotter } from "./in-memory.snapshotter.js";
-import * as _ddd_ts_core0 from "@ddd-ts/core";
-import { EventOf, EventSourced, EventStreamAggregateStore, EventStreamStore, EventsOf, IEventBus, IEventSourced, IIdentifiable, ISerializer, Identifiable, StreamId } from "@ddd-ts/core";
+import type { HasTrait } from "@ddd-ts/traits";
+import { StreamId, type EventsOf, EventSourced, type Identifiable, type IEventBus, EventStreamStore, EventStreamAggregateStore, type EventOf, type ISerializer, type IEventSourced, type IIdentifiable } from "@ddd-ts/core";
 import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
-
-//#region src/in-memory.event-stream.aggregate-store.d.ts
-declare const MakeInMemoryEventStreamAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => {
-  new (database: InMemoryDatabase, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus): {
-    loadFirst(event: EventsOf<A>[number]): InstanceType<A>;
-    getStreamId(id: InstanceType<A>["id"]): StreamId;
+import { InMemorySnapshotter } from "./in-memory.snapshotter";
+export declare const MakeInMemoryEventStreamAggregateStore: <A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>>(AGGREGATE: A) => {
+    new (database: InMemoryDatabase, serializer: ISerializer<InstanceType<A>> & ISerializer<EventOf<InstanceType<A>>>, eventBus?: IEventBus): {
+        loadFirst(event: EventsOf<A>[number]): InstanceType<A>;
+        getStreamId(id: InstanceType<A>["id"]): StreamId;
+        readonly database: InMemoryDatabase;
+        readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}>;
+        readonly snapshotter: InMemorySnapshotter<InstanceType<A>>;
+        readonly eventBus?: IEventBus | undefined;
+        readonly streamStore: EventStreamStore<EventOf<InstanceType<A>>>;
+        readonly transaction: import("@ddd-ts/core").TransactionPerformer;
+        loadFromSnapshot(snapshot: InstanceType<A>): Promise<InstanceType<A>>;
+        loadFromScratch(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
+        loadForce(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
+        load(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
+        saveAll(aggregates: InstanceType<A>[], parentTrx?: import("@ddd-ts/core").Transaction, attempts?: number): Promise<void>;
+        save(aggregate: InstanceType<A>, trx?: import("@ddd-ts/core").Transaction, attempts?: number): Promise<void>;
+    };
+};
+export declare abstract class InMemoryEventStreamAggregateStore<A extends IEventSourced & IIdentifiable> extends EventStreamAggregateStore<A> {
     readonly database: InMemoryDatabase;
-    readonly serializer: ISerializer<EventOf<InstanceType<A>>, {}>;
-    readonly snapshotter: InMemorySnapshotter<InstanceType<A>>;
+    readonly serializer: ISerializer<EventOf<A>>;
+    readonly snapshotter: InMemorySnapshotter<A>;
     readonly eventBus?: IEventBus | undefined;
-    readonly streamStore: EventStreamStore<EventOf<InstanceType<A>>>;
-    readonly transaction: _ddd_ts_core0.TransactionPerformer;
-    loadFromSnapshot(snapshot: InstanceType<A>): Promise<InstanceType<A>>;
-    loadFromScratch(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
-    loadForce(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
-    load(id: InstanceType<A>["id"]): Promise<InstanceType<A> | undefined>;
-    saveAll(aggregates: InstanceType<A>[], parentTrx?: _ddd_ts_core0.Transaction, attempts?: number): Promise<void>;
-    save(aggregate: InstanceType<A>, trx?: _ddd_ts_core0.Transaction, attempts?: number): Promise<void>;
-  };
-};
-declare abstract class InMemoryEventStreamAggregateStore<A extends IEventSourced & IIdentifiable> extends EventStreamAggregateStore<A> {
-  readonly database: InMemoryDatabase;
-  readonly serializer: ISerializer<EventOf<A>>;
-  readonly snapshotter: InMemorySnapshotter<A>;
-  readonly eventBus?: IEventBus | undefined;
-  constructor(database: InMemoryDatabase, serializer: ISerializer<EventOf<A>>, snapshotter: InMemorySnapshotter<A>, eventBus?: IEventBus | undefined);
+    constructor(database: InMemoryDatabase, serializer: ISerializer<EventOf<A>>, snapshotter: InMemorySnapshotter<A>, eventBus?: IEventBus | undefined);
 }
-//#endregion
-export { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore };
 //# sourceMappingURL=in-memory.event-stream.aggregate-store.d.ts.map

package/dist/in-memory.event-stream.aggregate-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.event-stream.aggregate-store.d.ts","names":[],"sources":["../src/in-memory.event-stream.aggregate-store.ts"],"mappings":";;;;;;;cAsBa,qCAAA,aACD,QAAA,QAAgB,YAAA,IAAgB,QAAA,QAAgB,YAAA,GAAa,SAAA,EAE5D,CAAA;EAAA,eAMG,gBAAA,EAAgB,UAAA,EACd,WAAA,CAAY,YAAA,CAAa,CAAA,KACnC,WAAA,CAAY,OAAA,CAAQ,YAAA,CAAa,CAAA,KAAI,QAAA,GAC5B,SAAA;qBAUI,QAAA,CAAS,CAAA,YAAa,YAAA,CAAa,CAAA;oBAIpC,YAAA,CAAa,CAAA,UAAW,QAAA;IAAA,mBAUd,gBAAA;IAAA;;wBAGC,SAAA;IAAA;;;;;;;;;;uBAPT,iCAAA,WACV,aAAA,GAAgB,aAAA,UAClB,yBAAA,CAA0B,CAAA;EAAA,SAEhB,QAAA,EAAU,gBAAA;EAAA,SACV,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA;EAAA,SAChC,WAAA,EAAa,mBAAA,CAAoB,CAAA;EAAA,SACjC,QAAA,GAAW,SAAA;cAHX,QAAA,EAAU,gBAAA,EACV,UAAA,EAAY,WAAA,CAAY,OAAA,CAAQ,CAAA,IAChC,WAAA,EAAa,mBAAA,CAAoB,CAAA,GACjC,QAAA,GAAW,SAAA;AAAA"}
+{"version":3,"file":"in-memory.event-stream.aggregate-store.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.aggregate-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,gBAAgB,EAChB,yBAAyB,EAEzB,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAG9D,eAAO,MAAM,qCAAqC,GAChD,CAAC,SAAS,QAAQ,CAAC,OAAO,YAAY,CAAC,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,aAE5D,CAAC;mBAME,gBAAgB,cACd,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACtC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,aAC5B,SAAS;yBAUL,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;wBAItC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,QAAQ;2BAUtB,gBAAgB;;;4BAGf,SAAS;;;;;;;;;;CATvC,CAAC;AAEF,8BAAsB,iCAAiC,CACrD,CAAC,SAAS,aAAa,GAAG,aAAa,CACvC,SAAQ,yBAAyB,CAAC,CAAC,CAAC;aAElB,QAAQ,EAAE,gBAAgB;aAC1B,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;aACnC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC;aACnC,QAAQ,CAAC,EAAE,SAAS;gBAHpB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EACnC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC,EACnC,QAAQ,CAAC,EAAE,SAAS,YAAA;CAWvC"}

package/dist/in-memory.event-stream.aggregate-store.js

@@ -1,28 +1,28 @@
-import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.js";
-import { InMemorySnapshotter } from "./in-memory.snapshotter.js";
-import { EventOf, EventSourced, EventStreamAggregateStore, EventStreamStore, EventsOf, IEventSourced, IIdentifiable, ISerializer, StreamId } from "@ddd-ts/core";
-import { InMemoryDatabase, InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+const require_in_memory_event_stream_storage_layer = require('./in-memory.event-stream.storage-layer.js');
+const require_in_memory_snapshotter = require('./in-memory.snapshotter.js');
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
 
 //#region src/in-memory.event-stream.aggregate-store.ts
 const MakeInMemoryEventStreamAggregateStore = (AGGREGATE) => {
 	return class $InMemoryEventStreamAggregateStore extends InMemoryEventStreamAggregateStore {
 		constructor(database, serializer, eventBus) {
-			const snapshotter = new InMemorySnapshotter(AGGREGATE.name, database, serializer);
+			const snapshotter = new require_in_memory_snapshotter.InMemorySnapshotter(AGGREGATE.name, database, serializer);
 			super(database, serializer, snapshotter, eventBus);
 		}
 		loadFirst(event) {
 			return AGGREGATE.loadFirst(event);
 		}
 		getStreamId(id) {
-			return StreamId.from(AGGREGATE.name, id.serialize());
+			return _ddd_ts_core.StreamId.from(AGGREGATE.name, id.serialize());
 		}
 	};
 };
-var InMemoryEventStreamAggregateStore = class extends EventStreamAggregateStore {
+var InMemoryEventStreamAggregateStore = class extends _ddd_ts_core.EventStreamAggregateStore {
 	constructor(database, serializer, snapshotter, eventBus) {
-		const storageLayer = new InMemoryEventStreamStorageLayer(database);
-		const transaction = new InMemoryTransactionPerformer(database);
-		const streamStore = new EventStreamStore(storageLayer, serializer, eventBus);
+		const storageLayer = new require_in_memory_event_stream_storage_layer.InMemoryEventStreamStorageLayer(database);
+		const transaction = new _ddd_ts_store_inmemory.InMemoryTransactionPerformer(database);
+		const streamStore = new _ddd_ts_core.EventStreamStore(storageLayer, serializer, eventBus);
 		super(streamStore, transaction, snapshotter);
 		this.database = database;
 		this.serializer = serializer;
@@ -32,5 +32,5 @@ var InMemoryEventStreamAggregateStore = class extends EventStreamAggregateStore
 };
 
 //#endregion
-export { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore };
-//# sourceMappingURL=in-memory.event-stream.aggregate-store.js.map
+exports.InMemoryEventStreamAggregateStore = InMemoryEventStreamAggregateStore;
+exports.MakeInMemoryEventStreamAggregateStore = MakeInMemoryEventStreamAggregateStore;

package/dist/in-memory.event-stream.aggregate-store.mjs

@@ -0,0 +1,35 @@
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.mjs";
+import { InMemorySnapshotter } from "./in-memory.snapshotter.mjs";
+import { EventStreamAggregateStore, EventStreamStore, StreamId } from "@ddd-ts/core";
+import { InMemoryTransactionPerformer } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.event-stream.aggregate-store.ts
+const MakeInMemoryEventStreamAggregateStore = (AGGREGATE) => {
+	return class $InMemoryEventStreamAggregateStore extends InMemoryEventStreamAggregateStore {
+		constructor(database, serializer, eventBus) {
+			const snapshotter = new InMemorySnapshotter(AGGREGATE.name, database, serializer);
+			super(database, serializer, snapshotter, eventBus);
+		}
+		loadFirst(event) {
+			return AGGREGATE.loadFirst(event);
+		}
+		getStreamId(id) {
+			return StreamId.from(AGGREGATE.name, id.serialize());
+		}
+	};
+};
+var InMemoryEventStreamAggregateStore = class extends EventStreamAggregateStore {
+	constructor(database, serializer, snapshotter, eventBus) {
+		const storageLayer = new InMemoryEventStreamStorageLayer(database);
+		const transaction = new InMemoryTransactionPerformer(database);
+		const streamStore = new EventStreamStore(storageLayer, serializer, eventBus);
+		super(streamStore, transaction, snapshotter);
+		this.database = database;
+		this.serializer = serializer;
+		this.snapshotter = snapshotter;
+		this.eventBus = eventBus;
+	}
+};
+
+//#endregion
+export { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore };

package/dist/in-memory.event-stream.aggregate-store.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=in-memory.event-stream.aggregate-store.spec.d.ts.map

package/dist/in-memory.event-stream.aggregate-store.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.aggregate-store.spec.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.aggregate-store.spec.ts"],"names":[],"mappings":""}

package/dist/in-memory.event-stream.storage-layer.d.ts

@@ -1,15 +1,11 @@
-import { EventStreamStorageLayer, ISerializedChange, ISerializedFact, StreamId } from "@ddd-ts/core";
-import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
+import { StreamId, type ISerializedChange, type ISerializedFact, type EventStreamStorageLayer } from "@ddd-ts/core";
+import type { ISerializedSavedChange } from "@ddd-ts/core/dist/interfaces/es-event";
 import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
-
-//#region src/in-memory.event-stream.storage-layer.d.ts
-declare class InMemoryEventStreamStorageLayer implements EventStreamStorageLayer {
-  readonly database: InMemoryDatabase;
-  constructor(database: InMemoryDatabase);
-  isLocalRevisionOutdatedError(error: unknown): boolean;
-  append(streamId: StreamId, changes: ISerializedChange[], expectedRevision: number, trx: InMemoryTransaction): Promise<ISerializedSavedChange$1[]>;
-  read(streamId: StreamId, from?: number): AsyncIterable<ISerializedFact>;
+export declare class InMemoryEventStreamStorageLayer implements EventStreamStorageLayer {
+    readonly database: InMemoryDatabase;
+    constructor(database: InMemoryDatabase);
+    isLocalRevisionOutdatedError(error: unknown): boolean;
+    append(streamId: StreamId, changes: ISerializedChange[], expectedRevision: number, trx: InMemoryTransaction): Promise<ISerializedSavedChange[]>;
+    read(streamId: StreamId, from?: number): AsyncIterable<ISerializedFact>;
 }
-//#endregion
-export { InMemoryEventStreamStorageLayer };
 //# sourceMappingURL=in-memory.event-stream.storage-layer.d.ts.map

package/dist/in-memory.event-stream.storage-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.event-stream.storage-layer.d.ts","names":[],"sources":["../src/in-memory.event-stream.storage-layer.ts"],"mappings":";;;;;cAUa,+BAAA,YACA,uBAAA;EAAA,SAEiB,QAAA,EAAU,gBAAA;cAAV,QAAA,EAAU,gBAAA;EAEtC,4BAAA,CAA6B,KAAA;EAIvB,MAAA,CACJ,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,iBAAA,IACT,gBAAA,UACA,GAAA,EAAK,mBAAA,GAAmB,OAAA,CAAA,wBAAA;EAkCnB,IAAA,CACL,QAAA,EAAU,QAAA,EACV,IAAA,YACC,aAAA,CAAc,eAAA;AAAA"}
+{"version":3,"file":"in-memory.event-stream.storage-layer.d.ts","sourceRoot":"","sources":["../src/in-memory.event-stream.storage-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAE7B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE/E,qBAAa,+BACX,YAAW,uBAAuB;aAEN,QAAQ,EAAE,gBAAgB;gBAA1B,QAAQ,EAAE,gBAAgB;IAEtD,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAI/C,MAAM,CACV,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,iBAAiB,EAAE,EAC5B,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,mBAAmB;IAkCnB,IAAI,CACT,QAAQ,EAAE,QAAQ,EAClB,IAAI,CAAC,EAAE,MAAM,GACZ,aAAa,CAAC,eAAe,CAAC;CAclC"}

package/dist/in-memory.event-stream.storage-layer.js

@@ -1,6 +1,5 @@
-import { ConcurrencyError, EventStreamStorageLayer, StreamId } from "@ddd-ts/core";
-import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
-import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
+let _ddd_ts_core = require("@ddd-ts/core");
+let _ddd_ts_store_inmemory = require("@ddd-ts/store-inmemory");
 
 //#region src/in-memory.event-stream.storage-layer.ts
 var InMemoryEventStreamStorageLayer = class {
@@ -8,7 +7,7 @@ var InMemoryEventStreamStorageLayer = class {
 		this.database = database;
 	}
 	isLocalRevisionOutdatedError(error) {
-		return error instanceof ConcurrencyError;
+		return error instanceof _ddd_ts_core.ConcurrencyError;
 	}
 	async append(streamId, changes, expectedRevision, trx) {
 		const result = [];
@@ -40,5 +39,4 @@ var InMemoryEventStreamStorageLayer = class {
 };
 
 //#endregion
-export { InMemoryEventStreamStorageLayer };
-//# sourceMappingURL=in-memory.event-stream.storage-layer.js.map
+exports.InMemoryEventStreamStorageLayer = InMemoryEventStreamStorageLayer;