@moeru/eventa 1.0.0-alpha.9 → 1.0.0-beta.2

package/dist/index-CI_gUGXg.d.mts

@@ -0,0 +1,522 @@
+import { n as EventTag, r as Eventa } from "./eventa-AJyw28P8.mjs";
+import { t as EventContext } from "./context-ZVv99bcM.mjs";
+
+//#region src/invoke-shared.d.ts
+declare enum InvokeEventType {
+  SendEvent = 0,
+  SendEventError = 1,
+  SendEventStreamEnd = 2,
+  SendEventAbort = 3,
+  ReceiveEvent = 4,
+  ReceiveEventError = 5,
+  ReceiveEventStreamEnd = 6,
+}
+interface SendEvent<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: Req$1;
+  isReqStream?: boolean;
+}> {
+  id: EventTag<Res$1, Req$1>;
+  invokeType: InvokeEventType.SendEvent;
+}
+interface SendEventError<Res$1, Req$1 = undefined, _ = undefined, ReqErr$1 = Error> extends Eventa<{
+  invokeId: string;
+  content: ReqErr$1;
+}> {
+  id: EventTag<Res$1, Req$1>;
+  invokeType: InvokeEventType.SendEventError;
+}
+interface SendEventStreamEnd<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: undefined;
+}> {
+  id: EventTag<Res$1, Req$1>;
+  invokeType: InvokeEventType.SendEventStreamEnd;
+}
+interface SendEventAbort<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content?: unknown;
+}> {
+  id: EventTag<Res$1, Req$1>;
+  invokeType: InvokeEventType.SendEventAbort;
+}
+interface ReceiveEvent<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: Res$1;
+}> {
+  id: EventTag<Res$1, Req$1>;
+  invokeType: InvokeEventType.ReceiveEvent;
+}
+interface ReceiveEventError<Res$1, Req$1 = undefined, ResErr$1 = undefined, _ = undefined> extends Eventa<{
+  invokeId: string;
+  content: {
+    error: ResErr$1;
+  };
+}> {
+  id: EventTag<Res$1, Req$1>;
+  invokeType: InvokeEventType.ReceiveEventError;
+}
+interface ReceiveEventStreamEnd<Res$1, Req$1 = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: undefined;
+}> {
+  id: EventTag<Res$1, Req$1>;
+  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>;
+}
+type InferSendEvent<T> = T extends {
+  sendEvent: SendEvent<infer Res, infer Req, infer ResErr, infer ReqErr>;
+} ? SendEvent<Res, Req, ResErr, ReqErr> : never;
+type InferSendEventError<T> = T extends {
+  sendEventError: SendEventError<infer Res, infer Req, infer ResErr, infer ReqErr>;
+} ? SendEventError<Res, Req, ResErr, ReqErr> : never;
+type InferSendEventStreamEnd<T> = T extends {
+  sendEventStreamEnd: SendEventStreamEnd<infer Res, infer Req, infer ResErr, infer ReqErr>;
+} ? SendEventStreamEnd<Res, Req, ResErr, ReqErr> : never;
+type InferSendEventAbort<T> = T extends {
+  sendEventAbort: SendEventAbort<infer Res, infer Req, infer ResErr, infer ReqErr>;
+} ? SendEventAbort<Res, Req, ResErr, ReqErr> : never;
+type InferReceiveEvent<T> = T extends {
+  receiveEvent: ReceiveEvent<infer Res, infer Req, infer ResErr, infer ReqErr>;
+} ? ReceiveEvent<Res, Req, ResErr, ReqErr> : never;
+type InferReceiveEventError<T> = T extends {
+  receiveEventError: ReceiveEventError<infer Res, infer Req, infer ResErr, infer ReqErr>;
+} ? ReceiveEventError<Res, Req, ResErr, ReqErr> : 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>;
+};
+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>;
+//#endregion
+//#region src/invoke.d.ts
+type IsInvokeRequestOptional<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
+  invokeRequest: any;
+} ? undefined extends E['invokeRequest'] ? true : false : E extends {
+  invokeRequest?: any;
+} ? undefined extends E['invokeRequest'] ? true : false : true : true;
+type ExtractInvokeRequestOptions<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
+  invokeRequest: infer IR;
+} ? IR & {
+  signal?: AbortSignal;
+} : E extends {
+  invokeRequest?: infer IR;
+} ? IR & {
+  signal?: AbortSignal;
+} : {
+  signal?: AbortSignal;
+} : {
+  signal?: AbortSignal;
+};
+type ExtractInvokeResponseOptions<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
+  invokeResponse: infer IR;
+} ? 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 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;
+  invokeResponse?: ExtractInvokeResponseOptions<EC>;
+}> | {
+  response: Res$1;
+  invokeResponse?: ExtractInvokeResponseOptions<EC>;
+};
+declare function isExtendableInvokeResponseLike<Res$1, EC extends EventContext<any, any>>(value: Eventa<unknown> | ReceiveEvent<{
+  response: Res$1;
+  invokeResponse?: unknown;
+}>): value is ReceiveEvent<{
+  response: Res$1;
+  invokeResponse?: ExtractInvokeResponseOptions<EC>;
+}>;
+type Handler<Res$1, Req$1 = any, EC extends EventContext<any, any> = EventContext<any, any>, RawEventOptions = unknown> = (payload: Req$1, 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;
+}
+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>>>;
+}
+/**
+ * Create a unary invoke function (client side).
+ *
+ * It supports unary or streaming requests, but returns a single response.
+ * Use `defineStreamInvoke` when you expect a stream of responses.
+ *
+ * If you want stream input, set `Req` to `ReadableStream<T>` or `AsyncIterable<T>`
+ * (or a union type like `T | ReadableStream<T>` for optional streaming).
+ *
+ * @example
+ * ```ts
+ * // 1) Define eventa once (shared by client/server)
+ * const events = defineInvokeEventa<{ id: string }, { name: string }>()
+ *
+ * // 2) Client: define invoke function
+ * const invoke = defineInvoke(clientCtx, events)
+ *
+ * // 3) Call
+ * const res = await invoke({ name: 'alice' })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Stream request -> unary response
+ * const events = defineInvokeEventa<number, ReadableStream<number>>()
+ *
+ * defineInvokeHandler(serverCtx, events, async (payload) => {
+ *   let sum = 0
+ *   for await (const value of payload) {
+ *     sum += value
+ *   }
+ *
+ *   return sum
+ * })
+ *
+ * const invoke = defineInvoke(clientCtx, events)
+ * const input = new ReadableStream<number>({
+ *   start(controller) {
+ *     controller.enqueue(1)
+ *     controller.enqueue(2)
+ *     controller.close()
+ *   },
+ * })
+ *
+ * const total = await invoke(input)
+ * ```
+ *
+ * @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>;
+/**
+ * Create a map of invoke functions from a map of invoke events (client side).
+ *
+ * @example
+ * ```ts
+ * const events = {
+ *   double: defineInvokeEventa<number, number>(),
+ *   greet: defineInvokeEventa<string, { name: string }>(),
+ * }
+ *
+ * const invokes = defineInvokes(ctx, events)
+ * const result = await invokes.double(2)
+ * ```
+ *
+ * @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>;
+/**
+ * Define a unary invoke handler (server side).
+ *
+ * The handler can accept a unary or streaming request; it must return
+ * a single response (or an extendable response envelope).
+ *
+ * @example
+ * ```ts
+ * const events = defineInvokeEventa<{ id: string }, { name: string }>()
+ *
+ * defineInvokeHandler(serverCtx, events, ({ name }) => ({
+ *   id: `user-${name}`,
+ * }))
+ * ```
+ *
+ * @param ctx Event context on the handler/server side.
+ * @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 {
+  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;
+/**
+ * Define multiple invoke handlers in batch (server side).
+ *
+ * @example
+ * ```ts
+ * const events = {
+ *   double: defineInvokeEventa<number, number>(),
+ *   greet: defineInvokeEventa<string, { name: string }>(),
+ * }
+ *
+ * defineInvokeHandlers(ctx, events, {
+ *   double: value => value * 2,
+ *   greet: ({ name }) => `hi ${name}`,
+ * })
+ * ```
+ *
+ * @param ctx Event context on the handler/server side.
+ * @param events Map of invoke events created by `defineInvokeEventa`.
+ * @param handlers Map of handlers keyed by event name.
+ */
+declare function defineInvokeHandlers<EK extends string, EventMap extends Record<EK, InvokeEventa<any, any, any, any>>, CtxExt = any, EOpts extends {
+  raw?: any;
+} = any>(ctx: InvocableEventContext<CtxExt, EOpts>, events: EventMap, handlers: HandlerMap<EventMap, EOpts>): Record<EK, () => void>;
+/**
+ * Remove one or all invoke handlers for a specific invoke event (server side).
+ *
+ * @example
+ * ```ts
+ * const off = defineInvokeHandler(ctx, events, handler)
+ * off() // remove one handler
+ *
+ * // or remove all handlers for the event:
+ * undefineInvokeHandler(ctx, events)
+ * ```
+ *
+ * @param ctx Event context on the handler/server side.
+ * @param event Invoke event definition created by `defineInvokeEventa`.
+ * @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;
+//#endregion
+//#region src/invoke-extension-transfer.d.ts
+interface WithTransfer<T> {
+  message: T;
+  _transfer?: Transferable[];
+}
+declare function withTransfer<T>(body: T, transfer?: Transferable[]): ExtendableInvokeResponse<T, EventContext<{
+  invokeResponse?: {
+    transfer?: Transferable[];
+  };
+}, any>>;
+//#endregion
+//#region src/invoke-remote-methods.d.ts
+interface InvokeFunctionStubOptions {
+  allow?: boolean;
+  maxDepth?: number;
+  maxFunctions?: number;
+  tagPrefix?: string;
+  onDisallowedTag?: 'ignore' | 'throw';
+  autoDisposeMs?: number;
+  strict?: boolean;
+}
+type RemoteInvokeOptions<EC extends EventContext<any, any>> = ExtractInvokeRequestOptions<EC> & {
+  functionStubs?: boolean | InvokeFunctionStubOptions;
+};
+interface RemoteInvokeResult<Res$1> extends Promise<Res$1> {
+  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>;
+declare function createRemoteMethodTagPrefix(prefix?: string): string;
+/**
+ * Enable "remote method" payloads for invoke: functions in the request body are
+ * serialized into stub descriptors and rehydrated into invoke callers on the
+ * receiving side.
+ *
+ * This is an adapter around the plain-value RPC primitives `defineInvoke` and
+ * `defineInvokeHandler`. It keeps the core invoke APIs clean while offering an
+ * opt-in bridge for function values.
+ *
+ * @example
+ * ```ts
+ * const remote = withRemoteMethods({ allow: true })
+ * const events = defineInvokeEventa<{ output: number }, { helper: (n: number) => Promise<number> }>()
+ *
+ * // server (handler)
+ * remote.defineInvokeHandler(serverCtx, events, async ({ helper }) => {
+ *   const output = await helper(21)
+ *   return { output }
+ * })
+ *
+ * // client (caller)
+ * const invoke = remote.defineInvoke(clientCtx, events)
+ * const result = await invoke({ helper: async n => n * 2 }, { functionStubs: true })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Manual cleanup when you fire-and-forget or cancel midway:
+ * const invoke = remote.defineInvoke(clientCtx, events)
+ * const result = invoke({ helper: () => 'ok' }, { functionStubs: true })
+ * result.dispose()
+ * await result
+ * ```
+ *
+ * Security notes:
+ * - This feature is off by default. Enabling it allows the remote side to call
+ *   back into your process; only use with trusted peers.
+ * - Function stubs are tagged; prefer a unique `tagPrefix` to avoid collisions
+ *   (see `createRemoteMethodTagPrefix`).
+ * - `maxDepth`, `maxFunctions`, and `autoDisposeMs` limit attack surface and
+ *   resource usage. `autoDisposeMs` is useful for fire-and-forget calls.
+ * - Objects are rebuilt with a null prototype to mitigate `__proto__` pollution.
+ * - Enable `strict` to reject malformed `__eventaInvoke` payloads.
+ *
+ * @param defaultOptions Defaults for function stub behavior. Use `{ allow: true }`
+ *        to enable, or provide `maxDepth`, `maxFunctions`, `tagPrefix`,
+ *        `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 {
+    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;
+};
+//#endregion
+//#region src/stream.d.ts
+/**
+ * Create a stream invoke function (client side).
+ *
+ * Use when the response is streamed and the request may be unary or streaming.
+ *
+ * Common patterns:
+ * - Unary request -> stream response (server-streaming)
+ * - Stream request -> stream response (bi-directional streaming)
+ *
+ * @example
+ * ```ts
+ * // 1) Define eventa once (shared by client/server)
+ * const events = defineInvokeEventa<Progress | Result, Params>()
+ *
+ * // 2) Client: define invoke function
+ * const invoke = defineStreamInvoke(clientCtx, events)
+ *
+ * // 3) Call with unary request
+ * for await (const msg of invoke({ name: 'alice' })) {
+ *   console.log(msg)
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Client-streaming request
+ * const input = new ReadableStream<number>({
+ *   start(c) { c.enqueue(1); c.enqueue(2); c.close() },
+ * })
+ *
+ * for await (const msg of invoke(input)) {
+ *   console.log(msg)
+ * }
+ * ```
+ *
+ * @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?: {
+  signal?: AbortSignal;
+} & EO) => ReadableStream<Res$1>;
+type StreamHandler<Res$1, Req$1 = any, RawEventOptions = unknown> = (payload: Req$1, options?: {
+  abortController?: AbortController;
+} & RawEventOptions) => AsyncGenerator<Res$1, void, unknown>;
+/**
+ * Define a stream invoke handler (server side).
+ *
+ * The handler can receive either:
+ * - a unary request `Req`
+ * - a streaming request `ReadableStream<Req>` / `AsyncIterable<Req>`
+ *
+ * It must return an async generator of response messages.
+ *
+ * @example
+ * ```ts
+ * const events = defineInvokeEventa<Progress | Result, Params>()
+ *
+ * defineStreamInvokeHandler(serverCtx, events, async function* (payload) {
+ *   if (isReadableStream<Params>(payload) || isAsyncIterable<Params>(payload)) {
+ *     for await (const item of payload) {
+ *       yield { type: 'progress', value: item }
+ *     }
+ *   }
+ *
+ *   yield { type: 'result', ok: true }
+ * })
+ * ```
+ *
+ * @param serverCtx Event context on the handler/server side.
+ * @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 {
+  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;
+/**
+ * Convert a callback-style handler into a stream handler.
+ *
+ * Use `emit` to push response chunks, and return when done.
+ * Works for unary or streaming requests.
+ *
+ * @example
+ * ```ts
+ * defineStreamInvokeHandler(ctx, events, toStreamHandler(async ({ payload, emit }) => {
+ *   if (isReadableStream<Params>(payload) || isAsyncIterable<Params>(payload)) {
+ *     for await (const item of payload) {
+ *       emit({ type: 'progress', value: item })
+ *     }
+ *
+ *     emit({ type: 'result', ok: true })
+ *     return
+ *   }
+ *
+ *   emit({ type: 'result', ok: true })
+ * }))
+ * ```
+ *
+ * @param handler Callback handler with `emit` for streaming responses.
+ */
+declare function toStreamHandler<Req$1, Res$1, EO extends {
+  raw?: any;
+} = any>(handler: (context: {
+  payload: Req$1;
+  options?: EO;
+  emit: (data: Res$1) => void;
+}) => Promise<void>): StreamHandler<Res$1, Req$1, EO>;
+//#endregion
+//#region src/utils.d.ts
+declare function randomBetween(min: number, max: number): number;
+/**
+ * Checks if a value is an AsyncIterable.
+ *
+ * @param value
+ * @returns True if the value is an AsyncIterable.
+ */
+declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
+/**
+ * Checks if an object is a ReadableStream.
+ *
+ * @link https://github.com/cloudflare/workerd/blob/88e8696ce7a5f8969a7e02a2dcfb6504c17c9e8d/src/cloudflare/internal/streaming-forms.ts#L3
+ * @param obj
+ * @returns True if the object looks like a ReadableStream.
+ */
+declare function isReadableStream<T>(obj?: unknown | null): obj is ReadableStream<T>;
+declare function createAbortError(reason?: unknown): Error;
+declare function isAbortError(error: unknown): error is Error;
+declare function createUntilTriggeredOnce<F extends (...args: any[]) => any, P extends any[] = Parameters<F>, R = ReturnType<F>>(fn: F): {
+  onceTriggered: Promise<Awaited<R>>;
+  wrapper: (...args: P) => Promise<Awaited<R>>;
+};
+declare function createUntilTriggered<P, R>(fn: (...args: P[]) => R): {
+  promise: Promise<void>;
+  handler: () => void;
+};
+declare function createUntil<T>(options?: {
+  intervalHandler?: () => Promise<boolean>;
+  interval?: number;
+}): {
+  promise: Promise<T>;
+  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

package/dist/index.d.mts

@@ -1,5 +1,4 @@
-import { _ as or, a as EventaLike, c as InboundEventa, d as and, f as defineEventa, g as nanoid, h as matchBy, i as EventaFlowDirection, l as InvokeEventConstraint, m as defineOutboundEventa, n as EventTag, o as EventaMatchExpression, p as defineInboundEventa, r as Eventa, s as EventaType, t as DirectionalEventa, u as OutboundEventa } from "./eventa-DWOtUOEf.mjs";
-import { n as EventContextEmitFn, r as createContext, t as EventContext } from "./context-C0RYgQg8.mjs";
-import { C as isSendEvent, S as isReceiveEvent, _ as ReceiveEventStreamEnd, a as InvokeFunction, b as defineInvokeEventa, c as defineInvokeHandler, d as isExtendableInvokeResponseLike, f as undefineInvokeHandler, g as ReceiveEventError, h as ReceiveEvent, i as InvocableEventContext, l as defineInvokeHandlers, m as InvokeEventa, n as Handler, o as InvokeFunctionMap, p as InvokeEventType, r as HandlerMap, s as defineInvoke, t as ExtendableInvokeResponse, u as defineInvokes, v as SendEvent, x as isInvokeEventa, y as SendEventError } from "./invoke-BB3tmZlr.mjs";
-import { n as defineStreamInvokeHandler, r as toStreamHandler, t as defineStreamInvoke } from "./index-DXQGU0bi.mjs";
-export { DirectionalEventa, EventContext, EventContextEmitFn, EventTag, Eventa, EventaFlowDirection, EventaLike, EventaMatchExpression, EventaType, ExtendableInvokeResponse, Handler, HandlerMap, InboundEventa, InvocableEventContext, InvokeEventConstraint, InvokeEventType, InvokeEventa, InvokeFunction, InvokeFunctionMap, OutboundEventa, ReceiveEvent, ReceiveEventError, ReceiveEventStreamEnd, SendEvent, SendEventError, and, createContext, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, matchBy, nanoid, or, toStreamHandler, undefineInvokeHandler };
+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 };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-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-BygZzwvo.mjs";
-import { a as defineInvokeHandler, c as isExtendableInvokeResponseLike, d as defineInvokeEventa, f as isInvokeEventa, i as defineInvoke, l as undefineInvokeHandler, m as isSendEvent, n as defineStreamInvokeHandler, o as defineInvokeHandlers, p as isReceiveEvent, r as toStreamHandler, s as defineInvokes, t as defineStreamInvoke, u as InvokeEventType } from "./src-Bnf7MdlN.mjs";
+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, createContext, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, matchBy, nanoid, or, toStreamHandler, undefineInvokeHandler };
+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-C-bIJqJC.mjs → internal-ChLglF1N.mjs}

