@ddd-ts/event-sourcing-inmemory 0.0.0-compute-timeout-on-process.3 → 0.0.0-compute-timeout-on-process.4

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

@@ -0,0 +1,41 @@
+import { HasTrait } from "./traits/src/index.js";
+import { EventLakeStore, EventOf, EventSourced, IEventBus, IEventSourced, IIdentifiable, ISerializer, Identifiable, LakeId } 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>>;
+};
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,43 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.js";
+import { EventLakeStore } 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 };
+//# sourceMappingURL=in-memory.event-lake.aggregate-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.aggregate-store.js","names":[],"sources":["../src/in-memory.event-lake.aggregate-store.ts"],"sourcesContent":["import {\n  LakeId,\n  type IEventBus,\n  EventLakeStore,\n  EventOf,\n  ISerializer,\n  IEventSourced,\n  IIdentifiable,\n  IChange,\n  EventSourced,\n  Identifiable,\n} from \"@ddd-ts/core\";\nimport {\n  InMemoryDatabase,\n  InMemoryStore,\n  InMemoryTransaction,\n  InMemoryTransactionPerformer,\n} from \"@ddd-ts/store-inmemory\";\nimport { InMemoryEventLakeStorageLayer } from \"./in-memory.event-lake.storage-layer\";\nimport { HasTrait } from \"@ddd-ts/traits\";\n\nexport const MakeInMemoryEventLakeAggregateStore = <\n  A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>,\n>(\n  AGGREGATE: A,\n) => {\n  abstract class $InMemoryEventLakeAggregateStore extends InMemoryEventLakeAggregateStore<\n    InstanceType<A>\n  > {\n    constructor(\n      public readonly database: InMemoryDatabase,\n      public readonly collection: string,\n      serializer: ISerializer<InstanceType<A>> &\n        ISerializer<EventOf<InstanceType<A>>>,\n      eventBus?: IEventBus,\n    ) {\n      super(database, collection, serializer, eventBus, AGGREGATE.name);\n    }\n\n    abstract getLakeId(instance: InstanceType<A>): LakeId;\n  }\n\n  return $InMemoryEventLakeAggregateStore;\n};\n\nexport abstract class InMemoryEventLakeAggregateStore<\n  A extends IEventSourced & IIdentifiable,\n> extends InMemoryStore<A> {\n  transaction: InMemoryTransactionPerformer;\n  lakeStore: EventLakeStore<EventOf<A>>;\n  constructor(\n    public readonly database: InMemoryDatabase,\n    public readonly collection: string,\n    public readonly serializer: ISerializer<EventOf<A>> & ISerializer<A>,\n    public readonly eventBus?: IEventBus,\n    public readonly $name?: string,\n  ) {\n    const storageLayer = new InMemoryEventLakeStorageLayer(database);\n    super(collection, database, serializer, $name);\n    this.lakeStore = new EventLakeStore<EventOf<A>>(\n      storageLayer,\n      serializer,\n      eventBus,\n    );\n    this.transaction = new InMemoryTransactionPerformer(database);\n  }\n\n  abstract getLakeId(instance: A): LakeId;\n\n  override async save(aggregate: A, trx?: InMemoryTransaction) {\n    const changes = aggregate.changes as IChange<EventOf<A>>[];\n\n    await this.transaction.performWith(trx, async (trx) => {\n      const lakeId = this.getLakeId(aggregate);\n\n      await super.save(aggregate, trx);\n      await this.lakeStore.append(lakeId, changes, trx);\n      aggregate.clearChanges();\n    });\n  }\n}\n"],"mappings":";;;;;AAqBA,MAAa,uCAGX,cACG;CACH,MAAe,yCAAyC,gCAEtD;EACA,YACE,AAAgB,UAChB,AAAgB,YAChB,YAEA,UACA;AACA,SAAM,UAAU,YAAY,YAAY,UAAU,UAAU,KAAK;GANjD;GACA;;;AAWpB,QAAO;;AAGT,IAAsB,kCAAtB,cAEU,cAAiB;CACzB;CACA;CACA,YACE,AAAgB,UAChB,AAAgB,YAChB,AAAgB,YAChB,AAAgB,UAChB,AAAgB,OAChB;EACA,MAAM,eAAe,IAAI,8BAA8B,SAAS;AAChE,QAAM,YAAY,UAAU,YAAY,MAAM;EAP9B;EACA;EACA;EACA;EACA;AAIhB,OAAK,YAAY,IAAI,eACnB,cACA,YACA,SACD;AACD,OAAK,cAAc,IAAI,6BAA6B,SAAS;;CAK/D,MAAe,KAAK,WAAc,KAA2B;EAC3D,MAAM,UAAU,UAAU;AAE1B,QAAM,KAAK,YAAY,YAAY,KAAK,OAAO,QAAQ;GACrD,MAAM,SAAS,KAAK,UAAU,UAAU;AAExC,SAAM,MAAM,KAAK,WAAW,IAAI;AAChC,SAAM,KAAK,UAAU,OAAO,QAAQ,SAAS,IAAI;AACjD,aAAU,cAAc;IACxB"}

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

