@event-driven-io/emmett 0.20.1-alpha.3 → 0.20.1-alpha.5

package/dist/index.cjs

@@ -1,17 +1,1556 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;var _chunkCJZAVRMTcjs = require('./chunk-CJZAVRMT.cjs');var K=t=>"withSession"in t,X= exports.nulloSessionFactory =t=>({withSession:e=>e({eventStore:t,close:()=>Promise.resolve()})});var pt=(t,e,r)=>({type:t,data:e,metadata:r});var L=(t,e,r)=>({type:t,data:e,metadata:r});var ut=t=>({kind:"Reply",message:t}),ft= exports.send =t=>({kind:"Send",message:t}),yt= exports.publish =t=>({kind:"Publish",message:t}),vt= exports.schedule =(t,e)=>({kind:"Schedule",message:t,when:e}),Et= exports.complete =()=>({kind:"Complete"}),St= exports.ignore =t=>({kind:"Ignore",reason:t}),Tt= exports.error =t=>({kind:"Error",reason:t}),xt= exports.accept =()=>({kind:"Accept"});var H="__emt:GlobalStreamCaughtUp",Y= exports.isGlobalStreamCaughtUp =t=>t.type===H,Mt= exports.caughtUpEventFrom =t=>e=>e.type===H&&_optionalChain([e, 'access', _2 => _2.metadata, 'optionalAccess', _3 => _3.globalPosition])>=t,j= exports.globalStreamCaughtUp =t=>L(H,t,{globalPosition:t.globalPosition}),Vt= exports.isSubscriptionEvent =t=>Y(t),Pt= exports.isNotInternalEvent =t=>!Y(t);var xe="STREAM_EXISTS",F= exports.STREAM_DOES_NOT_EXIST ="STREAM_DOES_NOT_EXIST",D= exports.NO_CONCURRENCY_CHECK ="NO_CONCURRENCY_CHECK",ge= exports.matchesExpectedVersion =(t,e,r)=>e===D?!0:e==F?t===r:e==xe?t!==r:t===e,N= exports.assertExpectedVersionMatchesCurrent =(t,e,r)=>{if(e??=D,!ge(t,e,r))throw new b(t,e)},b= exports.ExpectedVersionConflictError =class t extends _chunkCJZAVRMTcjs.l{constructor(e,r){super(_optionalChain([e, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]),_optionalChain([r, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()])),Object.setPrototypeOf(this,t.prototype)}},z= exports.isExpectedVersionConflictError =t=>t instanceof b;var _uuid = require('uuid');var _webstreamspolyfill = require('web-streams-polyfill');var Q=t=>new _(t),_= exports.CaughtUpTransformStream =class extends _webstreamspolyfill.TransformStream{constructor(e){super({start:r=>{let n=0n;for(let o of e)r.enqueue(o),n=o.metadata.globalPosition;r.enqueue(j({globalPosition:n}))},transform:(r,n)=>{this._currentPosition=r.metadata.globalPosition,n.enqueue(r),!(this._currentPosition<this._logPosition)&&n.enqueue(j({globalPosition:this._currentPosition}))}}),this._currentPosition=this._logPosition=e.length>0?e[e.length-1].metadata.globalPosition:0n}set logPosition(e){this._logPosition=e}};var O=(t,e={})=>new S(t,e),S= (_class =class extends _webstreamspolyfill.TransformStream{constructor(r,n={}){super({cancel:o=>{console.log("Stream was canceled. Reason:",o),this.stopChecking()}});_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;this.onNoActiveReaderCallback=r;this.streamId=_nullishCoalesce(_optionalChain([n, 'optionalAccess', _8 => _8.streamId]), () => (_uuid.v4.call(void 0, ))),this.onNoActiveReaderCallback=r,this.startChecking(_nullishCoalesce(_optionalChain([n, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => (20)))}__init() {this.checkInterval=null}__init2() {this._isStopped=!1}get hasActiveSubscribers(){return!this._isStopped}startChecking(r){this.checkInterval=setInterval(()=>{this.checkNoActiveReader()},r)}stopChecking(){this.checkInterval&&(clearInterval(this.checkInterval),this.checkInterval=null,this._isStopped=!0,this.onNoActiveReaderCallback(this))}checkNoActiveReader(){!this.readable.locked&&!this._isStopped&&this.stopChecking()}}, _class);var Z=async(t,e)=>{if(t.writable.locked)return!1;let r=t.writable.getWriter();if(await r.ready,!t.readable.locked)return!1;try{for(let n of e)await r.write(n)}catch(n){console.log(n)}finally{await r.close()}return!0};var ee=()=>{let t=[],e=new Map;return{notify:async r=>{if(r.length!==0){t.push(...r);for(let n of e.values())n.logPosition=r[r.length-1].metadata.globalPosition,await Z(n,r)}},stream:()=>{let r=_uuid.v4.call(void 0, ),n=Q(t);return e.set(r,n),n.readable.pipeThrough(O(o=>{e.has(o.streamId)&&e.delete(o.streamId)},{streamId:r}))}}};var T=0n,ir= exports.getInMemoryEventStore =()=>{let t=new Map,e=ee(),r=()=>Array.from(t.values()).map(n=>n.length).reduce((n,o)=>n+o,0);return{async aggregateStream(n,o){let{evolve:a,initialState:i,read:m}=o,l=await this.readStream(n,m),y=_nullishCoalesce(_optionalChain([l, 'optionalAccess', _10 => _10.events]), () => ([]));return{currentStreamVersion:BigInt(y.length),state:y.reduce(a,i()),streamExists:l.streamExists}},readStream:(n,o)=>{let a=t.get(n),i=a?BigInt(a.length):T;N(i,_optionalChain([o, 'optionalAccess', _11 => _11.expectedStreamVersion]),T);let m=Number(o&&"from"in o?o.from:0),l=Number(o&&"to"in o?o.to:o&&"maxCount"in o&&o.maxCount?o.from+o.maxCount:_nullishCoalesce(_optionalChain([a, 'optionalAccess', _12 => _12.length]), () => (1))),y=a!==void 0&&a.length>0?a.map(f=>f).slice(m,l):[],E={currentStreamVersion:i,events:y,streamExists:a!==void 0&&a.length>0};return Promise.resolve(E)},appendToStream:async(n,o,a)=>{let i=_nullishCoalesce(t.get(n), () => ([])),m=i.length>0?BigInt(i.length):T;N(m,_optionalChain([a, 'optionalAccess', _13 => _13.expectedStreamVersion]),T);let l=o.map((f,v)=>({...f,metadata:{..._nullishCoalesce(f.metadata, () => ({})),streamName:n,eventId:_uuid.v4.call(void 0, ),streamPosition:BigInt(i.length+v+1),globalPosition:BigInt(r()+v+1)}})),y=BigInt(l.slice(-1)[0].metadata.streamPosition);return t.set(n,[...i,...l]),await e.notify(l),{nextExpectedStreamVersion:y,createdNewStream:m===T}}}};var d=(t,e)=>{if(Oe(t))return t.equals(e);if(Array.isArray(t))return Array.isArray(e)&&t.length===e.length&&t.every((o,a)=>d(o,e[a]));if(typeof t!="object"||typeof e!="object"||t===null||e===null)return t===e;if(Array.isArray(e))return!1;let r=Object.keys(t),n=Object.keys(e);if(r.length!==n.length||!r.every(o=>n.includes(o)))return!1;for(let o in t){if(t[o]instanceof Function&&e[o]instanceof Function)continue;if(!d(t[o],e[o]))return!1}return!0},Oe= exports.isEquatable =t=>t&&typeof t=="object"&&"equals"in t&&typeof t.equals=="function";var vr=t=>{let e,r,n=0;do({value:e,done:r}=t.next()),n+=e||0;while(!r);return n};var Sr=(t,e,r,n,o=()=>{})=>{let a=!1,i=t.map(m=>r(m)?(a=!0,n(m)):m).filter(m=>m!==void 0).map(m=>{if(!m)throw Error("That should not happen");return m});return!a&&o()!==void 0?[...t,e]:i};var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);var te={retries:0},w= exports.asyncRetry =async(t,e)=>e===void 0||e.retries===0?t():_asyncretry2.default.call(void 0, async r=>{try{return await t()}catch(n){throw _optionalChain([e, 'optionalAccess', _14 => _14.shouldRetryError])&&!e.shouldRetryError(n)&&r(n),n}},_nullishCoalesce(e, () => ({retries:0})));var re={retries:3,minTimeout:100,factor:1.5,shouldRetryError:z},Me=t=>t===void 0?te:"onVersionConflict"in t?typeof t.onVersionConflict=="boolean"?re:typeof t.onVersionConflict=="number"?{...re,retries:t.onVersionConflict}:t.onVersionConflict:t,ne= exports.CommandHandler =t=>async(e,r,n,o)=>w(async()=>await Ve(e,async({eventStore:i})=>{let{evolve:m,initialState:l}=t,E=(_nullishCoalesce(t.mapToStreamId, () => ((Te=>Te))))(r),f=await i.aggregateStream(E,{evolve:m,initialState:l,read:{expectedStreamVersion:_nullishCoalesce(_optionalChain([o, 'optionalAccess', _15 => _15.expectedStreamVersion]), () => (D))}}),v=f.state,B=f.currentStreamVersion,A=await n(v),R=Array.isArray(A)?A:[A];if(R.length===0)return{newEvents:[],newState:v,nextExpectedStreamVersion:B,createdNewStream:!1};let Se=_nullishCoalesce(_optionalChain([o, 'optionalAccess', _16 => _16.expectedStreamVersion]), () => ((f.streamExists?B:F)));return{...await i.appendToStream(E,R,{...o,expectedStreamVersion:Se}),newEvents:R,newState:R.reduce(m,v)}}),Me(o&&"retry"in o?o.retry:t.retry)),Ve=(t,e)=>(K(t)?t:X(t)).withSession(e);var Pr=t=>async(e,r,n,o)=>{let{decide:a,...i}=t;return ne(i)(e,r,m=>a(n,m),o)};var Nr=()=>{let t=new Map,e=[];return{send:async r=>{let n=t.get(r.type);if(n===void 0||n.length===0)throw new (0, _chunkCJZAVRMTcjs.k)(`No handler registered for command ${r.type}!`);let o=n[0];await o(r)},publish:async r=>{let n=_nullishCoalesce(t.get(r.type), () => ([]));for(let o of n)await o(r)},schedule:(r,n)=>{e=[...e,{message:r,options:n}]},handle:(r,...n)=>{let o=[...t.keys()].filter(a=>n.includes(a));if(o.length>0)throw new (0, _chunkCJZAVRMTcjs.k)(`Cannot register handler for commands ${o.join(", ")} as they're already registered!`);for(let a of n)t.set(a,[r])},subscribe(r,...n){for(let o of n)t.has(o)||t.set(o,[]),t.set(o,[..._nullishCoalesce(t.get(o), () => ([])),r])},dequeue:()=>{let r=e;return e=[],r}}};var Wr=t=>t,Pe= exports.inlineProjections =t=>t.map(e=>({type:"inline",projection:e})),ke= exports.asyncProjections =t=>t.map(e=>({type:"async",projection:e})),Gr= exports.projections ={inline:Pe,async:ke};var W=class extends Error{constructor(e){super(`Cannot parse! ${e}`)}},c= exports.JSONParser ={stringify:(t,e)=>JSON.stringify(_optionalChain([e, 'optionalAccess', _17 => _17.map])?e.map(t):t,(r,n)=>typeof n=="bigint"?n.toString():n),parse:(t,e)=>{let r=JSON.parse(t,_optionalChain([e, 'optionalAccess', _18 => _18.reviver]));if(_optionalChain([e, 'optionalAccess', _19 => _19.typeCheck])&&!_optionalChain([e, 'optionalAccess', _20 => _20.typeCheck, 'call', _21 => _21(r)]))throw new W(t);return _optionalChain([e, 'optionalAccess', _22 => _22.map])?e.map(r):r}};var G=t=>{let e=t.reduce((o,a)=>o+a.length,0),r=new Uint8Array(e),n=0;for(let o of t)r.set(o,n),n+=o.length;return r};var Lr=async t=>{let e=[];for await(let r of t)e.push(r);return e};var M= (_class2 =class{constructor() { _class2.prototype.__init3.call(this); }__init3() {this.buffer=[]}addToBuffer(e){this.buffer.push(e)}clearBuffer(){this.buffer=[]}hasCompleteMessage(){let e=G(this.buffer);return new TextDecoder().decode(e).includes(`
-`)}decode(){if(!this.hasCompleteMessage())return null;let e=G(this.buffer),r=new TextDecoder().decode(e),n=r.indexOf(`
-`);if(n===-1)return null;let o=r.slice(0,n),a=new Uint8Array(e.buffer,n+1);return this.buffer=a.byteLength>0?[a]:[],JSON.parse(o)}}, _class2);var V= (_class3 =class{constructor(e){;_class3.prototype.__init4.call(this);this.transform=e;this.transform=e}__init4() {this.buffer=[]}addToBuffer(e){this.buffer.push(e)}clearBuffer(){this.buffer=[]}hasCompleteMessage(){return this.buffer.some(e=>e.includes(`
-`))}decode(){let e=this.buffer.join("");if(!this.hasCompleteMessage()){if(e.trim().length>0)throw new Error("Unterminated string in JSON at position");return null}let r=e.indexOf(`
-`),n=e.slice(0,r).trim();return this.buffer=[e.slice(r+1)],this.transform(n)}}, _class3);var P=class extends V{constructor(){super(e=>JSON.parse(e))}};var k= (_class4 =class{constructor() { _class4.prototype.__init5.call(this); }__init5() {this.buffer=null}addToBuffer(e){this.buffer=e}clearBuffer(){this.buffer=null}hasCompleteMessage(){return this.buffer!==null}decode(){if(!this.hasCompleteMessage()||!this.buffer)return null;let e=this.buffer;return this.clearBuffer(),e}}, _class4);var q=class{constructor(e){this.decoders=e}decoderFor(e){let r=this.decoders.find(n=>n[0](e));return r?r[1]:null}addToBuffer(e){_optionalChain([this, 'access', _23 => _23.decoderFor, 'call', _24 => _24(e), 'optionalAccess', _25 => _25.addToBuffer, 'call', _26 => _26(e)])}clearBuffer(){for(let e of this.decoders.map(r=>r[1]))e.clearBuffer()}hasCompleteMessage(){return this.decoders.some(e=>e[1].hasCompleteMessage())}decode(){return _nullishCoalesce(_optionalChain([this, 'access', _27 => _27.decoders, 'access', _28 => _28.map, 'call', _29 => _29(r=>r[1]), 'access', _30 => _30.find, 'call', _31 => _31(r=>r.hasCompleteMessage()), 'optionalAccess', _32 => _32.decode, 'call', _33 => _33()]), () => (null))}},x= exports.DefaultDecoder =class extends q{constructor(){super([[e=>typeof e=="string",new P],[e=>e instanceof Uint8Array,new M],[e=>typeof e=="object",new k]])}};var oe=t=>new (0, _webstreamspolyfill.ReadableStream)({start(e){for(let r of t)e.enqueue(r);e.close()}});var En={fromArray:oe};var ae=t=>new (0, _webstreamspolyfill.TransformStream)({transform(e,r){t(e)&&r.enqueue(e)}});var se=t=>new (0, _webstreamspolyfill.TransformStream)({transform(e,r){r.enqueue(t(e))}});var ie=(t,e)=>new g(t,e),g=class extends _webstreamspolyfill.TransformStream{constructor(e,r){super({transform:n=>{this.accumulator=this.reducer(this.accumulator,n)},flush:n=>{n.enqueue(this.accumulator),n.terminate()}}),this.accumulator=r,this.reducer=e}};var me=(t,e,r={forever:!0,minTimeout:25})=>new (0, _webstreamspolyfill.TransformStream)({start(n){w(()=>Ne(t,e,n),r).catch(o=>{n.error(o)})}}),Ne=async(t,e,r)=>{let o=t().getReader();try{let a;do{let i=await o.read();a=i.done,await e(i,r),a&&r.terminate()}while(!a)}finally{o.releaseLock()}};var de=t=>new h(t),h= (_class5 =class extends _webstreamspolyfill.TransformStream{__init6() {this.count=0}constructor(e){super({transform:(r,n)=>{this.count++,this.count>this.skip&&n.enqueue(r)}});_class5.prototype.__init6.call(this);,this.skip=e}}, _class5);var pe=t=>new (0, _webstreamspolyfill.TransformStream)({transform(e,r){r.enqueue(e),t(e)&&r.terminate()}});var le=t=>new (0, _webstreamspolyfill.TransformStream)({async transform(e,r){if(!t(e)){r.enqueue(e);return}await Promise.resolve(),r.terminate()}});var ce=t=>new C(t),C= (_class6 =class extends _webstreamspolyfill.TransformStream{__init7() {this.count=0}constructor(e){super({transform:(r,n)=>{this.count<this.limit?(this.count++,n.enqueue(r)):n.terminate()}});_class6.prototype.__init7.call(this);,this.limit=e}}, _class6);var ue=t=>new (0, _webstreamspolyfill.TransformStream)({start(e){let r=setTimeout(()=>{e.terminate()},t),n=e.terminate.bind(e);e.terminate=()=>{clearTimeout(r),n()}},transform(e,r){r.enqueue(e)}});var fe={filter:ae,take:ce,TakeTransformStream:C,skip:de,SkipTransformStream:h,map:se,notifyAboutNoActiveReadersStream:O,NotifyAboutNoActiveReadersStream:S,reduce:ie,ReduceTransformStream:g,retry:me,stopAfter:pe,stopOn:le,waitAtMost:ue};var{retry:Be}=fe,Qn= exports.restream =(t,e=o=>o,r={forever:!0,minTimeout:25},n=new x)=>Be(t,$e(e,n),r).readable,$e=(t=r=>r,e=new x)=>(r,n)=>{let{done:o,value:a}=r;a&&e.addToBuffer(a),!(!o&&!e.hasCompleteMessage())&&Je(e,t,n)},Je=(t,e,r)=>{try{let n=t.decode();if(!n)return;let o=e(n);r.enqueue(o)}catch(n){r.error(new Error(`Decoding error: ${_optionalChain([n, 'optionalAccess', _34 => _34.toString, 'call', _35 => _35()])}`))}};var p=class extends Error{constructor(e){super(e)}},ye= exports.isSubset =(t,e)=>{let r=t,n=e;return U(r),U(n),Object.keys(n).every(o=>typeof n[o]=="object"?ye(r[o],n[o]):n[o]===r[o])},po= exports.assertFails =t=>{throw new p(_nullishCoalesce(t, () => ("That should not ever happened, right?")))},lo= exports.assertThrowsAsync =async(t,e)=>{try{throw await t(),new p("Function didn't throw expected error")}catch(r){let n=r;return e&&s(e(n)),n}},co= exports.assertThrows =(t,e)=>{try{throw t(),new p("Function didn't throw expected error")}catch(r){let n=r;return e&&s(e(n)),n}},uo= exports.assertRejects =async(t,e)=>{try{throw await t,new p("Function didn't throw expected error")}catch(r){if(!e)return;e instanceof Error?Ke(r,e):s(e(r))}},ve= exports.assertMatches =(t,e,r)=>{if(!ye(t,e))throw new p(_nullishCoalesce(r, () => (`subObj:
-${c.stringify(e)}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AssertionError: () => AssertionError,
+  BinaryJsonDecoder: () => BinaryJsonDecoder,
+  CaughtUpTransformStream: () => CaughtUpTransformStream,
+  CommandHandler: () => CommandHandler,
+  CommandHandlerStreamVersionConflictRetryOptions: () => CommandHandlerStreamVersionConflictRetryOptions,
+  CompositeDecoder: () => CompositeDecoder,
+  ConcurrencyError: () => ConcurrencyError,
+  DeciderCommandHandler: () => DeciderCommandHandler,
+  DeciderSpecification: () => DeciderSpecification,
+  DefaultDecoder: () => DefaultDecoder,
+  EmmettError: () => EmmettError,
+  ExpectedVersionConflictError: () => ExpectedVersionConflictError,
+  GlobalStreamCaughtUpType: () => GlobalStreamCaughtUpType,
+  IllegalStateError: () => IllegalStateError,
+  InMemoryEventStoreDefaultStreamVersion: () => InMemoryEventStoreDefaultStreamVersion,
+  JSONParser: () => JSONParser,
+  JsonDecoder: () => JsonDecoder,
+  NO_CONCURRENCY_CHECK: () => NO_CONCURRENCY_CHECK,
+  NoRetries: () => NoRetries,
+  NotFoundError: () => NotFoundError,
+  ObjectDecoder: () => ObjectDecoder,
+  ParseError: () => ParseError,
+  STREAM_DOES_NOT_EXIST: () => STREAM_DOES_NOT_EXIST,
+  STREAM_EXISTS: () => STREAM_EXISTS,
+  StreamingCoordinator: () => StreamingCoordinator,
+  StringDecoder: () => StringDecoder,
+  ValidationError: () => ValidationError,
+  ValidationErrors: () => ValidationErrors,
+  WrapEventStore: () => WrapEventStore,
+  accept: () => accept,
+  argMatches: () => argMatches,
+  argValue: () => argValue,
+  assertDeepEqual: () => assertDeepEqual,
+  assertEqual: () => assertEqual,
+  assertExpectedVersionMatchesCurrent: () => assertExpectedVersionMatchesCurrent,
+  assertFails: () => assertFails,
+  assertFalse: () => assertFalse,
+  assertIsNotNull: () => assertIsNotNull,
+  assertIsNull: () => assertIsNull,
+  assertMatches: () => assertMatches,
+  assertNotDeepEqual: () => assertNotDeepEqual,
+  assertNotEmptyString: () => assertNotEmptyString,
+  assertNotEqual: () => assertNotEqual,
+  assertOk: () => assertOk,
+  assertPositiveNumber: () => assertPositiveNumber,
+  assertRejects: () => assertRejects,
+  assertThat: () => assertThat,
+  assertThatArray: () => assertThatArray,
+  assertThrows: () => assertThrows,
+  assertThrowsAsync: () => assertThrowsAsync,
+  assertTrue: () => assertTrue,
+  assertUnsignedBigInt: () => assertUnsignedBigInt,
+  asyncProjections: () => asyncProjections,
+  asyncRetry: () => asyncRetry,
+  canCreateEventStoreSession: () => canCreateEventStoreSession,
+  caughtUpEventFrom: () => caughtUpEventFrom,
+  collect: () => collect,
+  command: () => command,
+  complete: () => complete,
+  concatUint8Arrays: () => concatUint8Arrays,
+  deepEquals: () => deepEquals,
+  error: () => error,
+  event: () => event,
+  formatDateToUtcYYYYMMDD: () => formatDateToUtcYYYYMMDD,
+  getInMemoryEventStore: () => getInMemoryEventStore,
+  getInMemoryMessageBus: () => getInMemoryMessageBus,
+  globalStreamCaughtUp: () => globalStreamCaughtUp,
+  ignore: () => ignore,
+  inlineProjections: () => inlineProjections,
+  isEquatable: () => isEquatable,
+  isErrorConstructor: () => isErrorConstructor,
+  isExpectedVersionConflictError: () => isExpectedVersionConflictError,
+  isGlobalStreamCaughtUp: () => isGlobalStreamCaughtUp,
+  isNotInternalEvent: () => isNotInternalEvent,
+  isNumber: () => isNumber,
+  isPluginConfig: () => isPluginConfig,
+  isString: () => isString,
+  isSubscriptionEvent: () => isSubscriptionEvent,
+  isSubset: () => isSubset,
+  isValidYYYYMMDD: () => isValidYYYYMMDD,
+  matchesExpectedVersion: () => matchesExpectedVersion,
+  merge: () => merge,
+  nulloSessionFactory: () => nulloSessionFactory,
+  parseDateFromUtcYYYYMMDD: () => parseDateFromUtcYYYYMMDD,
+  projection: () => projection,
+  projections: () => projections,
+  publish: () => publish,
+  reply: () => reply,
+  restream: () => restream,
+  schedule: () => schedule,
+  send: () => send,
+  streamGenerators: () => streamGenerators,
+  streamTrackingGlobalPosition: () => streamTrackingGlobalPosition,
+  streamTransformations: () => streamTransformations,
+  sum: () => sum,
+  verifyThat: () => verifyThat
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/eventStore/eventStore.ts
+var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+var nulloSessionFactory = (eventStore) => ({
+  withSession: (callback) => {
+    const nulloSession = {
+      eventStore,
+      close: () => Promise.resolve()
+    };
+    return callback(nulloSession);
+  }
+});
+
+// src/typing/command.ts
+var command = (type, data, metadata) => {
+  return {
+    type,
+    data,
+    metadata
+  };
+};
+
+// src/typing/event.ts
+var event = (type, data, metadata) => {
+  return {
+    type,
+    data,
+    metadata
+  };
+};
+
+// src/typing/workflow.ts
+var reply = (message) => {
+  return {
+    kind: "Reply",
+    message
+  };
+};
+var send = (message) => {
+  return {
+    kind: "Send",
+    message
+  };
+};
+var publish = (message) => {
+  return {
+    kind: "Publish",
+    message
+  };
+};
+var schedule = (message, when) => {
+  return {
+    kind: "Schedule",
+    message,
+    when
+  };
+};
+var complete = () => {
+  return {
+    kind: "Complete"
+  };
+};
+var ignore = (reason) => {
+  return {
+    kind: "Ignore",
+    reason
+  };
+};
+var error = (reason) => {
+  return {
+    kind: "Error",
+    reason
+  };
+};
+var accept = () => {
+  return { kind: "Accept" };
+};
+
+// src/eventStore/events/index.ts
+var GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
+var isGlobalStreamCaughtUp = (event2) => event2.type === GlobalStreamCaughtUpType;
+var caughtUpEventFrom = (position) => (event2) => event2.type === GlobalStreamCaughtUpType && event2.metadata?.globalPosition >= position;
+var globalStreamCaughtUp = (data) => event(GlobalStreamCaughtUpType, data, {
+  globalPosition: data.globalPosition
+});
+var isSubscriptionEvent = (event2) => isGlobalStreamCaughtUp(event2);
+var isNotInternalEvent = (event2) => !isGlobalStreamCaughtUp(event2);
+
+// src/validation/dates.ts
+var formatDateToUtcYYYYMMDD = (date) => {
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "UTC",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  return formatter.format(date);
+};
+var isValidYYYYMMDD = (dateString) => {
+  const regex = /^\d{4}-\d{2}-\d{2}$/;
+  return regex.test(dateString);
+};
+var parseDateFromUtcYYYYMMDD = (dateString) => {
+  const date = /* @__PURE__ */ new Date(dateString + "T00:00:00Z");
+  if (!isValidYYYYMMDD(dateString)) {
+    throw new ValidationError("Invalid date format, must be yyyy-mm-dd");
+  }
+  if (isNaN(date.getTime())) {
+    throw new ValidationError("Invalid date format");
+  }
+  return date;
+};
+
+// src/validation/index.ts
+var ValidationErrors = /* @__PURE__ */ ((ValidationErrors2) => {
+  ValidationErrors2["NOT_A_NONEMPTY_STRING"] = "NOT_A_NONEMPTY_STRING";
+  ValidationErrors2["NOT_A_POSITIVE_NUMBER"] = "NOT_A_POSITIVE_NUMBER";
+  ValidationErrors2["NOT_AN_UNSIGNED_BIGINT"] = "NOT_AN_UNSIGNED_BIGINT";
+  return ValidationErrors2;
+})(ValidationErrors || {});
+var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var assertNotEmptyString = (value) => {
+  if (!isString(value) || value.length === 0) {
+    throw new ValidationError("NOT_A_NONEMPTY_STRING" /* NOT_A_NONEMPTY_STRING */);
+  }
+  return value;
+};
+var assertPositiveNumber = (value) => {
+  if (!isNumber(value) || value <= 0) {
+    throw new ValidationError("NOT_A_POSITIVE_NUMBER" /* NOT_A_POSITIVE_NUMBER */);
+  }
+  return value;
+};
+var assertUnsignedBigInt = (value) => {
+  const number = BigInt(value);
+  if (number < 0) {
+    throw new ValidationError("NOT_AN_UNSIGNED_BIGINT" /* NOT_AN_UNSIGNED_BIGINT */);
+  }
+  return number;
+};
+
+// src/errors/index.ts
+var isErrorConstructor = (expect) => {
+  return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  expect.prototype.constructor === expect;
+};
+var EmmettError = class _EmmettError extends Error {
+  errorCode;
+  constructor(options) {
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
+    super(message);
+    this.errorCode = errorCode;
+    Object.setPrototypeOf(this, _EmmettError.prototype);
+  }
+};
+var ConcurrencyError = class _ConcurrencyError extends EmmettError {
+  constructor(current, expected, message) {
+    super({
+      errorCode: 412,
+      message: message ?? `Expected version ${expected.toString()} does not match current ${current?.toString()}`
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends EmmettError {
+  constructor(message) {
+    super({
+      errorCode: 400,
+      message: message ?? `Validation Error ocurred during Emmett processing`
+    });
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var IllegalStateError = class _IllegalStateError extends EmmettError {
+  constructor(message) {
+    super({
+      errorCode: 403,
+      message: message ?? `Illegal State ocurred during Emmett processing`
+    });
+    Object.setPrototypeOf(this, _IllegalStateError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends EmmettError {
+  constructor(options) {
+    super({
+      errorCode: 404,
+      message: options?.message ?? (options?.id ? options.type ? `${options.type} with ${options.id} was not found during Emmett processing` : `State with ${options.id} was not found during Emmett processing` : options?.type ? `${options.type} was not found during Emmett processing` : "State was not found during Emmett processing")
+    });
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+
+// src/eventStore/expectedVersion.ts
+var STREAM_EXISTS = "STREAM_EXISTS";
+var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var matchesExpectedVersion = (current, expected, defaultVersion) => {
+  if (expected === NO_CONCURRENCY_CHECK) return true;
+  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
+  if (expected == STREAM_EXISTS) return current !== defaultVersion;
+  return current === expected;
+};
+var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+  expected ??= NO_CONCURRENCY_CHECK;
+  if (!matchesExpectedVersion(current, expected, defaultVersion))
+    throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
+  constructor(current, expected) {
+    super(current?.toString(), expected?.toString());
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
+  }
+};
+var isExpectedVersionConflictError = (error2) => error2 instanceof ExpectedVersionConflictError;
+
+// src/eventStore/inMemoryEventStore.ts
+var import_uuid3 = require("uuid");
+
+// src/eventStore/subscriptions/caughtUpTransformStream.ts
+var import_web_streams_polyfill = require("web-streams-polyfill");
+var streamTrackingGlobalPosition = (currentEvents) => new CaughtUpTransformStream(currentEvents);
+var CaughtUpTransformStream = class extends import_web_streams_polyfill.TransformStream {
+  _currentPosition;
+  _logPosition;
+  constructor(events) {
+    super({
+      start: (controller) => {
+        let globalPosition = 0n;
+        for (const event2 of events) {
+          controller.enqueue(event2);
+          globalPosition = event2.metadata.globalPosition;
+        }
+        controller.enqueue(globalStreamCaughtUp({ globalPosition }));
+      },
+      transform: (event2, controller) => {
+        this._currentPosition = event2.metadata.globalPosition;
+        controller.enqueue(event2);
+        if (this._currentPosition < this._logPosition) return;
+        controller.enqueue(
+          globalStreamCaughtUp({ globalPosition: this._currentPosition })
+        );
+      }
+    });
+    this._currentPosition = this._logPosition = events.length > 0 ? events[events.length - 1].metadata.globalPosition : 0n;
+  }
+  set logPosition(value) {
+    this._logPosition = value;
+  }
+};
+
+// src/eventStore/subscriptions/streamingCoordinator.ts
+var import_uuid2 = require("uuid");
+
+// src/streaming/transformations/notifyAboutNoActiveReaders.ts
+var import_uuid = require("uuid");
+var import_web_streams_polyfill2 = require("web-streams-polyfill");
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = class extends import_web_streams_polyfill2.TransformStream {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = options?.streamId ?? (0, import_uuid.v4)();
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(options?.intervalCheckInMs ?? 20);
+  }
+  checkInterval = null;
+  streamId;
+  _isStopped = false;
+  get hasActiveSubscribers() {
+    return !this._isStopped;
+  }
+  startChecking(interval) {
+    this.checkInterval = setInterval(() => {
+      this.checkNoActiveReader();
+    }, interval);
+  }
+  stopChecking() {
+    if (!this.checkInterval) return;
+    clearInterval(this.checkInterval);
+    this.checkInterval = null;
+    this._isStopped = true;
+    this.onNoActiveReaderCallback(this);
+  }
+  checkNoActiveReader() {
+    if (!this.readable.locked && !this._isStopped) {
+      this.stopChecking();
+    }
+  }
+};
+
+// src/streaming/writers/writeToStream.ts
+var writeToStream = async (stream, items) => {
+  if (stream.writable.locked) return false;
+  const writer = stream.writable.getWriter();
+  await writer.ready;
+  if (!stream.readable.locked) return false;
+  try {
+    for (const item of items) {
+      await writer.write(item);
+    }
+  } catch (error2) {
+    console.log(error2);
+  } finally {
+    await writer.close();
+  }
+  return true;
+};
+
+// src/eventStore/subscriptions/streamingCoordinator.ts
+var StreamingCoordinator = () => {
+  const allEvents = [];
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    notify: async (events) => {
+      if (events.length === 0) return;
+      allEvents.push(...events);
+      for (const listener of listeners.values()) {
+        listener.logPosition = events[events.length - 1].metadata.globalPosition;
+        await writeToStream(listener, events);
+      }
+    },
+    stream: () => {
+      const streamId = (0, import_uuid2.v4)();
+      const transformStream = streamTrackingGlobalPosition(allEvents);
+      listeners.set(streamId, transformStream);
+      return transformStream.readable.pipeThrough(
+        notifyAboutNoActiveReadersStream(
+          (stream) => {
+            if (listeners.has(stream.streamId))
+              listeners.delete(stream.streamId);
+          },
+          { streamId }
+        )
+      );
+    }
+  };
+};
+
+// src/eventStore/inMemoryEventStore.ts
+var InMemoryEventStoreDefaultStreamVersion = 0n;
+var getInMemoryEventStore = () => {
+  const streams = /* @__PURE__ */ new Map();
+  const streamingCoordinator = StreamingCoordinator();
+  const getAllEventsCount = () => {
+    return Array.from(streams.values()).map((s) => s.length).reduce((p, c) => p + c, 0);
+  };
+  return {
+    async aggregateStream(streamName, options) {
+      const { evolve, initialState, read } = options;
+      const result = await this.readStream(streamName, read);
+      const events = result?.events ?? [];
+      return {
+        currentStreamVersion: BigInt(events.length),
+        state: events.reduce(evolve, initialState()),
+        streamExists: result.streamExists
+      };
+    },
+    readStream: (streamName, options) => {
+      const events = streams.get(streamName);
+      const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        options?.expectedStreamVersion,
+        InMemoryEventStoreDefaultStreamVersion
+      );
+      const from = Number(options && "from" in options ? options.from : 0);
+      const to = Number(
+        options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : events?.length ?? 1
+      );
+      const resultEvents = events !== void 0 && events.length > 0 ? events.map(
+        (e) => e
+      ).slice(from, to) : [];
+      const result = {
+        currentStreamVersion,
+        events: resultEvents,
+        streamExists: events !== void 0 && events.length > 0
+      };
+      return Promise.resolve(result);
+    },
+    appendToStream: async (streamName, events, options) => {
+      const currentEvents = streams.get(streamName) ?? [];
+      const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        options?.expectedStreamVersion,
+        InMemoryEventStoreDefaultStreamVersion
+      );
+      const newEvents = events.map((event2, index) => {
+        return {
+          ...event2,
+          metadata: {
+            ...event2.metadata ?? {},
+            streamName,
+            eventId: (0, import_uuid3.v4)(),
+            streamPosition: BigInt(currentEvents.length + index + 1),
+            globalPosition: BigInt(getAllEventsCount() + index + 1)
+          }
+        };
+      });
+      const positionOfLastEventInTheStream = BigInt(
+        newEvents.slice(-1)[0].metadata.streamPosition
+      );
+      streams.set(streamName, [...currentEvents, ...newEvents]);
+      await streamingCoordinator.notify(newEvents);
+      const result = {
+        nextExpectedStreamVersion: positionOfLastEventInTheStream,
+        createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
+      };
+      return result;
+    }
+    //streamEvents: streamingCoordinator.stream,
+  };
+};
+
+// src/utils/deepEquals.ts
+var deepEquals = (left, right) => {
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return left === right;
+  }
+  if (Array.isArray(right)) return false;
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+    return false;
+  for (const key in left) {
+    if (left[key] instanceof Function && right[key] instanceof Function)
+      continue;
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var isEquatable = (left) => {
+  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+
+// src/utils/iterators.ts
+var sum = (iterator) => {
+  let value, done, sum2 = 0;
+  do {
+    ({ value, done } = iterator.next());
+    sum2 += value || 0;
+  } while (!done);
+  return sum2;
+};
+
+// src/utils/merge.ts
+var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
+  let wasFound = false;
+  const result = array.map((p) => {
+    if (!where(p)) return p;
+    wasFound = true;
+    return onExisting(p);
+  }).filter((p) => p !== void 0).map((p) => {
+    if (!p) throw Error("That should not happen");
+    return p;
+  });
+  if (!wasFound) {
+    const result2 = onNotFound();
+    if (result2 !== void 0) return [...array, item];
+  }
+  return result;
+};
+
+// src/utils/retry.ts
+var import_async_retry = __toESM(require("async-retry"), 1);
+var NoRetries = { retries: 0 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return (0, import_async_retry.default)(
+    async (bail) => {
+      try {
+        return await fn();
+      } catch (error2) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    opts ?? { retries: 0 }
+  );
+};
+
+// src/commandHandling/handleCommand.ts
+var CommandHandlerStreamVersionConflictRetryOptions = {
+  retries: 3,
+  minTimeout: 100,
+  factor: 1.5,
+  shouldRetryError: isExpectedVersionConflictError
+};
+var fromCommandHandlerRetryOptions = (retryOptions) => {
+  if (retryOptions === void 0) return NoRetries;
+  if ("onVersionConflict" in retryOptions) {
+    if (typeof retryOptions.onVersionConflict === "boolean")
+      return CommandHandlerStreamVersionConflictRetryOptions;
+    else if (typeof retryOptions.onVersionConflict === "number")
+      return {
+        ...CommandHandlerStreamVersionConflictRetryOptions,
+        retries: retryOptions.onVersionConflict
+      };
+    else return retryOptions.onVersionConflict;
+  }
+  return retryOptions;
+};
+var CommandHandler = (options) => async (store, id, handle, handleOptions) => asyncRetry(
+  async () => {
+    const result = await withSession(store, async ({ eventStore }) => {
+      const { evolve, initialState } = options;
+      const mapToStreamId = options.mapToStreamId ?? ((id2) => id2);
+      const streamName = mapToStreamId(id);
+      const aggregationResult = await eventStore.aggregateStream(streamName, {
+        evolve,
+        initialState,
+        read: {
+          // expected stream version is passed to fail fast
+          // if stream is in the wrong state
+          expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+        }
+      });
+      const state = aggregationResult.state;
+      const currentStreamVersion = aggregationResult.currentStreamVersion;
+      const result2 = await handle(state);
+      const newEvents = Array.isArray(result2) ? result2 : [result2];
+      if (newEvents.length === 0) {
+        return {
+          newEvents: [],
+          newState: state,
+          nextExpectedStreamVersion: currentStreamVersion,
+          createdNewStream: false
+        };
+      }
+      const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST);
+      const appendResult = await eventStore.appendToStream(
+        streamName,
+        newEvents,
+        {
+          ...handleOptions,
+          expectedStreamVersion
+        }
+      );
+      return {
+        ...appendResult,
+        newEvents,
+        newState: newEvents.reduce(evolve, state)
+      };
+    });
+    return result;
+  },
+  fromCommandHandlerRetryOptions(
+    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
+  )
+);
+var withSession = (eventStore, callback) => {
+  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
+  return sessionFactory.withSession(callback);
+};
+
+// src/commandHandling/handleCommandWithDecider.ts
+var DeciderCommandHandler = (options) => async (eventStore, id, command2, handleOptions) => {
+  const { decide, ...rest } = options;
+  return CommandHandler(rest)(
+    eventStore,
+    id,
+    (state) => decide(command2, state),
+    handleOptions
+  );
+};
+
+// src/config/plugins/index.ts
+var import_commander = require("commander");
+var isPluginConfig = (plugin) => plugin !== void 0 && (typeof plugin === "string" || "name" in plugin && plugin.name !== void 0 && typeof plugin.name === "string");
+
+// src/messageBus/index.ts
+var getInMemoryMessageBus = () => {
+  const allHandlers = /* @__PURE__ */ new Map();
+  let pendingMessages = [];
+  return {
+    send: async (command2) => {
+      const handlers = allHandlers.get(command2.type);
+      if (handlers === void 0 || handlers.length === 0)
+        throw new EmmettError(
+          `No handler registered for command ${command2.type}!`
+        );
+      const commandHandler = handlers[0];
+      await commandHandler(command2);
+    },
+    publish: async (event2) => {
+      const handlers = allHandlers.get(event2.type) ?? [];
+      for (const handler of handlers) {
+        const eventHandler = handler;
+        await eventHandler(event2);
+      }
+    },
+    schedule: (message, when) => {
+      pendingMessages = [...pendingMessages, { message, options: when }];
+    },
+    handle: (commandHandler, ...commandTypes) => {
+      const alreadyRegistered = [...allHandlers.keys()].filter(
+        (registered) => commandTypes.includes(registered)
+      );
+      if (alreadyRegistered.length > 0)
+        throw new EmmettError(
+          `Cannot register handler for commands ${alreadyRegistered.join(", ")} as they're already registered!`
+        );
+      for (const commandType of commandTypes) {
+        allHandlers.set(commandType, [commandHandler]);
+      }
+    },
+    subscribe(eventHandler, ...eventTypes) {
+      for (const eventType of eventTypes) {
+        if (!allHandlers.has(eventType)) allHandlers.set(eventType, []);
+        allHandlers.set(eventType, [
+          ...allHandlers.get(eventType) ?? [],
+          eventHandler
+        ]);
+      }
+    },
+    dequeue: () => {
+      const pending = pendingMessages;
+      pendingMessages = [];
+      return pending;
+    }
+  };
+};
+
+// src/projections/index.ts
+var projection = (definition) => definition;
+var inlineProjections = (definitions) => definitions.map((projection2) => ({ type: "inline", projection: projection2 }));
+var asyncProjections = (definitions) => definitions.map((projection2) => ({ type: "async", projection: projection2 }));
+var projections = {
+  inline: inlineProjections,
+  async: asyncProjections
+};
+
+// src/serialization/json/JSONParser.ts
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      options?.map ? options.map(value) : value,
+      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+  },
+  parse: (text, options) => {
+    const parsed = JSON.parse(text, options?.reviver);
+    if (options?.typeCheck && !options?.typeCheck(parsed))
+      throw new ParseError(text);
+    return options?.map ? options.map(parsed) : parsed;
+  }
+};
+
+// src/streaming/binaryArrays.ts
+var concatUint8Arrays = (chunks) => {
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+};
+
+// src/streaming/collectors/collect.ts
+var collect = async (stream) => {
+  const results = [];
+  for await (const value of stream) {
+    results.push(value);
+  }
+  return results;
+};
+
+// src/streaming/decoders/binary.ts
+var BinaryJsonDecoder = class {
+  buffer = [];
+  addToBuffer(data) {
+    this.buffer.push(data);
+  }
+  clearBuffer() {
+    this.buffer = [];
+  }
+  hasCompleteMessage() {
+    const combined = concatUint8Arrays(this.buffer);
+    const text = new TextDecoder().decode(combined);
+    return text.includes("\n");
+  }
+  decode() {
+    if (!this.hasCompleteMessage()) {
+      return null;
+    }
+    const combined = concatUint8Arrays(this.buffer);
+    const text = new TextDecoder().decode(combined);
+    const delimiterIndex = text.indexOf("\n");
+    if (delimiterIndex === -1) {
+      return null;
+    }
+    const jsonString = text.slice(0, delimiterIndex);
+    const remaining = new Uint8Array(combined.buffer, delimiterIndex + 1);
+    this.buffer = remaining.byteLength > 0 ? [remaining] : [];
+    return JSON.parse(jsonString);
+  }
+};
+
+// src/streaming/decoders/string.ts
+var StringDecoder = class {
+  constructor(transform) {
+    this.transform = transform;
+    this.transform = transform;
+  }
+  buffer = [];
+  addToBuffer(data) {
+    this.buffer.push(data);
+  }
+  clearBuffer() {
+    this.buffer = [];
+  }
+  hasCompleteMessage() {
+    return this.buffer.some((chunk) => chunk.includes("\n"));
+  }
+  decode() {
+    const completeString = this.buffer.join("");
+    if (!this.hasCompleteMessage()) {
+      if (completeString.trim().length > 0) {
+        throw new Error("Unterminated string in JSON at position");
+      }
+      return null;
+    }
+    const delimiterIndex = completeString.indexOf("\n");
+    const message = completeString.slice(0, delimiterIndex).trim();
+    this.buffer = [completeString.slice(delimiterIndex + 1)];
+    return this.transform(message);
+  }
+};
+
+// src/streaming/decoders/json.ts
+var JsonDecoder = class extends StringDecoder {
+  constructor() {
+    super((jsonString) => JSON.parse(jsonString));
+  }
+};
+
+// src/streaming/decoders/object.ts
+var ObjectDecoder = class {
+  buffer = null;
+  addToBuffer(data) {
+    this.buffer = data;
+  }
+  clearBuffer() {
+    this.buffer = null;
+  }
+  hasCompleteMessage() {
+    return this.buffer !== null;
+  }
+  decode() {
+    if (!this.hasCompleteMessage() || !this.buffer) {
+      return null;
+    }
+    const data = this.buffer;
+    this.clearBuffer();
+    return data;
+  }
+};
+
+// src/streaming/decoders/composite.ts
+var CompositeDecoder = class {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  decoderFor(data) {
+    const decoder = this.decoders.find((d) => d[0](data));
+    if (!decoder) return null;
+    return decoder[1];
+  }
+  addToBuffer(data) {
+    this.decoderFor(data)?.addToBuffer(data);
+  }
+  clearBuffer() {
+    for (const decoder of this.decoders.map((d) => d[1])) {
+      decoder.clearBuffer();
+    }
+  }
+  hasCompleteMessage() {
+    return this.decoders.some((d) => d[1].hasCompleteMessage());
+  }
+  decode() {
+    const decoder = this.decoders.map((d) => d[1]).find((d) => d.hasCompleteMessage());
+    return decoder?.decode() ?? null;
+  }
+};
+var DefaultDecoder = class extends CompositeDecoder {
+  constructor() {
+    super([
+      [(data) => typeof data === "string", new JsonDecoder()],
+      [(data) => data instanceof Uint8Array, new BinaryJsonDecoder()],
+      [(data) => typeof data === "object", new ObjectDecoder()]
+    ]);
+  }
+};
+
+// src/streaming/generators/fromArray.ts
+var import_web_streams_polyfill3 = require("web-streams-polyfill");
+var fromArray = (chunks) => new import_web_streams_polyfill3.ReadableStream({
+  start(controller) {
+    for (const chunk of chunks) controller.enqueue(chunk);
+    controller.close();
+  }
+});
+
+// src/streaming/generators/index.ts
+var streamGenerators = { fromArray };
+
+// src/streaming/restream.ts
+var import_web_streams_polyfill13 = require("web-streams-polyfill");
+
+// src/streaming/transformations/filter.ts
+var import_web_streams_polyfill4 = require("web-streams-polyfill");
+var filter = (filter2) => new import_web_streams_polyfill4.TransformStream({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+
+// src/streaming/transformations/map.ts
+var import_web_streams_polyfill5 = require("web-streams-polyfill");
+var map = (map2) => new import_web_streams_polyfill5.TransformStream({
+  transform(chunk, controller) {
+    controller.enqueue(map2(chunk));
+  }
+});
+
+// src/streaming/transformations/reduce.ts
+var import_web_streams_polyfill6 = require("web-streams-polyfill");
+var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
+var ReduceTransformStream = class extends import_web_streams_polyfill6.TransformStream {
+  accumulator;
+  reducer;
+  constructor(reducer, initialValue) {
+    super({
+      transform: (chunk) => {
+        this.accumulator = this.reducer(this.accumulator, chunk);
+      },
+      flush: (controller) => {
+        controller.enqueue(this.accumulator);
+        controller.terminate();
+      }
+    });
+    this.accumulator = initialValue;
+    this.reducer = reducer;
+  }
+};
+
+// src/streaming/transformations/retry.ts
+var import_web_streams_polyfill7 = require("web-streams-polyfill");
+var retryStream = (createSourceStream, handleChunk2, retryOptions = { forever: true, minTimeout: 25 }) => new import_web_streams_polyfill7.TransformStream({
+  start(controller) {
+    asyncRetry(
+      () => onRestream(createSourceStream, handleChunk2, controller),
+      retryOptions
+    ).catch((error2) => {
+      controller.error(error2);
+    });
+  }
+});
+var onRestream = async (createSourceStream, handleChunk2, controller) => {
+  const sourceStream = createSourceStream();
+  const reader = sourceStream.getReader();
+  try {
+    let done;
+    do {
+      const result = await reader.read();
+      done = result.done;
+      await handleChunk2(result, controller);
+      if (done) {
+        controller.terminate();
+      }
+    } while (!done);
+  } finally {
+    reader.releaseLock();
+  }
+};
+
+// src/streaming/transformations/skip.ts
+var import_web_streams_polyfill8 = require("web-streams-polyfill");
+var skip = (limit) => new SkipTransformStream(limit);
+var SkipTransformStream = class extends import_web_streams_polyfill8.TransformStream {
+  count = 0;
+  skip;
+  constructor(skip2) {
+    super({
+      transform: (chunk, controller) => {
+        this.count++;
+        if (this.count > this.skip) {
+          controller.enqueue(chunk);
+        }
+      }
+    });
+    this.skip = skip2;
+  }
+};
+
+// src/streaming/transformations/stopAfter.ts
+var import_web_streams_polyfill9 = require("web-streams-polyfill");
+var stopAfter = (stopCondition) => new import_web_streams_polyfill9.TransformStream({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+
+// src/streaming/transformations/stopOn.ts
+var import_web_streams_polyfill10 = require("web-streams-polyfill");
+var stopOn = (stopCondition) => new import_web_streams_polyfill10.TransformStream({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+
+// src/streaming/transformations/take.ts
+var import_web_streams_polyfill11 = require("web-streams-polyfill");
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = class extends import_web_streams_polyfill11.TransformStream {
+  count = 0;
+  limit;
+  constructor(limit) {
+    super({
+      transform: (chunk, controller) => {
+        if (this.count < this.limit) {
+          this.count++;
+          controller.enqueue(chunk);
+        } else {
+          controller.terminate();
+        }
+      }
+    });
+    this.limit = limit;
+  }
+};
+
+// src/streaming/transformations/waitAtMost.ts
+var import_web_streams_polyfill12 = require("web-streams-polyfill");
+var waitAtMost = (waitTimeInMs) => new import_web_streams_polyfill12.TransformStream({
+  start(controller) {
+    const timeoutId = setTimeout(() => {
+      controller.terminate();
+    }, waitTimeInMs);
+    const originalTerminate = controller.terminate.bind(controller);
+    controller.terminate = () => {
+      clearTimeout(timeoutId);
+      originalTerminate();
+    };
+  },
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+  }
+});
+
+// src/streaming/transformations/index.ts
+var streamTransformations = {
+  filter,
+  take,
+  TakeTransformStream,
+  skip,
+  SkipTransformStream,
+  map,
+  notifyAboutNoActiveReadersStream,
+  NotifyAboutNoActiveReadersStream,
+  reduce,
+  ReduceTransformStream,
+  retry: retryStream,
+  stopAfter,
+  stopOn,
+  waitAtMost
+};
+
+// src/streaming/restream.ts
+var { retry: retry2 } = streamTransformations;
+var restream = (createSourceStream, transform = (source) => source, retryOptions = { forever: true, minTimeout: 25 }, decoder = new DefaultDecoder()) => retry2(createSourceStream, handleChunk(transform, decoder), retryOptions).readable;
+var handleChunk = (transform = (source) => source, decoder = new DefaultDecoder()) => (readResult, controller) => {
+  const { done: isDone, value } = readResult;
+  if (value) decoder.addToBuffer(value);
+  if (!isDone && !decoder.hasCompleteMessage()) return;
+  decodeAndTransform(decoder, transform, controller);
+};
+var decodeAndTransform = (decoder, transform, controller) => {
+  try {
+    const decoded = decoder.decode();
+    if (!decoded) return;
+    const transformed = transform(decoded);
+    controller.enqueue(transformed);
+  } catch (error2) {
+    controller.error(new Error(`Decoding error: ${error2?.toString()}`));
+  }
+};
+
+// src/testing/assertions.ts
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message) => {
+  throw new AssertionError(message ?? "That should not ever happened, right?");
+};
+var assertThrowsAsync = async (fun, errorCheck) => {
+  try {
+    await fun();
+    throw new AssertionError("Function didn't throw expected error");
+  } catch (error2) {
+    const typedError = error2;
+    if (errorCheck) assertTrue(errorCheck(typedError));
+    return typedError;
+  }
+};
+var assertThrows = (fun, errorCheck) => {
+  try {
+    fun();
+    throw new AssertionError("Function didn't throw expected error");
+  } catch (error2) {
+    const typedError = error2;
+    if (errorCheck) assertTrue(errorCheck(typedError));
+    return typedError;
+  }
+};
+var assertRejects = async (promise, errorCheck) => {
+  try {
+    await promise;
+    throw new AssertionError("Function didn't throw expected error");
+  } catch (error2) {
+    if (!errorCheck) return;
+    if (errorCheck instanceof Error) assertDeepEqual(error2, errorCheck);
+    else assertTrue(errorCheck(error2));
+  }
+};
+var assertMatches = (actual, expected, message) => {
+  if (!isSubset(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is not subset of
-${c.stringify(t)}`)))},Ke= exports.assertDeepEqual =(t,e,r)=>{if(!d(t,e))throw new p(_nullishCoalesce(r, () => (`subObj:
-${c.stringify(e)}
+${JSONParser.stringify(actual)}`
+    );
+};
+var assertDeepEqual = (actual, expected, message) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is not equal to
-${c.stringify(t)}`)))},fo= exports.assertNotDeepEqual =(t,e,r)=>{if(d(t,e))throw new p(_nullishCoalesce(r, () => (`subObj:
-${c.stringify(e)}
+${JSONParser.stringify(actual)}`
+    );
+};
+var assertNotDeepEqual = (actual, expected, message) => {
+  if (deepEquals(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is equals to
-${c.stringify(t)}`)))},yo= exports.assertThat =t=>({isEqualTo:e=>s(d(t,e))});function Xe(t,e){if(t)throw new p(_nullishCoalesce(e, () => ("Condition is false")))}function s(t,e){if(!t)throw new p(_nullishCoalesce(e, () => ("Condition is false")))}function U(t,e){if(!t)throw new p(_nullishCoalesce(e, () => ("Condition is not truthy")))}function u(t,e,r){if(t!==e)throw new p(`${_nullishCoalesce(r, () => ("Objects are not equal"))}:
-Expected: ${c.stringify(t)}
-Actual:${c.stringify(e)}`)}function Ee(t,e,r){if(t===e)throw new p(_nullishCoalesce(r, () => (`Objects are equal: ${c.stringify(t)}`)))}function vo(t){Ee(t,null),U(t)}function Eo(t){u(t,null)}var So=t=>e=>d(e,t),To= exports.argMatches =t=>e=>t(e);function xo(t){return{calledTimes:e=>{u(_optionalChain([t, 'access', _36 => _36.mock, 'optionalAccess', _37 => _37.calls, 'optionalAccess', _38 => _38.length]),e)},notCalled:()=>{u(_optionalChain([t, 'optionalAccess', _39 => _39.mock, 'optionalAccess', _40 => _40.calls, 'optionalAccess', _41 => _41.length]),0)},called:()=>{s(_optionalChain([t, 'access', _42 => _42.mock, 'optionalAccess', _43 => _43.calls, 'access', _44 => _44.length])!==void 0&&t.mock.calls.length>0)},calledWith:(...e)=>{s(_optionalChain([t, 'access', _45 => _45.mock, 'optionalAccess', _46 => _46.calls, 'access', _47 => _47.length])!==void 0&&t.mock.calls.length>=1&&t.mock.calls.some(r=>d(r.arguments,e)))},calledOnceWith:(...e)=>{s(_optionalChain([t, 'access', _48 => _48.mock, 'optionalAccess', _49 => _49.calls, 'access', _50 => _50.length])!==void 0&&t.mock.calls.length===1&&t.mock.calls.some(r=>d(r.arguments,e)))},calledWithArgumentMatching:(...e)=>{s(_optionalChain([t, 'access', _51 => _51.mock, 'optionalAccess', _52 => _52.calls, 'access', _53 => _53.length])!==void 0&&t.mock.calls.length>=1),s(_optionalChain([t, 'access', _54 => _54.mock, 'optionalAccess', _55 => _55.calls, 'access', _56 => _56.length])!==void 0&&t.mock.calls.length>=1&&t.mock.calls.some(r=>r.arguments&&r.arguments.length>=e.length&&e.every((n,o)=>n(r.arguments[o]))))},notCalledWithArgumentMatching:(...e)=>{Xe(_optionalChain([t, 'access', _57 => _57.mock, 'optionalAccess', _58 => _58.calls, 'access', _59 => _59.length])!==void 0&&t.mock.calls.length>=1&&t.mock.calls[0].arguments&&t.mock.calls[0].arguments.length>=e.length&&e.every((r,n)=>r(t.mock.calls[0].arguments[n])))}}}var go=t=>({isEmpty:()=>u(t.length,0),isNotEmpty:()=>Ee(t.length,0),hasSize:e=>u(t.length,e),containsElements:(...e)=>{s(e.every(r=>e.some(n=>d(r,n))))},containsExactlyInAnyOrder:(...e)=>{u(t.length,e.length),s(t.every(r=>e.some(n=>d(r,n))))},containsExactlyInAnyOrderElementsOf:e=>{u(t.length,e.length),s(t.every(r=>e.some(n=>d(r,n))))},containsExactlyElementsOf:e=>{u(t.length,e.length);for(let r=0;r<t.length;r++)s(d(t[r],e[r]))},containsExactly:e=>{u(t.length,1),s(d(t[0],e))},contains:e=>{s(t.some(r=>d(r,e)))},containsOnlyOnceElementsOf:e=>{s(e.map(r=>t.filter(n=>d(n,r)).length).filter(r=>r===1).length===e.length)},containsAnyOf:(...e)=>{s(t.some(r=>e.some(n=>d(r,n))))},allMatch:e=>{s(t.every(e))},anyMatches:e=>{s(t.some(e))},allMatchAsync:async e=>{for(let r of t)s(await e(r))}});var bo={for:t=>e=>({when:r=>{let n=()=>{let a=(Array.isArray(e)?e:[e]).reduce(t.evolve,t.initialState());return t.decide(r,a)};return{then:o=>{let a=n(),i=Array.isArray(a)?a:[a],m=Array.isArray(o)?o:[o];ve(i,m)},thenThrows:(...o)=>{try{throw n(),new p("Handler did not fail as expected")}catch(a){if(a instanceof p)throw a;if(o.length===0)return;if(!_chunkCJZAVRMTcjs.j.call(void 0, o[0])){s(o[0](a),`Error didn't match the error condition: ${_optionalChain([a, 'optionalAccess', _60 => _60.toString, 'call', _61 => _61()])}`);return}s(a instanceof o[0],`Caught error is not an instance of the expected type: ${_optionalChain([a, 'optionalAccess', _62 => _62.toString, 'call', _63 => _63()])}`),o[1]&&s(o[1](a),`Error didn't match the error condition: ${_optionalChain([a, 'optionalAccess', _64 => _64.toString, 'call', _65 => _65()])}`)}}}}})};var wo=t=>{let e=new Map;return{async aggregateStream(r,n){return t.aggregateStream(r,n)},readStream(r,n){return t.readStream(r,n)},appendToStream:async(r,n,o)=>{let a=await t.appendToStream(r,n,o),i=_nullishCoalesce(e.get(r), () => ([r,[]]));return e.set(r,[r,[...i[1],...n]]),a},appendedEvents:e,setup:async(r,n)=>t.appendToStream(r,n)}};exports.AssertionError = p; exports.BinaryJsonDecoder = M; exports.CaughtUpTransformStream = _; exports.CommandHandler = ne; exports.CommandHandlerStreamVersionConflictRetryOptions = re; exports.CompositeDecoder = q; exports.ConcurrencyError = _chunkCJZAVRMTcjs.l; exports.DeciderCommandHandler = Pr; exports.DeciderSpecification = bo; exports.DefaultDecoder = x; exports.EmmettError = _chunkCJZAVRMTcjs.k; exports.ExpectedVersionConflictError = b; exports.GlobalStreamCaughtUpType = H; exports.IllegalStateError = _chunkCJZAVRMTcjs.n; exports.InMemoryEventStoreDefaultStreamVersion = T; exports.JSONParser = c; exports.JsonDecoder = P; exports.NO_CONCURRENCY_CHECK = D; exports.NoRetries = te; exports.NotFoundError = _chunkCJZAVRMTcjs.o; exports.ObjectDecoder = k; exports.ParseError = W; exports.STREAM_DOES_NOT_EXIST = F; exports.STREAM_EXISTS = xe; exports.StreamingCoordinator = ee; exports.StringDecoder = V; exports.ValidationError = _chunkCJZAVRMTcjs.m; exports.ValidationErrors = _chunkCJZAVRMTcjs.d; exports.WrapEventStore = wo; exports.accept = xt; exports.argMatches = To; exports.argValue = So; exports.assertDeepEqual = Ke; exports.assertEqual = u; exports.assertExpectedVersionMatchesCurrent = N; exports.assertFails = po; exports.assertFalse = Xe; exports.assertIsNotNull = vo; exports.assertIsNull = Eo; exports.assertMatches = ve; exports.assertNotDeepEqual = fo; exports.assertNotEmptyString = _chunkCJZAVRMTcjs.g; exports.assertNotEqual = Ee; exports.assertOk = U; exports.assertPositiveNumber = _chunkCJZAVRMTcjs.h; exports.assertRejects = uo; exports.assertThat = yo; exports.assertThatArray = go; exports.assertThrows = co; exports.assertThrowsAsync = lo; exports.assertTrue = s; exports.assertUnsignedBigInt = _chunkCJZAVRMTcjs.i; exports.asyncProjections = ke; exports.asyncRetry = w; exports.canCreateEventStoreSession = K; exports.caughtUpEventFrom = Mt; exports.collect = Lr; exports.command = pt; exports.complete = Et; exports.concatUint8Arrays = G; exports.deepEquals = d; exports.error = Tt; exports.event = L; exports.formatDateToUtcYYYYMMDD = _chunkCJZAVRMTcjs.a; exports.getInMemoryEventStore = ir; exports.getInMemoryMessageBus = Nr; exports.globalStreamCaughtUp = j; exports.ignore = St; exports.inlineProjections = Pe; exports.isEquatable = Oe; exports.isErrorConstructor = _chunkCJZAVRMTcjs.j; exports.isExpectedVersionConflictError = z; exports.isGlobalStreamCaughtUp = Y; exports.isNotInternalEvent = Pt; exports.isNumber = _chunkCJZAVRMTcjs.e; exports.isPluginConfig = _chunkCJZAVRMTcjs.p; exports.isString = _chunkCJZAVRMTcjs.f; exports.isSubscriptionEvent = Vt; exports.isSubset = ye; exports.isValidYYYYMMDD = _chunkCJZAVRMTcjs.b; exports.matchesExpectedVersion = ge; exports.merge = Sr; exports.nulloSessionFactory = X; exports.parseDateFromUtcYYYYMMDD = _chunkCJZAVRMTcjs.c; exports.projection = Wr; exports.projections = Gr; exports.publish = yt; exports.reply = ut; exports.restream = Qn; exports.schedule = vt; exports.send = ft; exports.streamGenerators = En; exports.streamTrackingGlobalPosition = Q; exports.streamTransformations = fe; exports.sum = vr; exports.verifyThat = xo;
+${JSONParser.stringify(actual)}`
+    );
+};
+var assertThat = (item) => {
+  return {
+    isEqualTo: (other) => assertTrue(deepEquals(item, other))
+  };
+};
+function assertFalse(condition, message) {
+  if (condition) throw new AssertionError(message ?? `Condition is false`);
+}
+function assertTrue(condition, message) {
+  if (!condition) throw new AssertionError(message ?? `Condition is false`);
+}
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(message ?? `Condition is not truthy`);
+}
+function assertEqual(expected, actual, message) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${message ?? "Objects are not equal"}:
+Expected: ${JSONParser.stringify(expected)}
+Actual:${JSONParser.stringify(actual)}`
+    );
+}
+function assertNotEqual(obj, other, message) {
+  if (obj === other)
+    throw new AssertionError(
+      message ?? `Objects are equal: ${JSONParser.stringify(obj)}`
+    );
+}
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+function assertIsNull(result) {
+  assertEqual(result, null);
+}
+var argValue = (value) => (arg) => deepEquals(arg, value);
+var argMatches = (matches) => (arg) => matches(arg);
+function verifyThat(fn) {
+  return {
+    calledTimes: (times) => {
+      assertEqual(fn.mock?.calls?.length, times);
+    },
+    notCalled: () => {
+      assertEqual(fn?.mock?.calls?.length, 0);
+    },
+    called: () => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length > 0
+      );
+    },
+    calledWith: (...args) => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
+      );
+    },
+    calledOnceWith: (...args) => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length === 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
+      );
+    },
+    calledWithArgumentMatching: (...matches) => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1
+      );
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some(
+          (call) => call.arguments && call.arguments.length >= matches.length && matches.every((match, index) => match(call.arguments[index]))
+        )
+      );
+    },
+    notCalledWithArgumentMatching: (...matches) => {
+      assertFalse(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls[0].arguments && fn.mock.calls[0].arguments.length >= matches.length && matches.every(
+          (match, index) => match(fn.mock.calls[0].arguments[index])
+        )
+      );
+    }
+  };
+}
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(array.length, 0),
+    isNotEmpty: () => assertNotEqual(array.length, 0),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (...other) => {
+      assertTrue(other.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrder: (...other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrderElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      for (let i = 0; i < array.length; i++) {
+        assertTrue(deepEquals(array[i], other[i]));
+      }
+    },
+    containsExactly: (elem) => {
+      assertEqual(array.length, 1);
+      assertTrue(deepEquals(array[0], elem));
+    },
+    contains: (elem) => {
+      assertTrue(array.some((a) => deepEquals(a, elem)));
+    },
+    containsOnlyOnceElementsOf: (other) => {
+      assertTrue(
+        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
+      );
+    },
+    containsAnyOf: (...other) => {
+      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+    },
+    allMatch: (matches) => {
+      assertTrue(array.every(matches));
+    },
+    anyMatches: (matches) => {
+      assertTrue(array.some(matches));
+    },
+    allMatchAsync: async (matches) => {
+      for (const item of array) {
+        assertTrue(await matches(item));
+      }
+    }
+  };
+};
+
+// src/testing/deciderSpecification.ts
+var DeciderSpecification = {
+  for: (decider) => {
+    {
+      return (givenEvents) => {
+        return {
+          when: (command2) => {
+            const handle = () => {
+              const existingEvents = Array.isArray(givenEvents) ? givenEvents : [givenEvents];
+              const currentState = existingEvents.reduce(
+                decider.evolve,
+                decider.initialState()
+              );
+              return decider.decide(command2, currentState);
+            };
+            return {
+              then: (expectedEvents) => {
+                const resultEvents = handle();
+                const resultEventsArray = Array.isArray(resultEvents) ? resultEvents : [resultEvents];
+                const expectedEventsArray = Array.isArray(expectedEvents) ? expectedEvents : [expectedEvents];
+                assertMatches(resultEventsArray, expectedEventsArray);
+              },
+              thenThrows: (...args) => {
+                try {
+                  handle();
+                  throw new AssertionError("Handler did not fail as expected");
+                } catch (error2) {
+                  if (error2 instanceof AssertionError) throw error2;
+                  if (args.length === 0) return;
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
+                      args[0](error2),
+                      `Error didn't match the error condition: ${error2?.toString()}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error2 instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${error2?.toString()}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error2),
+                      `Error didn't match the error condition: ${error2?.toString()}`
+                    );
+                  }
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+
+// src/testing/wrapEventStore.ts
+var WrapEventStore = (eventStore) => {
+  const appendedEvents = /* @__PURE__ */ new Map();
+  return {
+    async aggregateStream(streamName, options) {
+      return eventStore.aggregateStream(streamName, options);
+    },
+    readStream(streamName, options) {
+      return eventStore.readStream(streamName, options);
+    },
+    appendToStream: async (streamName, events, options) => {
+      const result = await eventStore.appendToStream(
+        streamName,
+        events,
+        options
+      );
+      const currentStream = appendedEvents.get(streamName) ?? [streamName, []];
+      appendedEvents.set(streamName, [
+        streamName,
+        [...currentStream[1], ...events]
+      ]);
+      return result;
+    },
+    appendedEvents,
+    setup: async (streamName, events) => {
+      return eventStore.appendToStream(streamName, events);
+    }
+    // streamEvents: (): ReadableStream<
+    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
+    // > => {
+    //   return eventStore.streamEvents();
+    // },
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssertionError,
+  BinaryJsonDecoder,
+  CaughtUpTransformStream,
+  CommandHandler,
+  CommandHandlerStreamVersionConflictRetryOptions,
+  CompositeDecoder,
+  ConcurrencyError,
+  DeciderCommandHandler,
+  DeciderSpecification,
+  DefaultDecoder,
+  EmmettError,
+  ExpectedVersionConflictError,
+  GlobalStreamCaughtUpType,
+  IllegalStateError,
+  InMemoryEventStoreDefaultStreamVersion,
+  JSONParser,
+  JsonDecoder,
+  NO_CONCURRENCY_CHECK,
+  NoRetries,
+  NotFoundError,
+  ObjectDecoder,
+  ParseError,
+  STREAM_DOES_NOT_EXIST,
+  STREAM_EXISTS,
+  StreamingCoordinator,
+  StringDecoder,
+  ValidationError,
+  ValidationErrors,
+  WrapEventStore,
+  accept,
+  argMatches,
+  argValue,
+  assertDeepEqual,
+  assertEqual,
+  assertExpectedVersionMatchesCurrent,
+  assertFails,
+  assertFalse,
+  assertIsNotNull,
+  assertIsNull,
+  assertMatches,
+  assertNotDeepEqual,
+  assertNotEmptyString,
+  assertNotEqual,
+  assertOk,
+  assertPositiveNumber,
+  assertRejects,
+  assertThat,
+  assertThatArray,
+  assertThrows,
+  assertThrowsAsync,
+  assertTrue,
+  assertUnsignedBigInt,
+  asyncProjections,
+  asyncRetry,
+  canCreateEventStoreSession,
+  caughtUpEventFrom,
+  collect,
+  command,
+  complete,
+  concatUint8Arrays,
+  deepEquals,
+  error,
+  event,
+  formatDateToUtcYYYYMMDD,
+  getInMemoryEventStore,
+  getInMemoryMessageBus,
+  globalStreamCaughtUp,
+  ignore,
+  inlineProjections,
+  isEquatable,
+  isErrorConstructor,
+  isExpectedVersionConflictError,
+  isGlobalStreamCaughtUp,
+  isNotInternalEvent,
+  isNumber,
+  isPluginConfig,
+  isString,
+  isSubscriptionEvent,
+  isSubset,
+  isValidYYYYMMDD,
+  matchesExpectedVersion,
+  merge,
+  nulloSessionFactory,
+  parseDateFromUtcYYYYMMDD,
+  projection,
+  projections,
+  publish,
+  reply,
+  restream,
+  schedule,
+  send,
+  streamGenerators,
+  streamTrackingGlobalPosition,
+  streamTransformations,
+  sum,
+  verifyThat
+});
 //# sourceMappingURL=index.cjs.map