@@ -1,4 +1,4 @@
-import { l as nanoid } from "./context-BygZzwvo.mjs";
+import { l as nanoid } from "./context-BMDJMapI.mjs";
 
 //#region src/adapters/websocket/internal.ts
 function generateWebsocketPayload(type, payload) {
@@ -15,4 +15,4 @@ function parseWebsocketPayload(data) {
 
 //#endregion
 export { parseWebsocketPayload as n, generateWebsocketPayload as t };
-//# sourceMappingURL=internal-C-bIJqJC.mjs.map
+//# sourceMappingURL=internal-ChLglF1N.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"internal-C-bIJqJC.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-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"}

package/dist/{shared-BExRc0zC.mjs → shared-CA_i_yfR.mjs}

@@ -1,4 +1,4 @@
-import { a as defineEventa, l as nanoid } from "./context-BygZzwvo.mjs";
+import { a as defineEventa, l as nanoid } from "./context-BMDJMapI.mjs";
 
 //#region src/adapters/electron/internal.ts
 function generatePayload(type, payload) {
@@ -18,4 +18,4 @@ const errorEvent = { ...defineEventa() };
 
 //#endregion
 export { generatePayload as n, parsePayload as r, errorEvent as t };
-//# sourceMappingURL=shared-BExRc0zC.mjs.map
+//# sourceMappingURL=shared-CA_i_yfR.mjs.map

package/dist/{shared-BExRc0zC.mjs.map → shared-CA_i_yfR.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"shared-BExRc0zC.mjs","names":[],"sources":["../src/adapters/electron/internal.ts","../src/adapters/electron/shared.ts"],"sourcesContent":["import type { EventTag } from '../..'\nimport type { Payload as CustomEventDetailDetail } from './shared'\n\nimport { nanoid } from '../..'\n\nexport function generatePayload<T>(type: EventTag<any, any>, payload: T): CustomEventDetailDetail<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n  }\n}\n\nexport function parsePayload<T>(data: unknown): CustomEventDetailDetail<T> {\n  return data as CustomEventDetailDetail<T>\n}\n","import type { EventTag } from '../../eventa'\n\nimport { defineEventa } from '../../eventa'\n\nexport interface Payload<T> {\n  id: string\n  type: EventTag<any, any>\n  payload: T\n}\n\nexport const errorEvent = { ...defineEventa<{ error: unknown }>() }\n"],"mappings":";;;AAKA,SAAgB,gBAAmB,MAA0B,SAAwC;AACnG,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACD;;AAGH,SAAgB,aAAgB,MAA2C;AACzE,QAAO;;;;;ACJT,MAAa,aAAa,EAAE,GAAG,cAAkC,EAAE"}
+{"version":3,"file":"shared-CA_i_yfR.mjs","names":[],"sources":["../src/adapters/electron/internal.ts","../src/adapters/electron/shared.ts"],"sourcesContent":["import type { EventTag } from '../..'\nimport type { Payload as CustomEventDetailDetail } from './shared'\n\nimport { nanoid } from '../..'\n\nexport function generatePayload<T>(type: EventTag<any, any>, payload: T): CustomEventDetailDetail<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n  }\n}\n\nexport function parsePayload<T>(data: unknown): CustomEventDetailDetail<T> {\n  return data as CustomEventDetailDetail<T>\n}\n","import type { EventTag } from '../../eventa'\n\nimport { defineEventa } from '../../eventa'\n\nexport interface Payload<T> {\n  id: string\n  type: EventTag<any, any>\n  payload: T\n}\n\nexport const errorEvent = { ...defineEventa<{ error: unknown }>() }\n"],"mappings":";;;AAKA,SAAgB,gBAAmB,MAA0B,SAAwC;AACnG,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACD;;AAGH,SAAgB,aAAgB,MAA2C;AACzE,QAAO;;;;;ACJT,MAAa,aAAa,EAAE,GAAG,cAAkC,EAAE"}

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

@@ -1,5 +1,5 @@
-import { a as defineEventa, l as nanoid, s as defineOutboundEventa } from "./context-BygZzwvo.mjs";
-import { c as isExtendableInvokeResponseLike } from "./src-Bnf7MdlN.mjs";
+import { a as defineEventa, l as nanoid, s as defineOutboundEventa } from "./context-BMDJMapI.mjs";
+import { d as isExtendableInvokeResponseLike } from "./src-eMqISeHo.mjs";
 
 //#region src/adapters/webworkers/internal.ts
 function generateWorkerPayload(type, payload) {
@@ -59,13 +59,7 @@ function normalizeOnListenerParameters(event, options) {
 		transfer
 	};
 }
-function withTransfer(body, transfer) {
-	return {
-		response: body,
-		invokeResponse: { transfer: transfer ?? [] }
-	};
-}
 
 //#endregion
-export { withTransfer as a, parseWorkerPayload as c, normalizeOnListenerParameters as i, defineWorkerEventa as n, workerErrorEvent as o, isWorkerEventa as r, generateWorkerPayload as s, defineOutboundWorkerEventa as t };
-//# sourceMappingURL=shared-DRAsaLuo.mjs.map
+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

package/dist/shared-CRxfs1TC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-CRxfs1TC.mjs","names":["eventPayload: any","transfer: Transferable[] | undefined"],"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;AAClE,MAAa,0BAA0B,cAAgD;AAEvF,SAAgB,8BAA8B,OAAoB,SAAmD;CACnH,IAAIA,eAAoB,MAAM;CAC9B,IAAIC;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,SACpG;MAAI,MAAM,QAAQ,QAAQ,SAAS,CACjC,YAAW,QAAQ;;AAIvB,QAAO;EACL,MAAM;EACN;EACD"}

package/dist/{shared-Q10kRJA8.d.mts → shared-Cd4CLAdD.d.mts}

@@ -1,4 +1,4 @@
-import { n as EventTag, s as EventaType } from "./eventa-DWOtUOEf.mjs";
+import { n as EventTag, s as EventaType } from "./eventa-AJyw28P8.mjs";
 
 //#region src/adapters/electron/shared.d.ts
 interface Payload<T> {
@@ -15,4 +15,4 @@ declare const errorEvent: {
 };
 //#endregion
 export { errorEvent as n, Payload as t };
-//# sourceMappingURL=shared-Q10kRJA8.d.mts.map
+//# sourceMappingURL=shared-Cd4CLAdD.d.mts.map