@@ -0,0 +1,14 @@
+import { EventId, EventLakeStorageLayer, ISerializedChange, ISerializedFact, LakeId } from "@ddd-ts/core";
+import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
+import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
+
+//#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>;
+}
+//#endregion
+export { InMemoryEventLakeStorageLayer };
+//# sourceMappingURL=in-memory.event-lake.storage-layer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,52 @@
+//#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 };
+//# sourceMappingURL=in-memory.event-lake.storage-layer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.storage-layer.js","names":[],"sources":["../src/in-memory.event-lake.storage-layer.ts"],"sourcesContent":["import {\n  LakeId,\n  type ISerializedChange,\n  type ISerializedFact,\n  EventLakeStorageLayer,\n  EventId,\n} from \"@ddd-ts/core\";\nimport { ISerializedSavedChange } from \"@ddd-ts/core/dist/interfaces/es-event\";\nimport { InMemoryDatabase, InMemoryTransaction } from \"@ddd-ts/store-inmemory\";\n\nexport class InMemoryEventLakeStorageLayer implements EventLakeStorageLayer {\n  constructor(public readonly database: InMemoryDatabase) {}\n\n  async append(\n    lakeId: LakeId,\n    changes: ISerializedChange[],\n    trx: InMemoryTransaction,\n  ) {\n    const result: ISerializedSavedChange[] = [];\n\n    let revision = 0;\n    for (const change of changes) {\n      const ref = `${lakeId.serialize()}/${change.id}`;\n\n      const stored = {\n        ...change,\n        ref: ref,\n        revision: revision,\n      };\n\n      this.database.save(\n        lakeId.serialize(),\n        change.id,\n        stored,\n        trx.transaction,\n      );\n      result.push({\n        ...change,\n        ref: ref,\n        revision: revision,\n        occurredAt: undefined,\n      });\n      revision++;\n    }\n    return result;\n  }\n\n  async *read(\n    lakeId: LakeId,\n    startAfter?: EventId,\n    endAt?: EventId,\n  ): AsyncIterable<ISerializedFact> {\n    const events = this.database.loadAll(lakeId.serialize());\n\n    const sorted = events.sort((a, b) =>\n      a.data.savedAt === b.data.savedAt\n        ? a.data.data.revision - b.data.data.revision\n        : a.data.savedAt < b.data.savedAt\n          ? -1\n          : 1,\n    );\n\n    const facts = sorted.map((e) => e.data);\n\n    let started = !startAfter;\n\n    for (const fact of facts) {\n      if (startAfter && fact.data.id === startAfter.serialize()) {\n        started = true;\n        continue;\n      }\n      if (endAt && fact.data.id === endAt.serialize()) {\n        yield { ...fact.data, occurredAt: fact.data.savedAt };\n        break;\n      }\n      if (started) {\n        yield { ...fact.data, occurredAt: fact.data.savedAt };\n      }\n    }\n  }\n}\n"],"mappings":";AAUA,IAAa,gCAAb,MAA4E;CAC1E,YAAY,AAAgB,UAA4B;EAA5B;;CAE5B,MAAM,OACJ,QACA,SACA,KACA;EACA,MAAM,SAAmC,EAAE;EAE3C,IAAI,WAAW;AACf,OAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,MAAM,GAAG,OAAO,WAAW,CAAC,GAAG,OAAO;GAE5C,MAAM,SAAS;IACb,GAAG;IACE;IACK;IACX;AAED,QAAK,SAAS,KACZ,OAAO,WAAW,EAClB,OAAO,IACP,QACA,IAAI,YACL;AACD,UAAO,KAAK;IACV,GAAG;IACE;IACK;IACV,YAAY;IACb,CAAC;AACF;;AAEF,SAAO;;CAGT,OAAO,KACL,QACA,YACA,OACgC;EAWhC,MAAM,QAVS,KAAK,SAAS,QAAQ,OAAO,WAAW,CAAC,CAElC,MAAM,GAAG,MAC7B,EAAE,KAAK,YAAY,EAAE,KAAK,UACtB,EAAE,KAAK,KAAK,WAAW,EAAE,KAAK,KAAK,WACnC,EAAE,KAAK,UAAU,EAAE,KAAK,UACtB,KACA,EACP,CAEoB,KAAK,MAAM,EAAE,KAAK;EAEvC,IAAI,UAAU,CAAC;AAEf,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,cAAc,KAAK,KAAK,OAAO,WAAW,WAAW,EAAE;AACzD,cAAU;AACV;;AAEF,OAAI,SAAS,KAAK,KAAK,OAAO,MAAM,WAAW,EAAE;AAC/C,UAAM;KAAE,GAAG,KAAK;KAAM,YAAY,KAAK,KAAK;KAAS;AACrD;;AAEF,OAAI,QACF,OAAM;IAAE,GAAG,KAAK;IAAM,YAAY,KAAK,KAAK;IAAS"}

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

@@ -0,0 +1,10 @@
+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>);
+}
+//#endregion
+export { InMemoryEventLakeStore };
+//# sourceMappingURL=in-memory.event-lake.store.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,13 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.js";
+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 };
+//# sourceMappingURL=in-memory.event-lake.store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-lake.store.js","names":[],"sources":["../src/in-memory.event-lake.store.ts"],"sourcesContent":["import { IEsEvent, EventLakeStore, ISerializer } from \"@ddd-ts/core\";\nimport type { InMemoryDatabase } from \"@ddd-ts/store-inmemory\";\nimport { InMemoryEventLakeStorageLayer } from \"./in-memory.event-lake.storage-layer\";\n\nexport class InMemoryEventLakeStore<\n  Event extends IEsEvent,\n> extends EventLakeStore<Event> {\n  constructor(database: InMemoryDatabase, serializer: ISerializer<Event>) {\n    super(new InMemoryEventLakeStorageLayer(database), serializer);\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,yBAAb,cAEU,eAAsB;CAC9B,YAAY,UAA4B,YAAgC;AACtE,QAAM,IAAI,8BAA8B,SAAS,EAAE,WAAW"}

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

@@ -0,0 +1,35 @@
+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 { 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;
+    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: _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);
+}
+//#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

@@ -0,0 +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"}

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

@@ -0,0 +1,36 @@
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.js";
+import { InMemorySnapshotter } from "./in-memory.snapshotter.js";
+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 };
+//# sourceMappingURL=in-memory.event-stream.aggregate-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.aggregate-store.js","names":[],"sources":["../src/in-memory.event-stream.aggregate-store.ts"],"sourcesContent":["import { HasTrait } from \"@ddd-ts/traits\";\nimport {\n  StreamId,\n  EventsOf,\n  EventSourced,\n  type Identifiable,\n  type IEventBus,\n  EventStreamStore,\n  EventStreamAggregateStore,\n  Named,\n  EventOf,\n  ISerializer,\n  IEventSourced,\n  IIdentifiable,\n} from \"@ddd-ts/core\";\nimport {\n  InMemoryDatabase,\n  InMemoryTransactionPerformer,\n} from \"@ddd-ts/store-inmemory\";\nimport { InMemorySnapshotter } from \"./in-memory.snapshotter\";\nimport { InMemoryEventStreamStorageLayer } from \"./in-memory.event-stream.storage-layer\";\n\nexport const MakeInMemoryEventStreamAggregateStore = <\n  A extends HasTrait<typeof EventSourced> & HasTrait<typeof Identifiable>,\n>(\n  AGGREGATE: A,\n) => {\n  return class $InMemoryEventStreamAggregateStore extends InMemoryEventStreamAggregateStore<\n    InstanceType<A>\n  > {\n    constructor(\n      database: InMemoryDatabase,\n      serializer: ISerializer<InstanceType<A>> &\n        ISerializer<EventOf<InstanceType<A>>>,\n      eventBus?: IEventBus,\n    ) {\n      const snapshotter = new InMemorySnapshotter<InstanceType<A>>(\n        AGGREGATE.name,\n        database,\n        serializer,\n      );\n      super(database, serializer, snapshotter, eventBus);\n    }\n\n    loadFirst(event: EventsOf<A>[number]): InstanceType<A> {\n      return AGGREGATE.loadFirst(event);\n    }\n\n    getStreamId(id: InstanceType<A>[\"id\"]): StreamId {\n      return StreamId.from(AGGREGATE.name, id.serialize());\n    }\n  };\n};\n\nexport abstract class InMemoryEventStreamAggregateStore<\n  A extends IEventSourced & IIdentifiable,\n> extends EventStreamAggregateStore<A> {\n  constructor(\n    public readonly database: InMemoryDatabase,\n    public readonly serializer: ISerializer<EventOf<A>>,\n    public readonly snapshotter: InMemorySnapshotter<A>,\n    public readonly eventBus?: IEventBus,\n  ) {\n    const storageLayer = new InMemoryEventStreamStorageLayer(database);\n    const transaction = new InMemoryTransactionPerformer(database);\n    const streamStore = new EventStreamStore<EventOf<A>>(\n      storageLayer,\n      serializer,\n      eventBus,\n    );\n    super(streamStore, transaction, snapshotter);\n  }\n}\n"],"mappings":";;;;;;AAsBA,MAAa,yCAGX,cACG;AACH,QAAO,MAAM,2CAA2C,kCAEtD;EACA,YACE,UACA,YAEA,UACA;GACA,MAAM,cAAc,IAAI,oBACtB,UAAU,MACV,UACA,WACD;AACD,SAAM,UAAU,YAAY,aAAa,SAAS;;EAGpD,UAAU,OAA6C;AACrD,UAAO,UAAU,UAAU,MAAM;;EAGnC,YAAY,IAAqC;AAC/C,UAAO,SAAS,KAAK,UAAU,MAAM,GAAG,WAAW,CAAC;;;;AAK1D,IAAsB,oCAAtB,cAEU,0BAA6B;CACrC,YACE,AAAgB,UAChB,AAAgB,YAChB,AAAgB,aAChB,AAAgB,UAChB;EACA,MAAM,eAAe,IAAI,gCAAgC,SAAS;EAClE,MAAM,cAAc,IAAI,6BAA6B,SAAS;EAC9D,MAAM,cAAc,IAAI,iBACtB,cACA,YACA,SACD;AACD,QAAM,aAAa,aAAa,YAAY;EAZ5B;EACA;EACA;EACA"}

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

