@moeru/eventa 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/eventa-DSnoBa1O.d.mts

@@ -0,0 +1,106 @@
+//#region src/eventa.d.ts
+declare function nanoid(): string;
+interface InvokeEventConstraint<_Req, _Res> {}
+type EventTag<Res, Req> = string & InvokeEventConstraint<Req, Res>;
+declare enum EventaType {
+  Event = "event",
+  MatchExpression = "matchExpression"
+}
+declare enum EventaFlowDirection {
+  Inbound = "inbound",
+  Outbound = "outbound"
+}
+interface DirectionalEventa<P, T = undefined> extends Eventa<P> {
+  _flowDirection: EventaFlowDirection | T;
+}
+interface InboundEventa<T> extends DirectionalEventa<T> {
+  _flowDirection: EventaFlowDirection.Inbound;
+}
+interface OutboundEventa<T> extends DirectionalEventa<T> {
+  _flowDirection: EventaFlowDirection.Outbound;
+}
+declare function defineInboundEventa<T>(id?: string): InboundEventa<T>;
+declare function defineOutboundEventa<T>(id?: string): OutboundEventa<T>;
+interface EventaLike<_P = undefined, T extends EventaType = EventaType> {
+  id: string;
+  type?: T;
+}
+interface Eventa<P = unknown, M = unknown, IM = unknown> extends EventaLike<P, EventaType.Event> {
+  body?: P;
+  /**
+   * Optional runtime metadata that can be attached to the eventa.
+   *
+   * NOTICE: for defineInvoke, and defineInvokeHandler, the metadata will be omitted
+   * for smaller chunk size, this means for metadata, the data contains will not be available in the defineInvokeHandler.
+   *
+   * This can be used for various purposes such as logging, debugging, or providing additional context about the eventa.
+   * Allowing the event handler to be able to access this metadata can enable more flexible and powerful event handling logic.
+   */
+  metadata?: M;
+  /**
+   * Optional runtime metadata that can be attached to the eventa when invoking it.
+   *
+   * Unlike the `metadata` field, the `invokeMetadata` is specifically designed to be used when invoking the eventa, and it
+   * will be available in the defineInvokeHandler.
+   *
+   * This allows for a clear separation between the metadata that describes the eventa itself and the metadata that is relevant
+   * to the invocation of the eventa, providing more flexibility in how metadata is used and accessed within the event
+   * handling system.
+   */
+  invokeMetadata?: IM;
+}
+type InferEventaPayload<E> = E extends Eventa<infer P> ? P : never;
+declare function defineEventa<P = undefined, M = undefined, IM = undefined>(id?: string, options?: {
+  /**
+   * Optionally inherit many properties from another parent eventa.
+   */
+  inheritFrom?: Eventa<P, M, IM>;
+  /**
+   * Optional runtime metadata that can be attached to the eventa.
+   *
+   * NOTICE: for defineInvoke, and defineInvokeHandler, the metadata will be omitted
+   * for smaller chunk size, this means for metadata, the data contains will not be available in the defineInvokeHandler.
+   *
+   * This can be used for various purposes such as logging, debugging, or providing additional context about the eventa.
+   * Allowing the event handler to be able to access this metadata can enable more flexible and powerful event handling logic.
+   */
+  metadata?: M;
+  /**
+   * Optional runtime metadata that can be attached to the eventa when invoking it.
+   *
+   * Unlike the `metadata` field, the `invokeMetadata` is specifically designed to be used when invoking the eventa, and it
+   * will be available in the defineInvokeHandler.
+   *
+   * This allows for a clear separation between the metadata that describes the eventa itself and the metadata that is relevant
+   * to the invocation of the eventa, providing more flexibility in how metadata is used and accessed within the event
+   * handling system.
+   */
+  invokeMetadata?: IM;
+}): Eventa<P, M, IM>;
+interface EventaMatchExpression<P = undefined> extends EventaLike<P, EventaType.MatchExpression> {
+  matcher?: (event: Eventa<P>) => boolean | Promise<boolean>;
+}
+declare function and<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P>;
+declare function or<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P>;
+/**
+ * Match by is powerful utility function that allows you to create a match expression based on various criteria
+ * when working with eventa (event system).
+ *
+ * Semantics like glob matching, RegExp, or even custom matcher function can be used to create complex match
+ * expressions that can be used to filter and handle events in a flexible way.
+ */
+declare function matchBy<P = undefined>(glob: string, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(options: {
+  ids: string[];
+}, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(options: {
+  eventa: Eventa<P>[];
+}, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(options: {
+  types: EventaType[];
+}, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(regExp: RegExp, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined, E extends Eventa<P> = Eventa<P>>(matcher: (event: E) => boolean | Promise<boolean>): EventaMatchExpression<P>;
+//#endregion
+export { nanoid as _, EventaLike as a, InboundEventa as c, OutboundEventa as d, and as f, matchBy as g, defineOutboundEventa as h, EventaFlowDirection as i, InferEventaPayload as l, defineInboundEventa as m, EventTag as n, EventaMatchExpression as o, defineEventa as p, Eventa as r, EventaType as s, DirectionalEventa as t, InvokeEventConstraint as u, or as v };
+//# sourceMappingURL=eventa-DSnoBa1O.d.mts.map

package/dist/{index-CI_gUGXg.d.mts → index-g6DulgOI.d.mts}

@@ -1,5 +1,5 @@
-import { n as EventTag, r as Eventa } from "./eventa-AJyw28P8.mjs";
-import { t as EventContext } from "./context-ZVv99bcM.mjs";
+import { n as EventTag, r as Eventa } from "./eventa-DSnoBa1O.mjs";
+import { t as EventContext } from "./context-BsqFeoer.mjs";
 
 //#region src/invoke-shared.d.ts
 declare enum InvokeEventType {
@@ -9,102 +9,114 @@ declare enum InvokeEventType {
   SendEventAbort = 3,
   ReceiveEvent = 4,
   ReceiveEventError = 5,
-  ReceiveEventStreamEnd = 6,
+  ReceiveEventStreamEnd = 6
 }
-interface SendEvent<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+interface SendEvent<Res, Req = undefined, _ = undefined, __ = undefined, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
-  content: Req$1;
+  content: Req;
   isReqStream?: boolean;
-}> {
-  id: EventTag<Res$1, Req$1>;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.SendEvent;
 }
-interface SendEventError<Res$1, Req$1 = undefined, _ = undefined, ReqErr$1 = Error> extends Eventa<{
+interface SendEventError<Res, Req = undefined, _ = undefined, ReqErr = Error, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
-  content: ReqErr$1;
-}> {
-  id: EventTag<Res$1, Req$1>;
+  content: ReqErr;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.SendEventError;
 }
-interface SendEventStreamEnd<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+interface SendEventStreamEnd<Res, Req = undefined, _ = undefined, __ = undefined, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
   content: undefined;
-}> {
-  id: EventTag<Res$1, Req$1>;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.SendEventStreamEnd;
 }
-interface SendEventAbort<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+interface SendEventAbort<Res, Req = undefined, _ = undefined, __ = undefined, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
   content?: unknown;
-}> {
-  id: EventTag<Res$1, Req$1>;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.SendEventAbort;
 }
-interface ReceiveEvent<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+interface ReceiveEvent<Res, Req = undefined, _ = undefined, __ = undefined, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
-  content: Res$1;
-}> {
-  id: EventTag<Res$1, Req$1>;
+  content: Res;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.ReceiveEvent;
 }
-interface ReceiveEventError<Res$1, Req$1 = undefined, ResErr$1 = undefined, _ = undefined> extends Eventa<{
+interface ReceiveEventError<Res, Req = undefined, ResErr = undefined, _ = undefined, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
   content: {
-    error: ResErr$1;
+    error: ResErr;
   };
-}> {
-  id: EventTag<Res$1, Req$1>;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.ReceiveEventError;
 }
-interface ReceiveEventStreamEnd<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+interface ReceiveEventStreamEnd<Res, Req = undefined, _ = undefined, __ = undefined, M = undefined, IM = undefined> extends Eventa<{
   invokeId: string;
   content: undefined;
-}> {
-  id: EventTag<Res$1, Req$1>;
+}, M, IM> {
+  id: EventTag<Res, Req>;
   invokeType: InvokeEventType.ReceiveEventStreamEnd;
 }
-interface InvokeEventa<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error> {
-  sendEvent: SendEvent<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  sendEventError: SendEventError<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  sendEventStreamEnd: SendEventStreamEnd<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  sendEventAbort: SendEventAbort<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  receiveEvent: ReceiveEvent<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  receiveEventError: ReceiveEventError<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  receiveEventStreamEnd: ReceiveEventStreamEnd<Res$1, Req$1, ResErr$1, ReqErr$1>;
+interface InvokeEventa<Res, Req = undefined, ResErr = Error, ReqErr = Error, M = undefined, IM = undefined> {
+  sendEvent: SendEvent<Res, Req, ResErr, ReqErr, M, IM>;
+  sendEventError: SendEventError<Res, Req, ResErr, ReqErr, M, IM>;
+  sendEventStreamEnd: SendEventStreamEnd<Res, Req, ResErr, ReqErr, M, IM>;
+  sendEventAbort: SendEventAbort<Res, Req, ResErr, ReqErr, M, IM>;
+  receiveEvent: ReceiveEvent<Res, Req, ResErr, ReqErr, M, IM>;
+  receiveEventError: ReceiveEventError<Res, Req, ResErr, ReqErr, M, IM>;
+  receiveEventStreamEnd: ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr, M, IM>;
+}
+interface InvokeHandlerEventa<Res, Req = undefined, ResErr = Error, ReqErr = Error, M = undefined, _IM = undefined> extends InvokeEventa<Res, Req, ResErr, ReqErr, M, undefined> {
+  sendEvent: SendEvent<Res, Req, ResErr, ReqErr, M, undefined>;
+  sendEventError: SendEventError<Res, Req, ResErr, ReqErr, M, undefined>;
+  sendEventStreamEnd: SendEventStreamEnd<Res, Req, ResErr, ReqErr, M, undefined>;
+  sendEventAbort: SendEventAbort<Res, Req, ResErr, ReqErr, M, undefined>;
+  receiveEvent: ReceiveEvent<Res, Req, ResErr, ReqErr, M, undefined>;
+  receiveEventError: ReceiveEventError<Res, Req, ResErr, ReqErr, M, undefined>;
+  receiveEventStreamEnd: ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr, M, undefined>;
 }
 type InferSendEvent<T> = T extends {
-  sendEvent: SendEvent<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? SendEvent<Res, Req, ResErr, ReqErr> : never;
+  sendEvent: SendEvent<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? SendEvent<Res, Req, ResErr, ReqErr, M, IM> : never;
 type InferSendEventError<T> = T extends {
-  sendEventError: SendEventError<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? SendEventError<Res, Req, ResErr, ReqErr> : never;
+  sendEventError: SendEventError<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? SendEventError<Res, Req, ResErr, ReqErr, M, IM> : never;
 type InferSendEventStreamEnd<T> = T extends {
-  sendEventStreamEnd: SendEventStreamEnd<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? SendEventStreamEnd<Res, Req, ResErr, ReqErr> : never;
+  sendEventStreamEnd: SendEventStreamEnd<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? SendEventStreamEnd<Res, Req, ResErr, ReqErr, M, IM> : never;
 type InferSendEventAbort<T> = T extends {
-  sendEventAbort: SendEventAbort<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? SendEventAbort<Res, Req, ResErr, ReqErr> : never;
+  sendEventAbort: SendEventAbort<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? SendEventAbort<Res, Req, ResErr, ReqErr, M, IM> : never;
 type InferReceiveEvent<T> = T extends {
-  receiveEvent: ReceiveEvent<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? ReceiveEvent<Res, Req, ResErr, ReqErr> : never;
+  receiveEvent: ReceiveEvent<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? ReceiveEvent<Res, Req, ResErr, ReqErr, M, IM> : never;
 type InferReceiveEventError<T> = T extends {
-  receiveEventError: ReceiveEventError<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? ReceiveEventError<Res, Req, ResErr, ReqErr> : never;
+  receiveEventError: ReceiveEventError<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? ReceiveEventError<Res, Req, ResErr, ReqErr, M, IM> : never;
 type InferReceiveEventStreamEnd<T> = T extends {
-  receiveEventStreamEnd: ReceiveEventStreamEnd<infer Res, infer Req, infer ResErr, infer ReqErr>;
-} ? ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr> : never;
-declare function defineInvokeEventa<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error>(tag?: string): {
-  sendEvent: SendEvent<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  sendEventError: SendEventError<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  sendEventStreamEnd: SendEventStreamEnd<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  sendEventAbort: SendEventAbort<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  receiveEvent: ReceiveEvent<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  receiveEventError: ReceiveEventError<Res$1, Req$1, ResErr$1, ReqErr$1>;
-  receiveEventStreamEnd: ReceiveEventStreamEnd<Res$1, Req$1, ResErr$1, ReqErr$1>;
+  receiveEventStreamEnd: ReceiveEventStreamEnd<infer Res, infer Req, infer ResErr, infer ReqErr, infer M, infer IM>;
+} ? ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr, M, IM> : never;
+declare function defineInvokeEventa<Res, Req = undefined, ResErr = Error, ReqErr = Error, M = undefined, IM = undefined>(tag?: string, options?: {
+  metadata?: M;
+  invokeMetadata?: IM;
+}): {
+  sendEvent: SendEvent<Res, Req, ResErr, ReqErr, M, IM>;
+  sendEventError: SendEventError<Res, Req, ResErr, ReqErr, M, IM>;
+  sendEventStreamEnd: SendEventStreamEnd<Res, Req, ResErr, ReqErr, M, IM>;
+  sendEventAbort: SendEventAbort<Res, Req, ResErr, ReqErr, M, IM>;
+  receiveEvent: ReceiveEvent<Res, Req, ResErr, ReqErr, M, IM>;
+  receiveEventError: ReceiveEventError<Res, Req, ResErr, ReqErr, M, IM>;
+  receiveEventStreamEnd: ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr, M, IM>;
 };
-declare function isInvokeEventa(event: Eventa<any>): event is SendEvent<any, any, any, any> | SendEventError<any, any, any, any> | SendEventStreamEnd<any, any, any, any> | ReceiveEvent<any, any, any, any> | ReceiveEventError<any, any, any, any> | ReceiveEventStreamEnd<any, any, any, any> | SendEventAbort<any, any, any, any>;
-declare function isSendEvent(event: Eventa<any>): event is SendEvent<any, any, any, any> | SendEventError<any, any, any, any> | SendEventStreamEnd<any, any, any, any> | SendEventAbort<any, any, any, any>;
-declare function isReceiveEvent(event: Eventa<any>): event is ReceiveEvent<any, any, any, any> | ReceiveEventError<any, any, any, any> | ReceiveEventStreamEnd<any, any, any, any>;
+declare function isInvokeEventa(event: Eventa<any>): event is SendEvent<any, any, any, any, any, any> | SendEventError<any, any, any, any, any, any> | SendEventStreamEnd<any, any, any, any, any, any> | ReceiveEvent<any, any, any, any, any, any> | ReceiveEventError<any, any, any, any, any, any> | ReceiveEventStreamEnd<any, any, any, any, any, any> | SendEventAbort<any, any, any, any, any, any>;
+declare function isSendEvent(event: Eventa<any>): event is SendEvent<any, any, any, any, any, any> | SendEventError<any, any, any, any, any, any> | SendEventStreamEnd<any, any, any, any, any, any> | SendEventAbort<any, any, any, any, any, any>;
+declare function isReceiveEvent(event: Eventa<any>): event is ReceiveEvent<any, any, any, any, any, any> | ReceiveEventError<any, any, any, any, any, any> | ReceiveEventStreamEnd<any, any, any, any, any, any>;
 //#endregion
 //#region src/invoke.d.ts
 type IsInvokeRequestOptional<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
@@ -130,33 +142,33 @@ type ExtractInvokeResponseOptions<EC extends EventContext<any, any>> = EC extend
 } ? IR : E extends {
   invokeResponse?: infer IR;
 } ? IR : undefined : undefined;
-type InvokeFunction<Res$1, Req$1, EC extends EventContext<any, any>> = [Req$1] extends [undefined] ? IsInvokeRequestOptional<EC> extends true ? (req?: Req$1, options?: ExtractInvokeRequestOptions<EC>) => Promise<Res$1> : (req: Req$1, options: ExtractInvokeRequestOptions<EC>) => Promise<Res$1> : IsInvokeRequestOptional<EC> extends true ? (req: Req$1, options?: ExtractInvokeRequestOptions<EC>) => Promise<Res$1> : (req: Req$1, options: ExtractInvokeRequestOptions<EC>) => Promise<Res$1>;
+type InvokeFunction<Res, Req, EC extends EventContext<any, any>> = [Req] extends [undefined] ? IsInvokeRequestOptional<EC> extends true ? (req?: Req, options?: ExtractInvokeRequestOptions<EC>) => Promise<Res> : (req: Req, options: ExtractInvokeRequestOptions<EC>) => Promise<Res> : IsInvokeRequestOptional<EC> extends true ? (req: Req, options?: ExtractInvokeRequestOptions<EC>) => Promise<Res> : (req: Req, options: ExtractInvokeRequestOptions<EC>) => Promise<Res>;
 type InvokeFunctionMap<EventMap extends Record<string, InvokeEventa<any, any, any, any>>, EC extends EventContext<any, any>> = { [K in keyof EventMap]: EventMap[K] extends InvokeEventa<infer Res, infer Req, any, any> ? InvokeFunction<Res, Req, EC> : never };
-type ExtendableInvokeResponse<Res$1, EC extends EventContext<any, any>> = Promise<Res$1> | Res$1 | Promise<{
-  response: Res$1;
+type ExtendableInvokeResponse<Res, EC extends EventContext<any, any>> = Promise<Res> | Res | Promise<{
+  response: Res;
   invokeResponse?: ExtractInvokeResponseOptions<EC>;
 }> | {
-  response: Res$1;
+  response: Res;
   invokeResponse?: ExtractInvokeResponseOptions<EC>;
 };
-declare function isExtendableInvokeResponseLike<Res$1, EC extends EventContext<any, any>>(value: Eventa<unknown> | ReceiveEvent<{
-  response: Res$1;
+declare function isExtendableInvokeResponseLike<Res, EC extends EventContext<any, any>>(value: Eventa<unknown> | ReceiveEvent<{
+  response: Res;
   invokeResponse?: unknown;
 }>): value is ReceiveEvent<{
-  response: Res$1;
+  response: Res;
   invokeResponse?: ExtractInvokeResponseOptions<EC>;
 }>;
-type Handler<Res$1, Req$1 = any, EC extends EventContext<any, any> = EventContext<any, any>, RawEventOptions = unknown> = (payload: Req$1, options?: {
+type Handler<Res, Req = any, EC extends EventContext<any, any> = EventContext<any, any>, RawEventOptions = unknown> = (payload: Req, options?: {
   abortController?: AbortController;
-} & RawEventOptions) => ExtendableInvokeResponse<Res$1, EC>;
-interface InternalInvokeHandler<Res$1, Req$1 = any, ResErr$1 = Error, ReqErr$1 = Error, EO = any> {
-  onSend: (params: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>['sendEvent'], eventOptions?: EO) => void;
-  onSendStreamEnd: (params: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>['sendEventStreamEnd'], eventOptions?: EO) => void;
-  onSendAbort: (params: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>['sendEventAbort'], eventOptions?: EO) => void;
+} & RawEventOptions) => ExtendableInvokeResponse<Res, EC>;
+interface InternalInvokeHandler<Res, Req = any, ResErr = Error, ReqErr = Error, EO = any, M = undefined, IM = undefined> {
+  onSend: (params: InvokeEventa<Res, Req, ResErr, ReqErr, M, IM>['sendEvent'], eventOptions?: EO) => void;
+  onSendStreamEnd: (params: InvokeEventa<Res, Req, ResErr, ReqErr, M, IM>['sendEventStreamEnd'], eventOptions?: EO) => void;
+  onSendAbort: (params: InvokeEventa<Res, Req, ResErr, ReqErr, M, IM>['sendEventAbort'], eventOptions?: EO) => void;
 }
-type HandlerMap<EventMap extends Record<string, InvokeEventa<any, any, any, any>>, EO = any, EC extends EventContext<any, any> = EventContext<any, any>> = { [K in keyof EventMap]: EventMap[K] extends InvokeEventa<infer Res, infer Req, any, any> ? Handler<Res, Req, EC, EO> : never };
-interface InvocableEventContext<E$1, EO> extends EventContext<E$1, EO> {
-  invokeHandlers?: Map<string, Map<Handler<any>, InternalInvokeHandler<any>>>;
+type HandlerMap<EventMap extends Record<string, InvokeEventa<any, any, any, any, any, any>>, EO = any, EC extends EventContext<any, any> = EventContext<any, any>> = { [K in keyof EventMap]: EventMap[K] extends InvokeEventa<infer Res, infer Req, any, any, any, any> ? Handler<Res, Req, EC, EO> : never };
+interface InvocableEventContext<E, EO> extends EventContext<E, EO> {
+  invokeHandlers?: Map<string, Map<Handler<any>, InternalInvokeHandler<any, any, any, any, any, any, any>>>;
 }
 /**
  * Create a unary invoke function (client side).
@@ -208,7 +220,7 @@ interface InvocableEventContext<E$1, EO> extends EventContext<E$1, EO> {
  * @param ctx Event context on the caller/client side.
  * @param event Invoke event definition created by `defineInvokeEventa`.
  */
-declare function defineInvoke<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx | (() => ECtx | Promise<ECtx>), event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>): InvokeFunction<Res$1, Req$1, ECtx>;
+declare function defineInvoke<Res, Req = undefined, ResErr = Error, ReqErr = Error, M = undefined, IM = undefined, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx | (() => ECtx | Promise<ECtx>), event: InvokeEventa<Res, Req, ResErr, ReqErr, M, IM>): InvokeFunction<Res, Req, ECtx>;
 /**
  * Create a map of invoke functions from a map of invoke events (client side).
  *
@@ -226,7 +238,7 @@ declare function defineInvoke<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr
  * @param ctx Event context on the caller/client side.
  * @param events Map of invoke events created by `defineInvokeEventa`.
  */
-declare function defineInvokes<EK extends string, EventMap extends Record<EK, InvokeEventa<any, any, any, any>>, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx | (() => ECtx | Promise<ECtx>), events: EventMap): InvokeFunctionMap<EventMap, ECtx>;
+declare function defineInvokes<EK extends string, EventMap extends Record<EK, InvokeEventa<any, any, any, any, any, any>>, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx | (() => ECtx | Promise<ECtx>), events: EventMap): InvokeFunctionMap<EventMap, ECtx>;
 /**
  * Define a unary invoke handler (server side).
  *
@@ -246,9 +258,9 @@ declare function defineInvokes<EK extends string, EventMap extends Record<EK, In
  * @param event Invoke event definition created by `defineInvokeEventa`.
  * @param handler Handler that returns a response (or response + metadata).
  */
-declare function defineInvokeHandler<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, CtxExt = any, EOpts extends {
+declare function defineInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, M = undefined, IM = undefined, CtxExt = any, EOpts extends {
   raw?: any;
-} = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>, handler: Handler<Res$1, Req$1, InvocableEventContext<CtxExt, EOpts>, EOpts>): () => void;
+} = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeHandlerEventa<Res, Req, ResErr, ReqErr, M, IM>, handler: Handler<Res, Req, InvocableEventContext<CtxExt, EOpts>, EOpts>): () => void;
 /**
  * Define multiple invoke handlers in batch (server side).
  *
@@ -289,7 +301,7 @@ declare function defineInvokeHandlers<EK extends string, EventMap extends Record
  * @param handler Specific handler to remove (omit to remove all).
  * @returns `true` if at least one handler was removed, `false` otherwise
  */
-declare function undefineInvokeHandler<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, CtxExt = any, EOpts = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>, handler?: Handler<Res$1, Req$1, InvocableEventContext<CtxExt, EOpts>, EOpts>): boolean;
+declare function undefineInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, CtxExt = any, EOpts = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res, Req, ResErr, ReqErr>, handler?: Handler<Res, Req, InvocableEventContext<CtxExt, EOpts>, EOpts>): boolean;
 //#endregion
 //#region src/invoke-extension-transfer.d.ts
 interface WithTransfer<T> {
@@ -315,10 +327,10 @@ interface InvokeFunctionStubOptions {
 type RemoteInvokeOptions<EC extends EventContext<any, any>> = ExtractInvokeRequestOptions<EC> & {
   functionStubs?: boolean | InvokeFunctionStubOptions;
 };
-interface RemoteInvokeResult<Res$1> extends Promise<Res$1> {
+interface RemoteInvokeResult<Res> extends Promise<Res> {
   dispose: () => void;
 }
-type RemoteInvokeFunction<Res$1, Req$1, EC extends EventContext<any, any>> = [Req$1] extends [undefined] ? (req?: Req$1, options?: RemoteInvokeOptions<EC>) => RemoteInvokeResult<Res$1> : (req: Req$1, options?: RemoteInvokeOptions<EC>) => RemoteInvokeResult<Res$1>;
+type RemoteInvokeFunction<Res, Req, EC extends EventContext<any, any>> = [Req] extends [undefined] ? (req?: Req, options?: RemoteInvokeOptions<EC>) => RemoteInvokeResult<Res> : (req: Req, options?: RemoteInvokeOptions<EC>) => RemoteInvokeResult<Res>;
 declare function createRemoteMethodTagPrefix(prefix?: string): string;
 /**
  * Enable "remote method" payloads for invoke: functions in the request body are
@@ -369,10 +381,10 @@ declare function createRemoteMethodTagPrefix(prefix?: string): string;
  *        `onDisallowedTag`, `autoDisposeMs`, and `strict` for stricter control.
  */
 declare function withRemoteMethods(defaultOptions?: boolean | InvokeFunctionStubOptions): {
-  defineInvoke<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx, event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>): RemoteInvokeFunction<Res$1, Req$1, ECtx>;
-  defineInvokeHandler<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, CtxExt = any, EOpts extends {
+  defineInvoke<Res, Req = undefined, ResErr = Error, ReqErr = Error, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx, event: InvokeEventa<Res, Req, ResErr, ReqErr>): RemoteInvokeFunction<Res, Req, ECtx>;
+  defineInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, CtxExt = any, EOpts extends {
     raw?: any;
-  } = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>, handler: Handler<Res$1, Req$1, InvocableEventContext<CtxExt, EOpts>, EOpts>): () => void;
+  } = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res, Req, ResErr, ReqErr>, handler: Handler<Res, Req, InvocableEventContext<CtxExt, EOpts>, EOpts>): () => void;
 };
 //#endregion
 //#region src/stream.d.ts
@@ -414,12 +426,12 @@ declare function withRemoteMethods(defaultOptions?: boolean | InvokeFunctionStub
  * @param clientCtx Event context on the caller/client side.
  * @param event Invoke event definition created by `defineInvokeEventa`.
  */
-declare function defineStreamInvoke<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, E$1 = any, EO = any>(clientCtx: EventContext<E$1, EO>, event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>): (req: Req$1 | ReadableStream<Req$1> | AsyncIterable<Req$1>, options?: {
+declare function defineStreamInvoke<Res, Req = undefined, ResErr = Error, ReqErr = Error, E = any, EO = any>(clientCtx: EventContext<E, EO>, event: InvokeEventa<Res, Req, ResErr, ReqErr>): (req: Req | ReadableStream<Req> | AsyncIterable<Req>, options?: {
   signal?: AbortSignal;
-} & EO) => ReadableStream<Res$1>;
-type StreamHandler<Res$1, Req$1 = any, RawEventOptions = unknown> = (payload: Req$1, options?: {
+} & EO) => ReadableStream<Res>;
+type StreamHandler<Res, Req = any, RawEventOptions = unknown> = (payload: Req, options?: {
   abortController?: AbortController;
-} & RawEventOptions) => AsyncGenerator<Res$1, void, unknown>;
+} & RawEventOptions) => AsyncGenerator<Res, void, unknown>;
 /**
  * Define a stream invoke handler (server side).
  *
@@ -448,9 +460,9 @@ type StreamHandler<Res$1, Req$1 = any, RawEventOptions = unknown> = (payload: Re
  * @param event Invoke event definition created by `defineInvokeEventa`.
  * @param fn Stream handler that yields response chunks.
  */
-declare function defineStreamInvokeHandler<Res$1, Req$1 = undefined, ResErr$1 = Error, ReqErr$1 = Error, E$1 = any, EO extends {
+declare function defineStreamInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, E = any, EO extends {
   raw?: any;
-} = any>(serverCtx: EventContext<E$1, EO>, event: InvokeEventa<Res$1, Req$1, ResErr$1, ReqErr$1>, fn: StreamHandler<Res$1, Req$1, EO>): void;
+} = any>(serverCtx: EventContext<E, EO>, event: InvokeEventa<Res, Req, ResErr, ReqErr>, fn: StreamHandler<Res, Req, EO>): void;
 /**
  * Convert a callback-style handler into a stream handler.
  *
@@ -475,13 +487,13 @@ declare function defineStreamInvokeHandler<Res$1, Req$1 = undefined, ResErr$1 =
  *
  * @param handler Callback handler with `emit` for streaming responses.
  */
-declare function toStreamHandler<Req$1, Res$1, EO extends {
+declare function toStreamHandler<Req, Res, EO extends {
   raw?: any;
 } = any>(handler: (context: {
-  payload: Req$1;
+  payload: Req;
   options?: EO;
-  emit: (data: Res$1) => void;
-}) => Promise<void>): StreamHandler<Res$1, Req$1, EO>;
+  emit: (data: Res) => void;
+}) => Promise<void>): StreamHandler<Res, Req, EO>;
 //#endregion
 //#region src/utils.d.ts
 declare function randomBetween(min: number, max: number): number;
@@ -518,5 +530,5 @@ declare function createUntil<T>(options?: {
   handler: (value: T) => void;
 };
 //#endregion
-export { isSendEvent as $, defineInvokeHandlers as A, InferSendEventStreamEnd as B, Handler as C, InvokeFunctionMap as D, InvokeFunction as E, InferReceiveEventError as F, ReceiveEventStreamEnd as G, InvokeEventa as H, InferReceiveEventStreamEnd as I, SendEventError as J, SendEvent as K, InferSendEvent as L, isExtendableInvokeResponseLike as M, undefineInvokeHandler as N, defineInvoke as O, InferReceiveEvent as P, isReceiveEvent as Q, InferSendEventAbort as R, ExtractInvokeResponseOptions as S, InvocableEventContext as T, ReceiveEvent as U, InvokeEventType as V, ReceiveEventError as W, defineInvokeEventa as X, SendEventStreamEnd as Y, isInvokeEventa as Z, withRemoteMethods as _, isAbortError as a, ExtendableInvokeResponse as b, randomBetween as c, toStreamHandler as d, InvokeFunctionStubOptions as f, createRemoteMethodTagPrefix as g, RemoteInvokeResult as h, createUntilTriggeredOnce as i, defineInvokes as j, defineInvokeHandler as k, defineStreamInvoke as l, RemoteInvokeOptions as m, createUntil as n, isAsyncIterable as o, RemoteInvokeFunction as p, SendEventAbort as q, createUntilTriggered as r, isReadableStream as s, createAbortError as t, defineStreamInvokeHandler as u, WithTransfer as v, HandlerMap as w, ExtractInvokeRequestOptions as x, withTransfer as y, InferSendEventError as z };
-//# sourceMappingURL=index-CI_gUGXg.d.mts.map
+export { isReceiveEvent as $, defineInvokeHandlers as A, InferSendEventStreamEnd as B, Handler as C, InvokeFunctionMap as D, InvokeFunction as E, InferReceiveEventError as F, ReceiveEventError as G, InvokeEventa as H, InferReceiveEventStreamEnd as I, SendEventAbort as J, ReceiveEventStreamEnd as K, InferSendEvent as L, isExtendableInvokeResponseLike as M, undefineInvokeHandler as N, defineInvoke as O, InferReceiveEvent as P, isInvokeEventa as Q, InferSendEventAbort as R, ExtractInvokeResponseOptions as S, InvocableEventContext as T, InvokeHandlerEventa as U, InvokeEventType as V, ReceiveEvent as W, SendEventStreamEnd as X, SendEventError as Y, defineInvokeEventa as Z, withRemoteMethods as _, isAbortError as a, ExtendableInvokeResponse as b, randomBetween as c, toStreamHandler as d, isSendEvent as et, InvokeFunctionStubOptions as f, createRemoteMethodTagPrefix as g, RemoteInvokeResult as h, createUntilTriggeredOnce as i, defineInvokes as j, defineInvokeHandler as k, defineStreamInvoke as l, RemoteInvokeOptions as m, createUntil as n, isAsyncIterable as o, RemoteInvokeFunction as p, SendEvent as q, createUntilTriggered as r, isReadableStream as s, createAbortError as t, defineStreamInvokeHandler as u, WithTransfer as v, HandlerMap as w, ExtractInvokeRequestOptions as x, withTransfer as y, InferSendEventError as z };
+//# sourceMappingURL=index-g6DulgOI.d.mts.map

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as nanoid, a as EventaLike, c as InboundEventa, d as OutboundEventa, f as and, g as matchBy, h as defineOutboundEventa, i as EventaFlowDirection, l as InferEventaPayload, m as defineInboundEventa, n as EventTag, o as EventaMatchExpression, p as defineEventa, r as Eventa, s as EventaType, t as DirectionalEventa, u as InvokeEventConstraint, v as or } from "./eventa-AJyw28P8.mjs";
-import { n as EventContextEmitFn, r as createContext, t as EventContext } from "./context-ZVv99bcM.mjs";
-import { $ as isSendEvent, A as defineInvokeHandlers, B as InferSendEventStreamEnd, C as Handler, D as InvokeFunctionMap, E as InvokeFunction, F as InferReceiveEventError, G as ReceiveEventStreamEnd, H as InvokeEventa, I as InferReceiveEventStreamEnd, J as SendEventError, K as SendEvent, L as InferSendEvent, M as isExtendableInvokeResponseLike, N as undefineInvokeHandler, O as defineInvoke, P as InferReceiveEvent, Q as isReceiveEvent, R as InferSendEventAbort, S as ExtractInvokeResponseOptions, T as InvocableEventContext, U as ReceiveEvent, V as InvokeEventType, W as ReceiveEventError, X as defineInvokeEventa, Y as SendEventStreamEnd, Z as isInvokeEventa, _ as withRemoteMethods, a as isAbortError, b as ExtendableInvokeResponse, c as randomBetween, d as toStreamHandler, f as InvokeFunctionStubOptions, g as createRemoteMethodTagPrefix, h as RemoteInvokeResult, i as createUntilTriggeredOnce, j as defineInvokes, k as defineInvokeHandler, l as defineStreamInvoke, m as RemoteInvokeOptions, n as createUntil, o as isAsyncIterable, p as RemoteInvokeFunction, q as SendEventAbort, r as createUntilTriggered, s as isReadableStream, t as createAbortError, u as defineStreamInvokeHandler, v as WithTransfer, w as HandlerMap, x as ExtractInvokeRequestOptions, y as withTransfer, z as InferSendEventError } from "./index-CI_gUGXg.mjs";
-export { DirectionalEventa, EventContext, EventContextEmitFn, EventTag, Eventa, EventaFlowDirection, EventaLike, EventaMatchExpression, EventaType, ExtendableInvokeResponse, ExtractInvokeRequestOptions, ExtractInvokeResponseOptions, Handler, HandlerMap, InboundEventa, InferEventaPayload, InferReceiveEvent, InferReceiveEventError, InferReceiveEventStreamEnd, InferSendEvent, InferSendEventAbort, InferSendEventError, InferSendEventStreamEnd, InvocableEventContext, InvokeEventConstraint, InvokeEventType, InvokeEventa, InvokeFunction, InvokeFunctionMap, InvokeFunctionStubOptions, OutboundEventa, ReceiveEvent, ReceiveEventError, ReceiveEventStreamEnd, RemoteInvokeFunction, RemoteInvokeOptions, RemoteInvokeResult, SendEvent, SendEventAbort, SendEventError, SendEventStreamEnd, WithTransfer, and, createAbortError, createContext, createRemoteMethodTagPrefix, createUntil, createUntilTriggered, createUntilTriggeredOnce, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isAbortError, isAsyncIterable, isExtendableInvokeResponseLike, isInvokeEventa, isReadableStream, isReceiveEvent, isSendEvent, matchBy, nanoid, or, randomBetween, toStreamHandler, undefineInvokeHandler, withRemoteMethods, withTransfer };
+import { _ as nanoid, a as EventaLike, c as InboundEventa, d as OutboundEventa, f as and, g as matchBy, h as defineOutboundEventa, i as EventaFlowDirection, l as InferEventaPayload, m as defineInboundEventa, n as EventTag, o as EventaMatchExpression, p as defineEventa, r as Eventa, s as EventaType, t as DirectionalEventa, u as InvokeEventConstraint, v as or } from "./eventa-DSnoBa1O.mjs";
+import { n as EventContextEmitFn, r as createContext, t as EventContext } from "./context-BsqFeoer.mjs";
+import { $ as isReceiveEvent, A as defineInvokeHandlers, B as InferSendEventStreamEnd, C as Handler, D as InvokeFunctionMap, E as InvokeFunction, F as InferReceiveEventError, G as ReceiveEventError, H as InvokeEventa, I as InferReceiveEventStreamEnd, J as SendEventAbort, K as ReceiveEventStreamEnd, L as InferSendEvent, M as isExtendableInvokeResponseLike, N as undefineInvokeHandler, O as defineInvoke, P as InferReceiveEvent, Q as isInvokeEventa, R as InferSendEventAbort, S as ExtractInvokeResponseOptions, T as InvocableEventContext, U as InvokeHandlerEventa, V as InvokeEventType, W as ReceiveEvent, X as SendEventStreamEnd, Y as SendEventError, Z as defineInvokeEventa, _ as withRemoteMethods, a as isAbortError, b as ExtendableInvokeResponse, c as randomBetween, d as toStreamHandler, et as isSendEvent, f as InvokeFunctionStubOptions, g as createRemoteMethodTagPrefix, h as RemoteInvokeResult, i as createUntilTriggeredOnce, j as defineInvokes, k as defineInvokeHandler, l as defineStreamInvoke, m as RemoteInvokeOptions, n as createUntil, o as isAsyncIterable, p as RemoteInvokeFunction, q as SendEvent, r as createUntilTriggered, s as isReadableStream, t as createAbortError, u as defineStreamInvokeHandler, v as WithTransfer, w as HandlerMap, x as ExtractInvokeRequestOptions, y as withTransfer, z as InferSendEventError } from "./index-g6DulgOI.mjs";
+export { DirectionalEventa, EventContext, EventContextEmitFn, EventTag, Eventa, EventaFlowDirection, EventaLike, EventaMatchExpression, EventaType, ExtendableInvokeResponse, ExtractInvokeRequestOptions, ExtractInvokeResponseOptions, Handler, HandlerMap, InboundEventa, InferEventaPayload, InferReceiveEvent, InferReceiveEventError, InferReceiveEventStreamEnd, InferSendEvent, InferSendEventAbort, InferSendEventError, InferSendEventStreamEnd, InvocableEventContext, InvokeEventConstraint, InvokeEventType, InvokeEventa, InvokeFunction, InvokeFunctionMap, InvokeFunctionStubOptions, InvokeHandlerEventa, OutboundEventa, ReceiveEvent, ReceiveEventError, ReceiveEventStreamEnd, RemoteInvokeFunction, RemoteInvokeOptions, RemoteInvokeResult, SendEvent, SendEventAbort, SendEventError, SendEventStreamEnd, WithTransfer, and, createAbortError, createContext, createRemoteMethodTagPrefix, createUntil, createUntilTriggered, createUntilTriggeredOnce, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isAbortError, isAsyncIterable, isExtendableInvokeResponseLike, isInvokeEventa, isReadableStream, isReceiveEvent, isSendEvent, matchBy, nanoid, or, randomBetween, toStreamHandler, undefineInvokeHandler, withRemoteMethods, withTransfer };

package/dist/index.mjs

@@ -1,4 +1,3 @@
-import { a as defineEventa, c as matchBy, i as and, l as nanoid, n as EventaFlowDirection, o as defineInboundEventa, r as EventaType, s as defineOutboundEventa, t as createContext, u as or } from "./context-BMDJMapI.mjs";
-import { C as isInvokeEventa, S as defineInvokeEventa, T as isSendEvent, _ as isAbortError, a as withRemoteMethods, b as randomBetween, c as defineInvokeHandler, d as isExtendableInvokeResponseLike, f as undefineInvokeHandler, g as createUntilTriggeredOnce, h as createUntilTriggered, i as createRemoteMethodTagPrefix, l as defineInvokeHandlers, m as createUntil, n as defineStreamInvokeHandler, o as withTransfer, p as createAbortError, r as toStreamHandler, s as defineInvoke, t as defineStreamInvoke, u as defineInvokes, v as isAsyncIterable, w as isReceiveEvent, x as InvokeEventType, y as isReadableStream } from "./src-eMqISeHo.mjs";
-
-export { EventaFlowDirection, EventaType, InvokeEventType, and, createAbortError, createContext, createRemoteMethodTagPrefix, createUntil, createUntilTriggered, createUntilTriggeredOnce, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isAbortError, isAsyncIterable, isExtendableInvokeResponseLike, isInvokeEventa, isReadableStream, isReceiveEvent, isSendEvent, matchBy, nanoid, or, randomBetween, toStreamHandler, undefineInvokeHandler, withRemoteMethods, withTransfer };
+import { a as defineEventa, c as matchBy, i as and, l as nanoid, n as EventaFlowDirection, o as defineInboundEventa, r as EventaType, s as defineOutboundEventa, t as createContext, u as or } from "./context-Dht_IZMb.mjs";
+import { C as isInvokeEventa, S as defineInvokeEventa, T as isSendEvent, _ as isAbortError, a as withRemoteMethods, b as randomBetween, c as defineInvokeHandler, d as isExtendableInvokeResponseLike, f as undefineInvokeHandler, g as createUntilTriggeredOnce, h as createUntilTriggered, i as createRemoteMethodTagPrefix, l as defineInvokeHandlers, m as createUntil, n as defineStreamInvokeHandler, o as withTransfer, p as createAbortError, r as toStreamHandler, s as defineInvoke, t as defineStreamInvoke, u as defineInvokes, v as isAsyncIterable, w as isReceiveEvent, x as InvokeEventType, y as isReadableStream } from "./src-CTs6h4Ci.mjs";
+export { EventaFlowDirection, EventaType, InvokeEventType, and, createAbortError, createContext, createRemoteMethodTagPrefix, createUntil, createUntilTriggered, createUntilTriggeredOnce, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isAbortError, isAsyncIterable, isExtendableInvokeResponseLike, isInvokeEventa, isReadableStream, isReceiveEvent, isSendEvent, matchBy, nanoid, or, randomBetween, toStreamHandler, undefineInvokeHandler, withRemoteMethods, withTransfer };

package/dist/{internal-ChLglF1N.mjs → internal-CHUsXYiP.mjs}

@@ -1,5 +1,4 @@
-import { l as nanoid } from "./context-BMDJMapI.mjs";
-
+import { l as nanoid } from "./context-Dht_IZMb.mjs";
 //#region src/adapters/websocket/internal.ts
 function generateWebsocketPayload(type, payload) {
 	return {
@@ -12,7 +11,7 @@ function generateWebsocketPayload(type, payload) {
 function parseWebsocketPayload(data) {
 	return JSON.parse(data);
 }
-
 //#endregion
 export { parseWebsocketPayload as n, generateWebsocketPayload as t };
-//# sourceMappingURL=internal-ChLglF1N.mjs.map
+
+//# sourceMappingURL=internal-CHUsXYiP.mjs.map

package/dist/{internal-ChLglF1N.mjs.map → internal-CHUsXYiP.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"internal-ChLglF1N.mjs","names":[],"sources":["../src/adapters/websocket/internal.ts"],"sourcesContent":["import type { EventTag } from '../../eventa'\nimport type { WebsocketPayload } from './shared'\n\nimport { nanoid } from '../../eventa'\n\nexport function generateWebsocketPayload<T>(type: EventTag<any, any>, payload: T): WebsocketPayload<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n    timestamp: Date.now(),\n  }\n}\n\nexport function parseWebsocketPayload<T>(data: string): WebsocketPayload<T> {\n  return JSON.parse(data) as WebsocketPayload<T>\n}\n"],"mappings":";;;AAKA,SAAgB,yBAA4B,MAA0B,SAAiC;AACrG,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACA,WAAW,KAAK,KAAK;EACtB;;AAGH,SAAgB,sBAAyB,MAAmC;AAC1E,QAAO,KAAK,MAAM,KAAK"}
+{"version":3,"file":"internal-CHUsXYiP.mjs","names":[],"sources":["../src/adapters/websocket/internal.ts"],"sourcesContent":["import type { EventTag } from '../../eventa'\nimport type { WebsocketPayload } from './shared'\n\nimport { nanoid } from '../../eventa'\n\nexport function generateWebsocketPayload<T>(type: EventTag<any, any>, payload: T): WebsocketPayload<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n    timestamp: Date.now(),\n  }\n}\n\nexport function parseWebsocketPayload<T>(data: string): WebsocketPayload<T> {\n  return JSON.parse(data) as WebsocketPayload<T>\n}\n"],"mappings":";;AAKA,SAAgB,yBAA4B,MAA0B,SAAiC;AACrG,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACA,WAAW,KAAK,KAAK;EACtB;;AAGH,SAAgB,sBAAyB,MAAmC;AAC1E,QAAO,KAAK,MAAM,KAAK"}

package/dist/{shared-CRxfs1TC.mjs → shared-CA5MGwv0.mjs}

@@ -1,6 +1,5 @@
-import { a as defineEventa, l as nanoid, s as defineOutboundEventa } from "./context-BMDJMapI.mjs";
-import { d as isExtendableInvokeResponseLike } from "./src-eMqISeHo.mjs";
-
+import { a as defineEventa, l as nanoid, s as defineOutboundEventa } from "./context-Dht_IZMb.mjs";
+import { d as isExtendableInvokeResponseLike } from "./src-CTs6h4Ci.mjs";
 //#region src/adapters/webworkers/internal.ts
 function generateWorkerPayload(type, payload) {
 	return {
@@ -12,7 +11,6 @@ function generateWorkerPayload(type, payload) {
 function parseWorkerPayload(data) {
 	return data;
 }
-
 //#endregion
 //#region src/adapters/webworkers/shared.ts
 function defineWorkerEventa(id) {
@@ -31,7 +29,7 @@ function isWorkerEventa(event) {
 	return typeof event === "object" && "_workerTransfer" in event && typeof event._workerTransfer === "boolean" && event._workerTransfer === true;
 }
 const workerErrorEvent = defineEventa();
-const workerMessageErrorEvent = defineEventa();
+defineEventa();
 function normalizeOnListenerParameters(event, options) {
 	let eventPayload = event.body;
 	let transfer;
@@ -59,7 +57,7 @@ function normalizeOnListenerParameters(event, options) {
 		transfer
 	};
 }
-
 //#endregion
 export { workerErrorEvent as a, normalizeOnListenerParameters as i, defineWorkerEventa as n, generateWorkerPayload as o, isWorkerEventa as r, parseWorkerPayload as s, defineOutboundWorkerEventa as t };
-//# sourceMappingURL=shared-CRxfs1TC.mjs.map
+
+//# sourceMappingURL=shared-CA5MGwv0.mjs.map

package/dist/shared-CA5MGwv0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-CA5MGwv0.mjs","names":[],"sources":["../src/adapters/webworkers/internal.ts","../src/adapters/webworkers/shared.ts"],"sourcesContent":["import type { EventTag } from '../..'\nimport type { WorkerPayload } from './shared'\n\nimport { nanoid } from '../..'\n\nexport function generateWorkerPayload<T>(type: EventTag<any, any>, payload: T): WorkerPayload<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n  }\n}\n\nexport function parseWorkerPayload<T>(data: unknown): WorkerPayload<T> {\n  return data as WorkerPayload<T>\n}\n","import type { EventContext } from '../../context'\nimport type { Eventa, EventTag } from '../../eventa'\n\nimport { defineEventa, defineOutboundEventa } from '../../eventa'\nimport { isExtendableInvokeResponseLike } from '../../invoke'\n\nexport interface WorkerPayload<T> {\n  id: string\n  type: EventTag<any, any>\n  payload: T\n  transfer?: Transferable[]\n}\n\nexport interface WorkerEventa<T> extends Eventa<{ message: T, transfer?: Transferable[] }> {\n  _workerTransfer: true\n}\n\nexport function defineWorkerEventa<T>(id?: string): WorkerEventa<T> {\n  return {\n    ...defineEventa<{ message: T, transfer?: Transferable[] }>(id),\n    _workerTransfer: true,\n  }\n}\n\nexport function defineOutboundWorkerEventa<T>(id?: string): WorkerEventa<T> {\n  return {\n    ...defineOutboundEventa<{ message: T, transfer?: Transferable[] }>(id),\n    _workerTransfer: true,\n  }\n}\n\nexport function isWorkerEventa(event: Eventa<any>): event is WorkerEventa<any> {\n  return typeof event === 'object'\n    && '_workerTransfer' in event\n    && typeof event._workerTransfer === 'boolean'\n    && event._workerTransfer === true\n}\n\nexport const workerErrorEvent = defineEventa<{ error: unknown }>()\nexport const workerMessageErrorEvent = defineEventa<{ error: unknown, message: any }>()\n\nexport function normalizeOnListenerParameters(event: Eventa<any>, options?: { transfer?: Transferable[] } | unknown) {\n  let eventPayload: any = event.body\n  let transfer: Transferable[] | undefined\n\n  if (isExtendableInvokeResponseLike<unknown, EventContext<{ invokeResponse?: { transfer?: Transferable[] } }>>(event)) {\n    if (event.body!.content.invokeResponse?.transfer != null) {\n      transfer = event.body!.content.invokeResponse!.transfer\n      delete event.body!.content.invokeResponse\n    }\n\n    eventPayload = { ...event.body, content: event.body!.content.response }\n    delete eventPayload.content.response\n  }\n  else if (isWorkerEventa(event)) {\n    transfer = event.body?.transfer\n    delete event.body?.transfer\n\n    eventPayload = event.body?.message\n    delete event.body?.message\n  }\n\n  // Override from options\n  if (typeof options !== 'undefined' && options != null && typeof options === 'object' && 'transfer' in options) {\n    if (Array.isArray(options.transfer)) {\n      transfer = options.transfer\n    }\n  }\n\n  return {\n    body: eventPayload,\n    transfer,\n  }\n}\n"],"mappings":";;;AAKA,SAAgB,sBAAyB,MAA0B,SAA8B;AAC/F,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACD;;AAGH,SAAgB,mBAAsB,MAAiC;AACrE,QAAO;;;;ACGT,SAAgB,mBAAsB,IAA8B;AAClE,QAAO;EACL,GAAG,aAAwD,GAAG;EAC9D,iBAAiB;EAClB;;AAGH,SAAgB,2BAA8B,IAA8B;AAC1E,QAAO;EACL,GAAG,qBAAgE,GAAG;EACtE,iBAAiB;EAClB;;AAGH,SAAgB,eAAe,OAAgD;AAC7E,QAAO,OAAO,UAAU,YACnB,qBAAqB,SACrB,OAAO,MAAM,oBAAoB,aACjC,MAAM,oBAAoB;;AAGjC,MAAa,mBAAmB,cAAkC;AAC3B,cAAgD;AAEvF,SAAgB,8BAA8B,OAAoB,SAAmD;CACnH,IAAI,eAAoB,MAAM;CAC9B,IAAI;AAEJ,KAAI,+BAA0G,MAAM,EAAE;AACpH,MAAI,MAAM,KAAM,QAAQ,gBAAgB,YAAY,MAAM;AACxD,cAAW,MAAM,KAAM,QAAQ,eAAgB;AAC/C,UAAO,MAAM,KAAM,QAAQ;;AAG7B,iBAAe;GAAE,GAAG,MAAM;GAAM,SAAS,MAAM,KAAM,QAAQ;GAAU;AACvE,SAAO,aAAa,QAAQ;YAErB,eAAe,MAAM,EAAE;AAC9B,aAAW,MAAM,MAAM;AACvB,SAAO,MAAM,MAAM;AAEnB,iBAAe,MAAM,MAAM;AAC3B,SAAO,MAAM,MAAM;;AAIrB,KAAI,OAAO,YAAY,eAAe,WAAW,QAAQ,OAAO,YAAY,YAAY,cAAc;MAChG,MAAM,QAAQ,QAAQ,SAAS,CACjC,YAAW,QAAQ;;AAIvB,QAAO;EACL,MAAM;EACN;EACD"}

package/dist/{shared-DgX1R_nY.d.mts → shared-CVTLm458.d.mts}

@@ -1,4 +1,4 @@
-import { n as EventTag, r as Eventa } from "./eventa-AJyw28P8.mjs";
+import { n as EventTag, r as Eventa } from "./eventa-DSnoBa1O.mjs";
 
 //#region src/adapters/webworkers/shared.d.ts
 interface WorkerPayload<T> {
@@ -18,11 +18,11 @@ declare function defineOutboundWorkerEventa<T>(id?: string): WorkerEventa<T>;
 declare function isWorkerEventa(event: Eventa<any>): event is WorkerEventa<any>;
 declare const workerErrorEvent: Eventa<{
   error: unknown;
-}>;
+}, undefined, undefined>;
 declare const workerMessageErrorEvent: Eventa<{
   error: unknown;
   message: any;
-}>;
+}, undefined, undefined>;
 declare function normalizeOnListenerParameters(event: Eventa<any>, options?: {
   transfer?: Transferable[];
 } | unknown): {
@@ -31,4 +31,4 @@ declare function normalizeOnListenerParameters(event: Eventa<any>, options?: {
 };
 //#endregion
 export { isWorkerEventa as a, workerMessageErrorEvent as c, defineWorkerEventa as i, WorkerPayload as n, normalizeOnListenerParameters as o, defineOutboundWorkerEventa as r, workerErrorEvent as s, WorkerEventa as t };
-//# sourceMappingURL=shared-DgX1R_nY.d.mts.map
+//# sourceMappingURL=shared-CVTLm458.d.mts.map

package/dist/{shared-Cd4CLAdD.d.mts → shared-CfXZb-7K.d.mts}

@@ -1,4 +1,4 @@
-import { n as EventTag, s as EventaType } from "./eventa-AJyw28P8.mjs";
+import { n as EventTag, s as EventaType } from "./eventa-DSnoBa1O.mjs";
 
 //#region src/adapters/electron/shared.d.ts
 interface Payload<T> {
@@ -10,9 +10,11 @@ declare const errorEvent: {
   body?: {
     error: unknown;
   } | undefined;
+  metadata?: undefined;
+  invokeMetadata?: undefined;
   id: string;
   type?: EventaType.Event | undefined;
 };
 //#endregion
 export { errorEvent as n, Payload as t };
-//# sourceMappingURL=shared-Cd4CLAdD.d.mts.map
+//# sourceMappingURL=shared-CfXZb-7K.d.mts.map