@@ -0,0 +1,15 @@
+import { EventStreamStorageLayer, ISerializedChange, ISerializedFact, StreamId } from "@ddd-ts/core";
+import { InMemoryDatabase, InMemoryTransaction } from "@ddd-ts/store-inmemory";
+import { ISerializedSavedChange as ISerializedSavedChange$1 } from "@ddd-ts/core/dist/interfaces/es-event";
+
+//#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>;
+}
+//#endregion
+export { InMemoryEventStreamStorageLayer };
+//# sourceMappingURL=in-memory.event-stream.storage-layer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,42 @@
+import { ConcurrencyError } from "@ddd-ts/core";
+
+//#region src/in-memory.event-stream.storage-layer.ts
+var InMemoryEventStreamStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	isLocalRevisionOutdatedError(error) {
+		return error instanceof ConcurrencyError;
+	}
+	async append(streamId, changes, expectedRevision, trx) {
+		const result = [];
+		let revision = expectedRevision + 1;
+		for (const change of changes) {
+			const ref = `${streamId.serialize()}/${revision}`;
+			const stored = {
+				...change,
+				ref,
+				revision
+			};
+			this.database.create(streamId.serialize(), `${revision}`, stored, trx.transaction);
+			result.push({
+				...change,
+				ref,
+				revision,
+				occurredAt: void 0
+			});
+			revision++;
+		}
+		return result;
+	}
+	async *read(streamId, from) {
+		yield* this.database.loadAll(streamId.serialize()).sort((a, b) => a.data.data.revision - b.data.data.revision).map((e) => ({
+			...e.data.data,
+			occurredAt: e.data.savedAt
+		})).slice(from !== void 0 ? from : 0);
+	}
+};
+
+//#endregion
+export { InMemoryEventStreamStorageLayer };
+//# sourceMappingURL=in-memory.event-stream.storage-layer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.storage-layer.js","names":[],"sources":["../src/in-memory.event-stream.storage-layer.ts"],"sourcesContent":["import {\n  StreamId,\n  type ISerializedChange,\n  type ISerializedFact,\n  EventStreamStorageLayer,\n  ConcurrencyError,\n} from \"@ddd-ts/core\";\nimport { ISerializedSavedChange } from \"@ddd-ts/core/dist/interfaces/es-event\";\nimport { InMemoryDatabase, InMemoryTransaction } from \"@ddd-ts/store-inmemory\";\n\nexport class InMemoryEventStreamStorageLayer\n  implements EventStreamStorageLayer\n{\n  constructor(public readonly database: InMemoryDatabase) {}\n\n  isLocalRevisionOutdatedError(error: unknown): boolean {\n    return error instanceof ConcurrencyError;\n  }\n\n  async append(\n    streamId: StreamId,\n    changes: ISerializedChange[],\n    expectedRevision: number,\n    trx: InMemoryTransaction,\n  ) {\n    const result: ISerializedSavedChange[] = [];\n\n    let revision = expectedRevision + 1;\n\n    for (const change of changes) {\n      const ref = `${streamId.serialize()}/${revision}`;\n\n      const stored = {\n        ...change,\n        ref: ref,\n        revision: revision,\n      };\n\n      this.database.create(\n        streamId.serialize(),\n        `${revision}`,\n        stored,\n        trx.transaction,\n      );\n\n      result.push({\n        ...change,\n        ref: ref,\n        revision: revision,\n        occurredAt: undefined,\n      });\n\n      revision++;\n    }\n    return result;\n  }\n\n  async *read(\n    streamId: StreamId,\n    from?: number,\n  ): AsyncIterable<ISerializedFact> {\n    const events = this.database.loadAll(streamId.serialize());\n\n    const sorted = events.sort(\n      (a, b) => a.data.data.revision - b.data.data.revision,\n    );\n\n    const facts = sorted.map((e) => ({\n      ...e.data.data,\n      occurredAt: e.data.savedAt,\n    }));\n\n    yield* facts.slice(from !== undefined ? from : 0);\n  }\n}\n"],"mappings":";;;AAUA,IAAa,kCAAb,MAEA;CACE,YAAY,AAAgB,UAA4B;EAA5B;;CAE5B,6BAA6B,OAAyB;AACpD,SAAO,iBAAiB;;CAG1B,MAAM,OACJ,UACA,SACA,kBACA,KACA;EACA,MAAM,SAAmC,EAAE;EAE3C,IAAI,WAAW,mBAAmB;AAElC,OAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,MAAM,GAAG,SAAS,WAAW,CAAC,GAAG;GAEvC,MAAM,SAAS;IACb,GAAG;IACE;IACK;IACX;AAED,QAAK,SAAS,OACZ,SAAS,WAAW,EACpB,GAAG,YACH,QACA,IAAI,YACL;AAED,UAAO,KAAK;IACV,GAAG;IACE;IACK;IACV,YAAY;IACb,CAAC;AAEF;;AAEF,SAAO;;CAGT,OAAO,KACL,UACA,MACgC;AAYhC,SAXe,KAAK,SAAS,QAAQ,SAAS,WAAW,CAAC,CAEpC,MACnB,GAAG,MAAM,EAAE,KAAK,KAAK,WAAW,EAAE,KAAK,KAAK,SAC9C,CAEoB,KAAK,OAAO;GAC/B,GAAG,EAAE,KAAK;GACV,YAAY,EAAE,KAAK;GACpB,EAAE,CAEU,MAAM,SAAS,SAAY,OAAO,EAAE"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.store.d.ts","names":[],"sources":["../src/in-memory.event-stream.store.ts"],"mappings":";;;;cAIa,wBAAA,eACG,QAAA,UACN,gBAAA,CAAiB,KAAA;cACb,QAAA,EAAU,gBAAA,EAAkB,UAAA,EAAY,WAAA,CAAY,KAAA;AAAA"}

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

@@ -0,0 +1,13 @@
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.js";
+import { EventStreamStore } from "@ddd-ts/core";
+
+//#region src/in-memory.event-stream.store.ts
+var InMemoryEventStreamStore = class extends EventStreamStore {
+	constructor(database, serializer) {
+		super(new InMemoryEventStreamStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+export { InMemoryEventStreamStore };
+//# sourceMappingURL=in-memory.event-stream.store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.event-stream.store.js","names":[],"sources":["../src/in-memory.event-stream.store.ts"],"sourcesContent":["import { EventStreamStore, IEsEvent, INamed, ISerializer } from \"@ddd-ts/core\";\nimport type { InMemoryDatabase } from \"@ddd-ts/store-inmemory\";\nimport { InMemoryEventStreamStorageLayer } from \"./in-memory.event-stream.storage-layer\";\n\nexport class InMemoryEventStreamStore<\n  Event extends IEsEvent,\n> extends EventStreamStore<Event> {\n  constructor(database: InMemoryDatabase, serializer: ISerializer<Event>) {\n    super(new InMemoryEventStreamStorageLayer(database), serializer);\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,2BAAb,cAEU,iBAAwB;CAChC,YAAY,UAA4B,YAAgC;AACtE,QAAM,IAAI,gCAAgC,SAAS,EAAE,WAAW"}

package/dist/in-memory.projected-stream.reader.d.ts

@@ -0,0 +1,10 @@
+import { IEsEvent, ISerializer, ProjectedStreamReader } from "@ddd-ts/core";
+import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.projected-stream.reader.d.ts
+declare class InMemoryProjectedStreamReader<Events extends IEsEvent> extends ProjectedStreamReader<Events> {
+  constructor(database: InMemoryDatabase, serializer: ISerializer<Events>);
+}
+//#endregion
+export { InMemoryProjectedStreamReader };
+//# sourceMappingURL=in-memory.projected-stream.reader.d.ts.map

package/dist/in-memory.projected-stream.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.projected-stream.reader.d.ts","names":[],"sources":["../src/in-memory.projected-stream.reader.ts"],"mappings":";;;;cAIa,6BAAA,gBACI,QAAA,UACP,qBAAA,CAAsB,MAAA;cAClB,QAAA,EAAU,gBAAA,EAAkB,UAAA,EAAY,WAAA,CAAY,MAAA;AAAA"}

package/dist/in-memory.projected-stream.reader.js

@@ -0,0 +1,13 @@
+import { InMemoryProjectedStreamStorageLayer } from "./in-memory.projected-stream.storage-layer.js";
+import { ProjectedStreamReader } from "@ddd-ts/core";
+
+//#region src/in-memory.projected-stream.reader.ts
+var InMemoryProjectedStreamReader = class extends ProjectedStreamReader {
+	constructor(database, serializer) {
+		super(new InMemoryProjectedStreamStorageLayer(database), serializer);
+	}
+};
+
+//#endregion
+export { InMemoryProjectedStreamReader };
+//# sourceMappingURL=in-memory.projected-stream.reader.js.map

package/dist/in-memory.projected-stream.reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.projected-stream.reader.js","names":[],"sources":["../src/in-memory.projected-stream.reader.ts"],"sourcesContent":["import { IEsEvent, ISerializer, ProjectedStreamReader } from \"@ddd-ts/core\";\nimport { InMemoryDatabase } from \"@ddd-ts/store-inmemory\";\nimport { InMemoryProjectedStreamStorageLayer } from \"./in-memory.projected-stream.storage-layer\";\n\nexport class InMemoryProjectedStreamReader<\n  Events extends IEsEvent,\n> extends ProjectedStreamReader<Events> {\n  constructor(database: InMemoryDatabase, serializer: ISerializer<Events>) {\n    super(new InMemoryProjectedStreamStorageLayer(database), serializer);\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,gCAAb,cAEU,sBAA8B;CACtC,YAAY,UAA4B,YAAiC;AACvE,QAAM,IAAI,oCAAoC,SAAS,EAAE,WAAW"}

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

@@ -0,0 +1,31 @@
+import { Cursor, ISerializedFact, ISerializedSavedChange, LakeSource, ProjectedStream, ProjectedStreamStorageLayer, StreamSource } from "@ddd-ts/core";
+import { InMemoryDatabase } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.projected-stream.storage-layer.d.ts
+declare class InMemoryStreamSourceFilter {
+  private readonly database;
+  constructor(database: InMemoryDatabase);
+  all(source: StreamSource, shard: string): Generator<{
+    savedAt: bigint;
+    data: any;
+  }, void, unknown>;
+}
+declare class InMemoryLakeSourceFilter {
+  private readonly database;
+  constructor(database: InMemoryDatabase);
+  all(source: LakeSource, shard: string): Generator<{
+    savedAt: bigint;
+    data: any;
+  }, void, unknown>;
+}
+declare class InMemoryProjectedStreamStorageLayer implements ProjectedStreamStorageLayer {
+  private readonly database;
+  constructor(database: InMemoryDatabase);
+  getCursor(savedChange: ISerializedSavedChange): Promise<Cursor | undefined>;
+  get(cursor: Cursor): Promise<ISerializedFact | undefined>;
+  read(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor): AsyncGenerator<any, void, unknown>;
+  slice(projectedStream: ProjectedStream, shard: string, startAfter?: Cursor, endAt?: Cursor, count?: number): Promise<ISerializedFact[]>;
+}
+//#endregion
+export { InMemoryLakeSourceFilter, InMemoryProjectedStreamStorageLayer, InMemoryStreamSourceFilter };
+//# sourceMappingURL=in-memory.projected-stream.storage-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.projected-stream.storage-layer.d.ts","names":[],"sources":["../src/in-memory.projected-stream.storage-layer.ts"],"mappings":";;;;cAca,0BAAA;EAAA,iBACkB,QAAA;cAAA,QAAA,EAAU,gBAAA;EAEtC,GAAA,CAAI,MAAA,EAAQ,YAAA,EAAc,KAAA,WAAa,SAAA;;;;;cAiB7B,wBAAA;EAAA,iBACkB,QAAA;cAAA,QAAA,EAAU,gBAAA;EAEtC,GAAA,CAAI,MAAA,EAAQ,UAAA,EAAY,KAAA,WAAa,SAAA;;;;;cAc3B,mCAAA,YACA,2BAAA;EAAA,iBAEkB,QAAA;cAAA,QAAA,EAAU,gBAAA;EAEjC,SAAA,CACJ,WAAA,EAAa,sBAAA,GACZ,OAAA,CAAQ,MAAA;EAeL,GAAA,CAAI,MAAA,EAAQ,MAAA,GAAS,OAAA,CAAQ,eAAA;EAU5B,IAAA,CACL,eAAA,EAAiB,eAAA,EACjB,KAAA,UACA,UAAA,GAAa,MAAA,EACb,KAAA,GAAQ,MAAA,GAAM,cAAA;EAmCV,KAAA,CACJ,eAAA,EAAiB,eAAA,EACjB,KAAA,UACA,UAAA,GAAa,MAAA,EACb,KAAA,GAAQ,MAAA,EACR,KAAA,YACC,OAAA,CAAQ,eAAA;AAAA"}

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

@@ -0,0 +1,97 @@
+import { Cursor, EventId, LakeId, StreamSource } from "@ddd-ts/core";
+import { MicrosecondTimestamp } from "@ddd-ts/shape";
+
+//#region src/in-memory.projected-stream.storage-layer.ts
+var InMemoryStreamSourceFilter = class {
+	constructor(database) {
+		this.database = database;
+	}
+	*all(source, shard) {
+		const streams = [...this.database.storage.collections.keys()].filter((it) => it.startsWith(source.aggregateType));
+		for (const stream of streams) yield* this.database.loadAll(stream).filter((event) => {
+			if (!source.events.includes(event.data.data.name)) return false;
+			const payload = event.data.data.payload;
+			if (!payload) return false;
+			return payload[source.shardKey] === shard;
+		}).map((event) => event.data);
+	}
+};
+var InMemoryLakeSourceFilter = class {
+	constructor(database) {
+		this.database = database;
+	}
+	*all(source, shard) {
+		const lakeId = LakeId.from(source.shardType, shard);
+		yield* this.database.loadAll(lakeId.serialize()).filter((event) => {
+			if (!source.events.includes(event.data.data.name)) return false;
+			const payload = event.data.data.payload;
+			if (!payload) return false;
+			return payload[source.shardKey] === shard;
+		}).map((event) => event.data);
+	}
+};
+var InMemoryProjectedStreamStorageLayer = class {
+	constructor(database) {
+		this.database = database;
+	}
+	async getCursor(savedChange) {
+		const [collection, id] = savedChange.ref.split("/");
+		if (!collection || !id) return void 0;
+		const raw = this.database.storage.getCollection(collection).getRaw(id);
+		if (!raw) return void 0;
+		return new Cursor({
+			ref: savedChange.ref,
+			eventId: new EventId(savedChange.id),
+			occurredAt: MicrosecondTimestamp.fromMicroseconds(raw.savedAt),
+			revision: savedChange.revision
+		});
+	}
+	async get(cursor) {
+		const [collection, id] = cursor.ref.split("/");
+		if (!collection || !id) return void 0;
+		const raw = this.database.storage.getCollection(collection).getRaw(id);
+		if (!raw) return void 0;
+		return {
+			...raw.data,
+			occurredAt: raw.savedAt
+		};
+	}
+	async *read(projectedStream, shard, startAfter, endAt) {
+		const all = projectedStream.sources.map((source) => {
+			if (source instanceof StreamSource) return new InMemoryStreamSourceFilter(this.database).all(source, shard);
+			return new InMemoryLakeSourceFilter(this.database).all(source, shard);
+		}).flatMap((source) => [...source]).sort((a, b) => a.savedAt === b.savedAt ? a.data.revision - b.data.revision : a.savedAt > b.savedAt ? 1 : -1);
+		let started = !startAfter?.ref;
+		for (const fact of all) {
+			if (startAfter && fact.data.ref === startAfter.ref) {
+				started = true;
+				continue;
+			}
+			if (endAt?.ref && fact.data.ref === endAt.ref) {
+				yield {
+					...fact.data,
+					occurredAt: fact.savedAt
+				};
+				break;
+			}
+			if (started) yield {
+				...fact.data,
+				occurredAt: fact.savedAt
+			};
+		}
+	}
+	async slice(projectedStream, shard, startAfter, endAt, count) {
+		const stream = this.read(projectedStream, shard, startAfter, endAt);
+		const result = [];
+		let limit = count ?? Number.POSITIVE_INFINITY;
+		for await (const fact of stream) {
+			if (!limit--) break;
+			result.push(fact);
+		}
+		return result;
+	}
+};
+
+//#endregion
+export { InMemoryLakeSourceFilter, InMemoryProjectedStreamStorageLayer, InMemoryStreamSourceFilter };
+//# sourceMappingURL=in-memory.projected-stream.storage-layer.js.map

package/dist/in-memory.projected-stream.storage-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.projected-stream.storage-layer.js","names":[],"sources":["../src/in-memory.projected-stream.storage-layer.ts"],"sourcesContent":["import {\n  EventId,\n  ISerializedFact,\n  LakeId,\n  LakeSource,\n  ProjectedStream,\n  ProjectedStreamStorageLayer,\n  StreamSource,\n  Cursor,\n  ISerializedSavedChange,\n} from \"@ddd-ts/core\";\nimport { InMemoryDatabase } from \"@ddd-ts/store-inmemory\";\nimport { MicrosecondTimestamp } from \"@ddd-ts/shape\";\n\nexport class InMemoryStreamSourceFilter {\n  constructor(private readonly database: InMemoryDatabase) {}\n\n  *all(source: StreamSource, shard: string) {\n    const cols = [...this.database.storage.collections.keys()];\n    const streams = cols.filter((it) => it.startsWith(source.aggregateType));\n    for (const stream of streams) {\n      yield* this.database\n        .loadAll(stream)\n        .filter((event) => {\n          if (!source.events.includes(event.data.data.name)) return false;\n          const payload = event.data.data.payload;\n          if (!payload) return false;\n          return payload[source.shardKey] === shard;\n        })\n        .map((event) => event.data);\n    }\n  }\n}\n\nexport class InMemoryLakeSourceFilter {\n  constructor(private readonly database: InMemoryDatabase) {}\n\n  *all(source: LakeSource, shard: string) {\n    const lakeId = LakeId.from(source.shardType, shard);\n    yield* this.database\n      .loadAll(lakeId.serialize())\n      .filter((event) => {\n        if (!source.events.includes(event.data.data.name)) return false;\n        const payload = event.data.data.payload;\n        if (!payload) return false;\n        return payload[source.shardKey] === shard;\n      })\n      .map((event) => event.data);\n  }\n}\n\nexport class InMemoryProjectedStreamStorageLayer\n  implements ProjectedStreamStorageLayer\n{\n  constructor(private readonly database: InMemoryDatabase) {}\n\n  async getCursor(\n    savedChange: ISerializedSavedChange,\n  ): Promise<Cursor | undefined> {\n    const [collection, id] = savedChange.ref.split(\"/\");\n    if (!collection || !id) return undefined;\n\n    const raw = this.database.storage.getCollection(collection).getRaw(id);\n\n    if (!raw) return undefined;\n    return new Cursor({\n      ref: savedChange.ref,\n      eventId: new EventId(savedChange.id),\n      occurredAt: MicrosecondTimestamp.fromMicroseconds(raw.savedAt),\n      revision: savedChange.revision,\n    });\n  }\n\n  async get(cursor: Cursor): Promise<ISerializedFact | undefined> {\n    const [collection, id] = cursor.ref.split(\"/\");\n    if (!collection || !id) return undefined;\n\n    const raw = this.database.storage.getCollection(collection).getRaw(id);\n\n    if (!raw) return undefined;\n    return { ...raw.data, occurredAt: raw.savedAt };\n  }\n\n  async *read(\n    projectedStream: ProjectedStream,\n    shard: string,\n    startAfter?: Cursor,\n    endAt?: Cursor,\n  ) {\n    const sources = projectedStream.sources.map((source) => {\n      if (source instanceof StreamSource) {\n        return new InMemoryStreamSourceFilter(this.database).all(source, shard);\n      }\n      return new InMemoryLakeSourceFilter(this.database).all(source, shard);\n    });\n\n    const all = sources\n      .flatMap((source) => [...source])\n      .sort((a, b) =>\n        a.savedAt === b.savedAt\n          ? a.data.revision - b.data.revision\n          : a.savedAt > b.savedAt\n            ? 1\n            : -1,\n      );\n\n    let started = !startAfter?.ref;\n    for (const fact of all) {\n      if (startAfter && fact.data.ref === startAfter.ref) {\n        started = true;\n        continue;\n      }\n      if (endAt?.ref && fact.data.ref === endAt.ref) {\n        yield { ...fact.data, occurredAt: fact.savedAt };\n        break;\n      }\n      if (started) {\n        yield { ...fact.data, occurredAt: fact.savedAt };\n      }\n    }\n  }\n\n  async slice(\n    projectedStream: ProjectedStream,\n    shard: string,\n    startAfter?: Cursor,\n    endAt?: Cursor,\n    count?: number,\n  ): Promise<ISerializedFact[]> {\n    const stream = this.read(projectedStream, shard, startAfter, endAt);\n\n    const result: ISerializedFact[] = [];\n\n    let limit = count ?? Number.POSITIVE_INFINITY;\n    for await (const fact of stream) {\n      if (!limit--) break;\n      result.push(fact);\n    }\n\n    return result;\n  }\n}\n"],"mappings":";;;;AAcA,IAAa,6BAAb,MAAwC;CACtC,YAAY,AAAiB,UAA4B;EAA5B;;CAE7B,CAAC,IAAI,QAAsB,OAAe;EAExC,MAAM,UADO,CAAC,GAAG,KAAK,SAAS,QAAQ,YAAY,MAAM,CAAC,CACrC,QAAQ,OAAO,GAAG,WAAW,OAAO,cAAc,CAAC;AACxE,OAAK,MAAM,UAAU,QACnB,QAAO,KAAK,SACT,QAAQ,OAAO,CACf,QAAQ,UAAU;AACjB,OAAI,CAAC,OAAO,OAAO,SAAS,MAAM,KAAK,KAAK,KAAK,CAAE,QAAO;GAC1D,MAAM,UAAU,MAAM,KAAK,KAAK;AAChC,OAAI,CAAC,QAAS,QAAO;AACrB,UAAO,QAAQ,OAAO,cAAc;IACpC,CACD,KAAK,UAAU,MAAM,KAAK;;;AAKnC,IAAa,2BAAb,MAAsC;CACpC,YAAY,AAAiB,UAA4B;EAA5B;;CAE7B,CAAC,IAAI,QAAoB,OAAe;EACtC,MAAM,SAAS,OAAO,KAAK,OAAO,WAAW,MAAM;AACnD,SAAO,KAAK,SACT,QAAQ,OAAO,WAAW,CAAC,CAC3B,QAAQ,UAAU;AACjB,OAAI,CAAC,OAAO,OAAO,SAAS,MAAM,KAAK,KAAK,KAAK,CAAE,QAAO;GAC1D,MAAM,UAAU,MAAM,KAAK,KAAK;AAChC,OAAI,CAAC,QAAS,QAAO;AACrB,UAAO,QAAQ,OAAO,cAAc;IACpC,CACD,KAAK,UAAU,MAAM,KAAK;;;AAIjC,IAAa,sCAAb,MAEA;CACE,YAAY,AAAiB,UAA4B;EAA5B;;CAE7B,MAAM,UACJ,aAC6B;EAC7B,MAAM,CAAC,YAAY,MAAM,YAAY,IAAI,MAAM,IAAI;AACnD,MAAI,CAAC,cAAc,CAAC,GAAI,QAAO;EAE/B,MAAM,MAAM,KAAK,SAAS,QAAQ,cAAc,WAAW,CAAC,OAAO,GAAG;AAEtE,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,IAAI,OAAO;GAChB,KAAK,YAAY;GACjB,SAAS,IAAI,QAAQ,YAAY,GAAG;GACpC,YAAY,qBAAqB,iBAAiB,IAAI,QAAQ;GAC9D,UAAU,YAAY;GACvB,CAAC;;CAGJ,MAAM,IAAI,QAAsD;EAC9D,MAAM,CAAC,YAAY,MAAM,OAAO,IAAI,MAAM,IAAI;AAC9C,MAAI,CAAC,cAAc,CAAC,GAAI,QAAO;EAE/B,MAAM,MAAM,KAAK,SAAS,QAAQ,cAAc,WAAW,CAAC,OAAO,GAAG;AAEtE,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO;GAAE,GAAG,IAAI;GAAM,YAAY,IAAI;GAAS;;CAGjD,OAAO,KACL,iBACA,OACA,YACA,OACA;EAQA,MAAM,MAPU,gBAAgB,QAAQ,KAAK,WAAW;AACtD,OAAI,kBAAkB,aACpB,QAAO,IAAI,2BAA2B,KAAK,SAAS,CAAC,IAAI,QAAQ,MAAM;AAEzE,UAAO,IAAI,yBAAyB,KAAK,SAAS,CAAC,IAAI,QAAQ,MAAM;IACrE,CAGC,SAAS,WAAW,CAAC,GAAG,OAAO,CAAC,CAChC,MAAM,GAAG,MACR,EAAE,YAAY,EAAE,UACZ,EAAE,KAAK,WAAW,EAAE,KAAK,WACzB,EAAE,UAAU,EAAE,UACZ,IACA,GACP;EAEH,IAAI,UAAU,CAAC,YAAY;AAC3B,OAAK,MAAM,QAAQ,KAAK;AACtB,OAAI,cAAc,KAAK,KAAK,QAAQ,WAAW,KAAK;AAClD,cAAU;AACV;;AAEF,OAAI,OAAO,OAAO,KAAK,KAAK,QAAQ,MAAM,KAAK;AAC7C,UAAM;KAAE,GAAG,KAAK;KAAM,YAAY,KAAK;KAAS;AAChD;;AAEF,OAAI,QACF,OAAM;IAAE,GAAG,KAAK;IAAM,YAAY,KAAK;IAAS;;;CAKtD,MAAM,MACJ,iBACA,OACA,YACA,OACA,OAC4B;EAC5B,MAAM,SAAS,KAAK,KAAK,iBAAiB,OAAO,YAAY,MAAM;EAEnE,MAAM,SAA4B,EAAE;EAEpC,IAAI,QAAQ,SAAS,OAAO;AAC5B,aAAW,MAAM,QAAQ,QAAQ;AAC/B,OAAI,CAAC,QAAS;AACd,UAAO,KAAK,KAAK;;AAGnB,SAAO"}

package/dist/in-memory.snapshotter.d.ts

@@ -0,0 +1,10 @@
+import { IEsAggregateStore, IEventSourced, IIdentifiable, ISerializer } from "@ddd-ts/core";
+import { InMemoryDatabase, InMemoryStore } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.snapshotter.d.ts
+declare class InMemorySnapshotter<A extends IEventSourced & IIdentifiable> extends InMemoryStore<A> implements IEsAggregateStore<A> {
+  constructor(aggregate: string, db: InMemoryDatabase, serializer: ISerializer<A>);
+}
+//#endregion
+export { InMemorySnapshotter };
+//# sourceMappingURL=in-memory.snapshotter.d.ts.map

package/dist/in-memory.snapshotter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.snapshotter.d.ts","names":[],"sources":["../src/in-memory.snapshotter.ts"],"mappings":";;;;cA4Ba,mBAAA,WAA8B,aAAA,GAAgB,aAAA,UACjD,aAAA,CAAc,CAAA,aACX,iBAAA,CAAkB,CAAA;cAG3B,SAAA,UACA,EAAA,EAAI,gBAAA,EACJ,UAAA,EAAY,WAAA,CAAY,CAAA;AAAA"}

package/dist/in-memory.snapshotter.js

@@ -0,0 +1,29 @@
+import { InMemoryStore } from "@ddd-ts/store-inmemory";
+
+//#region src/in-memory.snapshotter.ts
+var SnapshotSerializer = class {
+	constructor(serializer) {
+		this.serializer = serializer;
+	}
+	async serialize(instance) {
+		return {
+			...await this.serializer.serialize(instance),
+			revision: instance.acknowledgedRevision
+		};
+	}
+	async deserialize(serialized) {
+		const { revision, ...content } = serialized;
+		const instance = await this.serializer.deserialize(content);
+		instance.acknowledgedRevision = Number(revision);
+		return instance;
+	}
+};
+var InMemorySnapshotter = class extends InMemoryStore {
+	constructor(aggregate, db, serializer) {
+		super(`snapshots-${aggregate}`, db, new SnapshotSerializer(serializer));
+	}
+};
+
+//#endregion
+export { InMemorySnapshotter };
+//# sourceMappingURL=in-memory.snapshotter.js.map

package/dist/in-memory.snapshotter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.snapshotter.js","names":[],"sources":["../src/in-memory.snapshotter.ts"],"sourcesContent":["import {\n  type IEsAggregateStore,\n  type IEventSourced,\n  type IIdentifiable,\n  type ISerializer,\n} from \"@ddd-ts/core\";\n\nimport { InMemoryDatabase, InMemoryStore } from \"@ddd-ts/store-inmemory\";\n\nclass SnapshotSerializer<A extends IEventSourced & IIdentifiable> {\n  constructor(private readonly serializer: ISerializer<A>) {}\n\n  async serialize(instance: A) {\n    const serialized = await this.serializer.serialize(instance);\n    return {\n      ...serialized,\n      revision: instance.acknowledgedRevision,\n    };\n  }\n\n  async deserialize(serialized: any) {\n    const { revision, ...content } = serialized;\n    const instance = await this.serializer.deserialize(content);\n    instance.acknowledgedRevision = Number(revision);\n    return instance;\n  }\n}\n\nexport class InMemorySnapshotter<A extends IEventSourced & IIdentifiable>\n  extends InMemoryStore<A>\n  implements IEsAggregateStore<A>\n{\n  constructor(\n    aggregate: string,\n    db: InMemoryDatabase,\n    serializer: ISerializer<A>,\n  ) {\n    super(`snapshots-${aggregate}`, db, new SnapshotSerializer(serializer));\n  }\n}\n"],"mappings":";;;AASA,IAAM,qBAAN,MAAkE;CAChE,YAAY,AAAiB,YAA4B;EAA5B;;CAE7B,MAAM,UAAU,UAAa;AAE3B,SAAO;GACL,GAFiB,MAAM,KAAK,WAAW,UAAU,SAAS;GAG1D,UAAU,SAAS;GACpB;;CAGH,MAAM,YAAY,YAAiB;EACjC,MAAM,EAAE,UAAU,GAAG,YAAY;EACjC,MAAM,WAAW,MAAM,KAAK,WAAW,YAAY,QAAQ;AAC3D,WAAS,uBAAuB,OAAO,SAAS;AAChD,SAAO;;;AAIX,IAAa,sBAAb,cACU,cAEV;CACE,YACE,WACA,IACA,YACA;AACA,QAAM,aAAa,aAAa,IAAI,IAAI,mBAAmB,WAAW,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.js";
+import { InMemoryEventLakeStore } from "./in-memory.event-lake.store.js";
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.js";
+import { InMemoryEventStreamStore } from "./in-memory.event-stream.store.js";
+import { InMemorySnapshotter } from "./in-memory.snapshotter.js";
+import { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore } from "./in-memory.event-stream.aggregate-store.js";
+import { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore } from "./in-memory.event-lake.aggregate-store.js";
+import { InMemoryLakeSourceFilter, InMemoryProjectedStreamStorageLayer, InMemoryStreamSourceFilter } from "./in-memory.projected-stream.storage-layer.js";
+import { InMemoryProjectedStreamReader } from "./in-memory.projected-stream.reader.js";
+export { InMemoryEventLakeAggregateStore, InMemoryEventLakeStorageLayer, InMemoryEventLakeStore, InMemoryEventStreamAggregateStore, InMemoryEventStreamStorageLayer, InMemoryEventStreamStore, InMemoryLakeSourceFilter, InMemoryProjectedStreamReader, InMemoryProjectedStreamStorageLayer, InMemorySnapshotter, InMemoryStreamSourceFilter, MakeInMemoryEventLakeAggregateStore, MakeInMemoryEventStreamAggregateStore };

package/dist/index.js

@@ -0,0 +1,11 @@
+import { InMemoryEventLakeStorageLayer } from "./in-memory.event-lake.storage-layer.js";
+import { InMemoryEventLakeStore } from "./in-memory.event-lake.store.js";
+import { InMemoryEventStreamStorageLayer } from "./in-memory.event-stream.storage-layer.js";
+import { InMemoryEventStreamStore } from "./in-memory.event-stream.store.js";
+import { InMemorySnapshotter } from "./in-memory.snapshotter.js";
+import { InMemoryEventStreamAggregateStore, MakeInMemoryEventStreamAggregateStore } from "./in-memory.event-stream.aggregate-store.js";
+import { InMemoryEventLakeAggregateStore, MakeInMemoryEventLakeAggregateStore } from "./in-memory.event-lake.aggregate-store.js";
+import { InMemoryLakeSourceFilter, InMemoryProjectedStreamStorageLayer, InMemoryStreamSourceFilter } from "./in-memory.projected-stream.storage-layer.js";
+import { InMemoryProjectedStreamReader } from "./in-memory.projected-stream.reader.js";
+
+export { InMemoryEventLakeAggregateStore, InMemoryEventLakeStorageLayer, InMemoryEventLakeStore, InMemoryEventStreamAggregateStore, InMemoryEventStreamStorageLayer, InMemoryEventStreamStore, InMemoryLakeSourceFilter, InMemoryProjectedStreamReader, InMemoryProjectedStreamStorageLayer, InMemorySnapshotter, InMemoryStreamSourceFilter, MakeInMemoryEventLakeAggregateStore, MakeInMemoryEventStreamAggregateStore };

package/dist/traits/src/index.d.ts

@@ -0,0 +1,17 @@
+//#region ../traits/src/index.d.ts
+type AbstractConstructor<Props = any, Result extends {} = {}> = abstract new (props: Props) => Result;
+type Trait<Factory extends <Base extends AbstractConstructor>(base: Base) => AbstractConstructor = any> = {
+  factory: Factory;
+  superTraits: readonly Trait<any>[];
+};
+declare const Trait: <T extends (base: AbstractConstructor<{}, {}>) => AbstractConstructor<any, any>>(factory: T) => {
+  factory: T;
+  superTraits: Trait[];
+  symbol: symbol;
+};
+type ConstructorWithTrait<T extends Trait> = Omit<ReturnType<T["factory"]>, ""> & (new (...args: any[]) => ImplementsTrait<T>);
+type HasTrait<T extends Trait | ((...args: any[]) => Trait)> = T extends ((...args: any[]) => Trait) ? HasTrait<ReturnType<T>> : T extends Trait ? ConstructorWithTrait<T> : never;
+type ImplementsTrait<T extends Trait> = InstanceType<ReturnType<T["factory"]>>;
+//#endregion
+export { HasTrait };
+//# sourceMappingURL=index.d.ts.map

package/dist/traits/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../traits/src/index.ts"],"mappings":";KAGY,mBAAA,sDAGM,KAAA,EAAO,KAAA,KAAU,MAAA;AAAA,KAEvB,KAAA,+BACoB,mBAAA,EAC5B,IAAA,EAAM,IAAA,KACH,mBAAA;EAEL,OAAA,EAAS,OAAA;EACT,WAAA,WAAsB,KAAA;AAAA;AAAA,cAoIX,KAAA,cAET,IAAA,EAAM,mBAAA,aACH,mBAAA,YAA6B,OAAA,EAEzB,CAAA;;eAG4B,KAAA;;;KAU3B,oBAAA,WAA+B,KAAA,IAAS,IAAA,CAClD,UAAA,CAAW,CAAA,6BAIN,IAAA,YACA,eAAA,CAAgB,CAAA;AAAA,KAEX,QAAA,WAAmB,KAAA,QAAa,IAAA,YAAgB,KAAA,KAC1D,CAAA,cAAc,IAAA,YAAgB,KAAA,IAC1B,QAAA,CAAS,UAAA,CAAW,CAAA,KACpB,CAAA,SAAU,KAAA,GACR,oBAAA,CAAqB,CAAA;AAAA,KAGjB,eAAA,WAA0B,KAAA,IAAS,YAAA,CAC7C,UAAA,CAAW,CAAA"}

package/package.json

@@ -1,26 +1,29 @@
 {
   "name": "@ddd-ts/event-sourcing-inmemory",
-  "version": "0.0.0-compute-timeout-on-process.3",
+  "version": "0.0.0-compute-timeout-on-process.4",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "repository": {
     "url": "git+https://github.com/ddd-ts/monorepo"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test": "jest --config node_modules/@ddd-ts/tools/jest.config.js",
     "build": "tsdown --config node_modules/@ddd-ts/tools/tsdown.config.js"
   },
   "dependencies": {
-    "@ddd-ts/core": "0.0.0-compute-timeout-on-process.3",
-    "@ddd-ts/shape": "0.0.0-compute-timeout-on-process.3",
-    "@ddd-ts/store-inmemory": "0.0.0-compute-timeout-on-process.3",
-    "@ddd-ts/types": "0.0.0-compute-timeout-on-process.3"
+    "@ddd-ts/core": "0.0.0-compute-timeout-on-process.4",
+    "@ddd-ts/shape": "0.0.0-compute-timeout-on-process.4",
+    "@ddd-ts/store-inmemory": "0.0.0-compute-timeout-on-process.4",
+    "@ddd-ts/types": "0.0.0-compute-timeout-on-process.4"
   },
   "devDependencies": {
-    "@ddd-ts/shape": "0.0.0-compute-timeout-on-process.3",
-    "@ddd-ts/tests": "0.0.0-compute-timeout-on-process.3",
-    "@ddd-ts/tools": "0.0.0-compute-timeout-on-process.3",
-    "@ddd-ts/traits": "0.0.0-compute-timeout-on-process.3",
+    "@ddd-ts/shape": "0.0.0-compute-timeout-on-process.4",
+    "@ddd-ts/tests": "0.0.0-compute-timeout-on-process.4",
+    "@ddd-ts/tools": "0.0.0-compute-timeout-on-process.4",
+    "@ddd-ts/traits": "0.0.0-compute-timeout-on-process.4",
     "@types/jest": "^29.5.1",
     "@types/node": "^20.12.4"
   },