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

package/dist/src-DZ7si0kE.mjs

@@ -0,0 +1,1169 @@
+import { a as defineEventa, l as nanoid } from "./context-ex8urwfs.mjs";
+
+//#region src/context-extension-invoke-internal.ts
+/**
+* Read the internal invoke configuration from context extensions, if present.
+* This is used by defineInvoke to determine which events should abort inflight invokes.
+*/
+function getContextExtensionInvokeInternalConfig(ctx) {
+	const extensions = ctx.extensions;
+	if (!extensions || typeof extensions !== "object") return;
+	const internal = extensions.__internal;
+	if (!internal || typeof internal !== "object") return;
+	const invoke = internal.invoke;
+	if (!invoke || typeof invoke !== "object") return;
+	return invoke;
+}
+/**
+* Register a fatal event/match expression that should terminate pending invokes.
+* Adapters call this to wire their error events (e.g. worker error) into invoke.
+*/
+function registerInvokeAbortEventListeners(ctx, eventOrMatch) {
+	const extensions = ctx.extensions ?? {};
+	const internal = extensions.__internal ?? {};
+	const invokeInternal = internal.invoke ?? {};
+	const abortOnEvents = Array.isArray(invokeInternal.abortOnEvents) ? invokeInternal.abortOnEvents : [];
+	if (!abortOnEvents.includes(eventOrMatch)) abortOnEvents.push(eventOrMatch);
+	invokeInternal.abortOnEvents = abortOnEvents;
+	internal.invoke = invokeInternal;
+	extensions.__internal = internal;
+	ctx.extensions = extensions;
+	return invokeInternal;
+}
+
+//#endregion
+//#region src/invoke-shared.ts
+let InvokeEventType = /* @__PURE__ */ function(InvokeEventType$1) {
+	InvokeEventType$1[InvokeEventType$1["SendEvent"] = 0] = "SendEvent";
+	InvokeEventType$1[InvokeEventType$1["SendEventError"] = 1] = "SendEventError";
+	InvokeEventType$1[InvokeEventType$1["SendEventStreamEnd"] = 2] = "SendEventStreamEnd";
+	InvokeEventType$1[InvokeEventType$1["SendEventAbort"] = 3] = "SendEventAbort";
+	InvokeEventType$1[InvokeEventType$1["ReceiveEvent"] = 4] = "ReceiveEvent";
+	InvokeEventType$1[InvokeEventType$1["ReceiveEventError"] = 5] = "ReceiveEventError";
+	InvokeEventType$1[InvokeEventType$1["ReceiveEventStreamEnd"] = 6] = "ReceiveEventStreamEnd";
+	return InvokeEventType$1;
+}({});
+function defineInvokeEventa(tag) {
+	if (!tag) tag = nanoid();
+	return {
+		sendEvent: {
+			...defineEventa(`${tag}-send`),
+			invokeType: InvokeEventType.SendEvent
+		},
+		sendEventError: {
+			...defineEventa(`${tag}-send-error`),
+			invokeType: InvokeEventType.SendEventError
+		},
+		sendEventStreamEnd: {
+			...defineEventa(`${tag}-send-stream-end`),
+			invokeType: InvokeEventType.SendEventStreamEnd
+		},
+		sendEventAbort: {
+			...defineEventa(`${tag}-send-abort`),
+			invokeType: InvokeEventType.SendEventAbort
+		},
+		receiveEvent: {
+			...defineEventa(`${tag}-receive`),
+			invokeType: InvokeEventType.ReceiveEvent
+		},
+		receiveEventError: {
+			...defineEventa(`${tag}-receive-error`),
+			invokeType: InvokeEventType.ReceiveEventError
+		},
+		receiveEventStreamEnd: {
+			...defineEventa(`${tag}-receive-stream-end`),
+			invokeType: InvokeEventType.ReceiveEventStreamEnd
+		}
+	};
+}
+function isInvokeEventa(event) {
+	if (typeof event !== "object") return false;
+	if ("invokeType" in event) return true;
+	return false;
+}
+function isSendEvent(event) {
+	if (!isInvokeEventa(event)) return false;
+	return event.invokeType === InvokeEventType.SendEvent || event.invokeType === InvokeEventType.SendEventError || event.invokeType === InvokeEventType.SendEventStreamEnd || event.invokeType === InvokeEventType.SendEventAbort;
+}
+function isReceiveEvent(event) {
+	if (!isInvokeEventa(event)) return false;
+	return event.invokeType === InvokeEventType.ReceiveEvent || event.invokeType === InvokeEventType.ReceiveEventError || event.invokeType === InvokeEventType.ReceiveEventStreamEnd;
+}
+
+//#endregion
+//#region src/utils.ts
+function randomBetween(min, max) {
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+* Checks if a value is an AsyncIterable.
+*
+* @param value
+* @returns True if the value is an AsyncIterable.
+*/
+function isAsyncIterable(value) {
+	return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+/**
+* 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.
+*/
+function isReadableStream(obj) {
+	return !!(obj && typeof obj === "object" && "getReader" in obj && typeof obj.getReader === "function");
+}
+function createAbortError(reason) {
+	if (reason instanceof Error && reason.name === "AbortError") return reason;
+	if (typeof DOMException !== "undefined") try {
+		return new DOMException(reason ? String(reason) : "Aborted", "AbortError");
+	} catch {}
+	const error = reason instanceof Error ? reason : new Error(reason ? String(reason) : "Aborted");
+	error.name = "AbortError";
+	return error;
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function createUntilTriggeredOnce(fn) {
+	let resolve;
+	const promise = new Promise((res) => {
+		resolve = res;
+	});
+	const handler = async (...args) => {
+		const res = await fn(...args);
+		resolve(res);
+		return res;
+	};
+	return {
+		onceTriggered: promise,
+		wrapper: handler
+	};
+}
+function createUntilTriggered(fn) {
+	let resolve;
+	const promise = new Promise((res) => {
+		resolve = res;
+	});
+	const handler = (...args) => {
+		resolve();
+		return fn(...args);
+	};
+	return {
+		promise,
+		handler
+	};
+}
+function createUntil(options) {
+	let resolve;
+	const promise = new Promise((res) => {
+		resolve = res;
+	});
+	if (options?.intervalHandler) setInterval(() => {
+		options?.intervalHandler?.().then((shouldResolve) => {
+			if (shouldResolve) resolve(void 0);
+		});
+	}, options.interval ?? 50);
+	return {
+		promise,
+		handler: resolve
+	};
+}
+
+//#endregion
+//#region src/invoke.ts
+function isExtendableInvokeResponseLike(value) {
+	if (!isReceiveEvent(value)) return false;
+	return typeof value.body?.content === "object" && value.body?.content != null && "response" in value.body.content && (!("invokeResponse" in value.body.content) || "invokeResponse" in value.body.content && (typeof value.body.content.invokeResponse === "object" || typeof value.body.content.invokeResponse === "undefined"));
+}
+/**
+* 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`.
+*/
+function defineInvoke(ctx, event) {
+	async function getContext() {
+		if (typeof ctx === "function") {
+			const resolvedCtx = ctx();
+			if (resolvedCtx instanceof Promise) return await resolvedCtx;
+			return resolvedCtx;
+		}
+		return ctx;
+	}
+	function _invoke(req, options) {
+		return new Promise((resolve, reject) => {
+			getContext().then((ctx$1) => {
+				const invokeId = nanoid();
+				const invokeReceiveEvent = defineEventa(`${event.receiveEvent.id}-${invokeId}`);
+				const invokeReceiveEventError = defineEventa(`${event.receiveEventError.id}-${invokeId}`);
+				const { signal, ...emitOptions } = options ?? {};
+				let finished = false;
+				const onAbort = () => {
+					ctx$1.emit(event.sendEventAbort, {
+						invokeId,
+						content: signal?.reason
+					}, emitOptions);
+					finishReject(createAbortError(signal?.reason));
+				};
+				const invokeInternalConfig = getContextExtensionInvokeInternalConfig(ctx$1);
+				const abortOffs = [];
+				const onAbortEvent = (payload, eventOptions) => {
+					const mappedError = invokeInternalConfig?.mapAbortError?.(payload, eventOptions);
+					if (typeof mappedError !== "undefined") {
+						finishReject(mappedError);
+						return;
+					}
+					const body = payload?.body;
+					finishReject(body && typeof body === "object" && "error" in body ? body.error : typeof body !== "undefined" ? body : payload);
+				};
+				const cleanup = () => {
+					ctx$1.off(invokeReceiveEvent);
+					ctx$1.off(invokeReceiveEventError);
+					for (const off of abortOffs) off();
+					if (signal) signal.removeEventListener("abort", onAbort);
+				};
+				const finishReject = (error) => {
+					if (finished) return;
+					finished = true;
+					reject(error);
+					cleanup();
+				};
+				const finishResolve = (value) => {
+					if (finished) return;
+					finished = true;
+					resolve(value);
+					cleanup();
+				};
+				ctx$1.on(invokeReceiveEvent, (payload) => {
+					if (!payload.body) return;
+					if (payload.body.invokeId !== invokeId) return;
+					const { content } = payload.body;
+					finishResolve(content);
+				});
+				ctx$1.on(invokeReceiveEventError, (payload) => {
+					if (!payload.body) return;
+					if (payload.body.invokeId !== invokeId) return;
+					const { error } = payload.body.content;
+					finishReject(error);
+				});
+				if (invokeInternalConfig?.abortOnEvents?.length) for (const eventOrMatch of invokeInternalConfig.abortOnEvents) abortOffs.push(ctx$1.on(eventOrMatch, onAbortEvent));
+				if (signal) {
+					if (signal.aborted) {
+						onAbort();
+						return;
+					}
+					signal.addEventListener("abort", onAbort, { once: true });
+				}
+				if (!isReadableStream(req) && !isAsyncIterable(req)) ctx$1.emit(event.sendEvent, {
+					invokeId,
+					content: req
+				}, emitOptions);
+				else {
+					const sendChunk = (chunk) => {
+						if (finished) return;
+						ctx$1.emit(event.sendEvent, {
+							invokeId,
+							content: chunk,
+							isReqStream: true
+						}, emitOptions);
+					};
+					const sendEnd = () => {
+						if (finished) return;
+						ctx$1.emit(event.sendEventStreamEnd, {
+							invokeId,
+							content: void 0
+						}, emitOptions);
+					};
+					const pump = async () => {
+						try {
+							for await (const chunk of req) {
+								if (signal?.aborted) return;
+								sendChunk(chunk);
+							}
+							sendEnd();
+						} catch (error) {
+							if (signal?.aborted) return;
+							if (isAbortError(error)) {
+								ctx$1.emit(event.sendEventAbort, {
+									invokeId,
+									content: error
+								}, emitOptions);
+								return;
+							}
+							ctx$1.emit(event.sendEventError, {
+								invokeId,
+								content: error
+							}, emitOptions);
+						}
+					};
+					pump();
+				}
+			});
+		});
+	}
+	return _invoke;
+}
+/**
+* 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`.
+*/
+function defineInvokes(ctx, events) {
+	return Object.keys(events).reduce((invokes, key) => {
+		invokes[key] = defineInvoke(ctx, events[key]);
+		return invokes;
+	}, {});
+}
+/**
+* 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).
+*/
+function defineInvokeHandler(ctx, event, handler) {
+	if (!ctx.invokeHandlers) ctx.invokeHandlers = /* @__PURE__ */ new Map();
+	let handlers = ctx.invokeHandlers?.get(event.sendEvent.id);
+	if (!handlers) {
+		handlers = /* @__PURE__ */ new Map();
+		ctx.invokeHandlers?.set(event.sendEvent.id, handlers);
+	}
+	let internalHandler = handlers.get(handler);
+	if (!internalHandler) {
+		const streamStates = /* @__PURE__ */ new Map();
+		const abortControllers = /* @__PURE__ */ new Map();
+		const abortReasons = /* @__PURE__ */ new Map();
+		const scheduleAbort = (controller, reason) => {
+			if (typeof queueMicrotask !== "undefined") {
+				queueMicrotask(() => controller.abort(reason));
+				return;
+			}
+			Promise.resolve().then(() => controller.abort(reason));
+		};
+		const handleInvoke = async (invokeId, payload, options) => {
+			const abortController = new AbortController();
+			abortControllers.set(invokeId, abortController);
+			if (abortReasons.has(invokeId)) scheduleAbort(abortController, abortReasons.get(invokeId));
+			const handlerOptions = options ? {
+				...options,
+				abortController
+			} : { abortController };
+			try {
+				const response = await handler(payload, handlerOptions);
+				ctx.emit({
+					...defineEventa(`${event.receiveEvent.id}-${invokeId}`),
+					invokeType: event.receiveEvent.invokeType
+				}, {
+					invokeId,
+					content: response
+				}, options);
+			} catch (error) {
+				ctx.emit({
+					...defineEventa(`${event.receiveEventError.id}-${invokeId}`),
+					invokeType: event.receiveEventError.invokeType
+				}, {
+					invokeId,
+					content: { error }
+				}, options);
+			} finally {
+				abortControllers.delete(invokeId);
+				abortReasons.delete(invokeId);
+			}
+		};
+		const onSend = async (payload, options) => {
+			if (!payload.body) return;
+			if (!payload.body.invokeId) return;
+			const invokeId = payload.body.invokeId;
+			if (payload.body.isReqStream) {
+				let controller = streamStates.get(invokeId);
+				if (!controller) {
+					let localController;
+					const reqStream = new ReadableStream({ start(c) {
+						localController = c;
+					} });
+					controller = localController;
+					streamStates.set(invokeId, controller);
+					handleInvoke(invokeId, reqStream, options);
+				}
+				controller.enqueue(payload.body.content);
+				return;
+			}
+			handleInvoke(invokeId, payload.body?.content, options);
+		};
+		const onSendStreamEnd = (payload, options) => {
+			if (!payload.body) return;
+			if (!payload.body.invokeId) return;
+			const invokeId = payload.body.invokeId;
+			let controller = streamStates.get(invokeId);
+			if (!controller) {
+				let localController;
+				const reqStream = new ReadableStream({ start(c) {
+					localController = c;
+				} });
+				controller = localController;
+				streamStates.set(invokeId, controller);
+				handleInvoke(invokeId, reqStream, options);
+			}
+			controller.close();
+			streamStates.delete(invokeId);
+		};
+		const onSendAbort = (payload, options) => {
+			if (!payload.body) return;
+			if (!payload.body.invokeId) return;
+			const invokeId = payload.body.invokeId;
+			const reason = payload.body.content;
+			const abortController = abortControllers.get(invokeId);
+			if (!abortController) {
+				abortReasons.set(invokeId, reason);
+				let streamController$1 = streamStates.get(invokeId);
+				if (!streamController$1) {
+					let localController;
+					const reqStream = new ReadableStream({ start(c) {
+						localController = c;
+					} });
+					streamController$1 = localController;
+					streamStates.set(invokeId, streamController$1);
+					handleInvoke(invokeId, reqStream, options);
+				}
+				streamController$1.error(createAbortError(reason));
+				streamStates.delete(invokeId);
+				return;
+			}
+			scheduleAbort(abortController, reason);
+			const streamController = streamStates.get(invokeId);
+			if (streamController) {
+				streamController.error(createAbortError(reason));
+				streamStates.delete(invokeId);
+			}
+		};
+		internalHandler = {
+			onSend,
+			onSendStreamEnd,
+			onSendAbort
+		};
+		handlers.set(handler, internalHandler);
+		ctx.on(event.sendEvent, internalHandler.onSend);
+		ctx.on(event.sendEventStreamEnd, internalHandler.onSendStreamEnd);
+		ctx.on(event.sendEventAbort, internalHandler.onSendAbort);
+	}
+	return () => {
+		ctx.off(event.sendEvent, internalHandler.onSend);
+		ctx.off(event.sendEventStreamEnd, internalHandler.onSendStreamEnd);
+		ctx.off(event.sendEventAbort, internalHandler.onSendAbort);
+	};
+}
+/**
+* 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.
+*/
+function defineInvokeHandlers(ctx, events, handlers) {
+	const eventKeys = Object.keys(events);
+	const handlerKeys = new Set(Object.keys(handlers));
+	if (eventKeys.length !== handlerKeys.size || !eventKeys.every((key) => handlerKeys.has(key))) throw new Error("The keys of events and handlers must match.");
+	return eventKeys.reduce((returnValues, key) => {
+		returnValues[key] = defineInvokeHandler(ctx, events[key], handlers[key]);
+		return returnValues;
+	}, {});
+}
+/**
+* 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
+*/
+function undefineInvokeHandler(ctx, event, handler) {
+	if (!ctx.invokeHandlers) return false;
+	const handlers = ctx.invokeHandlers?.get(event.sendEvent.id);
+	if (!handlers) return false;
+	if (handler) {
+		const internalHandler = handlers.get(handler);
+		if (!internalHandler) return false;
+		ctx.off(event.sendEvent, internalHandler.onSend);
+		ctx.off(event.sendEventStreamEnd, internalHandler.onSendStreamEnd);
+		ctx.off(event.sendEventAbort, internalHandler.onSendAbort);
+		ctx.invokeHandlers.delete(event.sendEvent.id);
+		return true;
+	}
+	let returnValue = false;
+	for (const internalHandlers of handlers.values()) {
+		ctx.off(event.sendEvent, internalHandlers.onSend);
+		ctx.off(event.sendEventStreamEnd, internalHandlers.onSendStreamEnd);
+		ctx.off(event.sendEventAbort, internalHandlers.onSendAbort);
+		returnValue = true;
+	}
+	ctx.invokeHandlers.delete(event.sendEvent.id);
+	return returnValue;
+}
+
+//#endregion
+//#region src/invoke-extension-transfer.ts
+function withTransfer(body, transfer) {
+	return {
+		response: body,
+		invokeResponse: { transfer: transfer ?? [] }
+	};
+}
+
+//#endregion
+//#region src/invoke-remote-methods.ts
+const DEFAULT_FUNCTION_STUB_OPTIONS = {
+	maxDepth: 32,
+	maxFunctions: 32,
+	tagPrefix: "eventa-invoke-fn-",
+	onDisallowedTag: "ignore",
+	autoDisposeMs: 0,
+	strict: false
+};
+function createRemoteMethodTagPrefix(prefix = DEFAULT_FUNCTION_STUB_OPTIONS.tagPrefix) {
+	return `${prefix}${nanoid()}-`;
+}
+function normalizeFunctionStubOptions(options) {
+	if (options === true) return {
+		allow: true,
+		...DEFAULT_FUNCTION_STUB_OPTIONS
+	};
+	if (!options) return {
+		allow: false,
+		...DEFAULT_FUNCTION_STUB_OPTIONS
+	};
+	return {
+		allow: options.allow ?? true,
+		maxDepth: options.maxDepth ?? DEFAULT_FUNCTION_STUB_OPTIONS.maxDepth,
+		maxFunctions: options.maxFunctions ?? DEFAULT_FUNCTION_STUB_OPTIONS.maxFunctions,
+		tagPrefix: options.tagPrefix ?? DEFAULT_FUNCTION_STUB_OPTIONS.tagPrefix,
+		onDisallowedTag: options.onDisallowedTag ?? DEFAULT_FUNCTION_STUB_OPTIONS.onDisallowedTag,
+		autoDisposeMs: options.autoDisposeMs ?? DEFAULT_FUNCTION_STUB_OPTIONS.autoDisposeMs,
+		strict: options.strict ?? DEFAULT_FUNCTION_STUB_OPTIONS.strict
+	};
+}
+function resolveFunctionStubOptions(defaults, override) {
+	const base = normalizeFunctionStubOptions(defaults);
+	if (typeof override === "undefined") return base;
+	if (typeof override === "boolean") return {
+		...base,
+		allow: override
+	};
+	return {
+		...base,
+		...normalizeFunctionStubOptions(override)
+	};
+}
+function isPlainObject(value) {
+	if (value == null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isInvokeFunctionStubPayload(value) {
+	if (!isPlainObject(value)) return false;
+	if (!("__eventaInvoke" in value)) return false;
+	const stub = value.__eventaInvoke;
+	return !!stub && typeof stub === "object" && typeof stub.tag === "string";
+}
+function hasInvokeFunctionStubKey(value) {
+	return isPlainObject(value) && "__eventaInvoke" in value;
+}
+function serializeInvokeFunctionPayload(value, ctx, options) {
+	if (!options.allow) return {
+		value,
+		dispose: () => void 0
+	};
+	let functionCount = 0;
+	const seen = /* @__PURE__ */ new WeakMap();
+	const disposers = [];
+	const walk = (input, depth) => {
+		if (typeof input === "function") {
+			if (functionCount >= options.maxFunctions) throw new Error(`Too many function stubs in invoke payload (max ${options.maxFunctions}).`);
+			functionCount += 1;
+			const tag = `${options.tagPrefix}${nanoid()}`;
+			const off = defineInvokeHandler(ctx, defineInvokeEventa(tag), (payload, handlerOptions) => {
+				return input(payload, handlerOptions);
+			});
+			disposers.push(off);
+			return { __eventaInvoke: { tag } };
+		}
+		if (input == null || typeof input !== "object") return input;
+		if (depth > options.maxDepth) throw new Error(`Invoke payload is too deep (max ${options.maxDepth}).`);
+		if (seen.has(input)) return seen.get(input);
+		if (Array.isArray(input)) {
+			const output$1 = Array.from({ length: input.length });
+			seen.set(input, output$1);
+			for (let i = 0; i < input.length; i += 1) output$1[i] = walk(input[i], depth + 1);
+			return output$1;
+		}
+		if (!isPlainObject(input)) return input;
+		const output = Object.create(null);
+		seen.set(input, output);
+		for (const [key, child] of Object.entries(input)) output[key] = walk(child, depth + 1);
+		return output;
+	};
+	return {
+		value: walk(value, 0),
+		dispose: () => {
+			for (const off of disposers) off();
+		}
+	};
+}
+function deserializeInvokeFunctionPayload(value, ctx, options) {
+	if (!options.allow) return value;
+	let functionCount = 0;
+	const seen = /* @__PURE__ */ new WeakMap();
+	const walk = (input, depth) => {
+		if (input == null || typeof input !== "object") return input;
+		if (depth > options.maxDepth) throw new Error(`Invoke payload is too deep (max ${options.maxDepth}).`);
+		if (isInvokeFunctionStubPayload(input)) {
+			if (functionCount >= options.maxFunctions) throw new Error(`Too many function stubs in invoke payload (max ${options.maxFunctions}).`);
+			const tag = input.__eventaInvoke.tag;
+			if (options.tagPrefix && !tag.startsWith(options.tagPrefix)) {
+				if (options.onDisallowedTag === "throw") throw new Error(`Invoke function tag not allowed: ${tag}`);
+				return input;
+			}
+			functionCount += 1;
+			return defineInvoke(ctx, defineInvokeEventa(tag));
+		} else if (options.strict && hasInvokeFunctionStubKey(input)) throw new Error("Invalid invoke function stub payload.");
+		if (seen.has(input)) return seen.get(input);
+		if (Array.isArray(input)) {
+			const output$1 = Array.from({ length: input.length });
+			seen.set(input, output$1);
+			for (let i = 0; i < input.length; i += 1) output$1[i] = walk(input[i], depth + 1);
+			return output$1;
+		}
+		if (!isPlainObject(input)) return input;
+		const output = Object.create(null);
+		seen.set(input, output);
+		for (const [key, child] of Object.entries(input)) output[key] = walk(child, depth + 1);
+		return output;
+	};
+	return walk(value, 0);
+}
+/**
+* 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.
+*/
+function withRemoteMethods(defaultOptions) {
+	return {
+		defineInvoke(ctx, event) {
+			const baseInvoke = defineInvoke(ctx, event);
+			const invoke = ((req, options) => {
+				const { functionStubs, ...invokeOptions } = options ?? {};
+				const normalizedOptions = resolveFunctionStubOptions(defaultOptions, functionStubs);
+				if (!normalizedOptions.allow) {
+					const wrapped$1 = baseInvoke(req, invokeOptions);
+					wrapped$1.dispose = () => void 0;
+					return wrapped$1;
+				}
+				let serialized;
+				try {
+					serialized = serializeInvokeFunctionPayload(req, ctx, normalizedOptions);
+				} catch (error) {
+					const rejected = Promise.reject(error);
+					rejected.dispose = () => void 0;
+					return rejected;
+				}
+				let disposed = false;
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					serialized.dispose();
+				};
+				let autoDisposeTimer;
+				if (normalizedOptions.autoDisposeMs > 0) autoDisposeTimer = setTimeout(() => {
+					dispose();
+				}, normalizedOptions.autoDisposeMs);
+				const finalize = () => {
+					if (autoDisposeTimer) clearTimeout(autoDisposeTimer);
+					dispose();
+				};
+				const wrapped = baseInvoke(serialized.value, invokeOptions).finally(finalize);
+				wrapped.dispose = finalize;
+				return wrapped;
+			});
+			return invoke;
+		},
+		defineInvokeHandler(ctx, event, handler) {
+			const normalizedOptions = resolveFunctionStubOptions(defaultOptions);
+			return defineInvokeHandler(ctx, event, async (payload, options) => {
+				return handler(normalizedOptions.allow ? deserializeInvokeFunctionPayload(payload, ctx, normalizedOptions) : payload, options);
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/stream.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`.
+*/
+function defineStreamInvoke(clientCtx, event) {
+	return (req, options) => {
+		const invokeId = nanoid();
+		const { signal, ...emitOptions } = options ?? {};
+		let onAbort;
+		const invokeReceiveEvent = defineEventa(`${event.receiveEvent.id}-${invokeId}`);
+		const invokeReceiveEventError = defineEventa(`${event.receiveEventError.id}-${invokeId}`);
+		const invokeReceiveEventStreamEnd = defineEventa(`${event.receiveEventStreamEnd.id}-${invokeId}`);
+		const stream = new ReadableStream({
+			start(controller) {
+				const cleanup = () => {
+					clientCtx.off(invokeReceiveEvent);
+					clientCtx.off(invokeReceiveEventError);
+					clientCtx.off(invokeReceiveEventStreamEnd);
+					if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+				};
+				onAbort = () => {
+					clientCtx.emit(event.sendEventAbort, {
+						invokeId,
+						content: signal?.reason
+					}, emitOptions);
+					controller.error(createAbortError(signal?.reason));
+					cleanup();
+				};
+				clientCtx.on(invokeReceiveEvent, (payload) => {
+					if (!payload.body) return;
+					if (payload.body.invokeId !== invokeId) return;
+					controller.enqueue(payload.body.content);
+				});
+				clientCtx.on(invokeReceiveEventError, (payload) => {
+					if (!payload.body) return;
+					if (payload.body.invokeId !== invokeId) return;
+					controller.error(payload.body.content.error);
+					cleanup();
+				});
+				clientCtx.on(invokeReceiveEventStreamEnd, (payload) => {
+					if (!payload.body) return;
+					if (payload.body.invokeId !== invokeId) return;
+					controller.close();
+					cleanup();
+				});
+				if (signal && onAbort) {
+					if (signal.aborted) {
+						onAbort();
+						return;
+					}
+					signal.addEventListener("abort", onAbort, { once: true });
+				}
+			},
+			cancel(reason) {
+				clientCtx.emit(event.sendEventAbort, {
+					invokeId,
+					content: reason
+				}, emitOptions);
+				clientCtx.off(invokeReceiveEvent);
+				clientCtx.off(invokeReceiveEventError);
+				clientCtx.off(invokeReceiveEventStreamEnd);
+				if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+			}
+		});
+		if (isReadableStream(req) || isAsyncIterable(req)) {
+			const sendChunk = (chunk) => {
+				clientCtx.emit(event.sendEvent, {
+					invokeId,
+					content: chunk,
+					isReqStream: true
+				}, emitOptions);
+			};
+			const sendEnd = () => {
+				clientCtx.emit(event.sendEventStreamEnd, {
+					invokeId,
+					content: void 0
+				}, emitOptions);
+			};
+			const pump = async () => {
+				try {
+					for await (const chunk of req) {
+						if (signal?.aborted) return;
+						sendChunk(chunk);
+					}
+					sendEnd();
+				} catch (error) {
+					if (signal?.aborted) return;
+					if (isAbortError(error)) {
+						clientCtx.emit(event.sendEventAbort, {
+							invokeId,
+							content: error
+						}, emitOptions);
+						return;
+					}
+					clientCtx.emit(event.sendEventError, {
+						invokeId,
+						content: error
+					}, emitOptions);
+				}
+			};
+			pump();
+		} else clientCtx.emit(event.sendEvent, {
+			invokeId,
+			content: req
+		}, emitOptions);
+		return stream;
+	};
+}
+/**
+* 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.
+*/
+function defineStreamInvokeHandler(serverCtx, event, fn) {
+	const invokeReceiveEvent = (invokeId) => defineEventa(`${event.receiveEvent.id}-${invokeId}`);
+	const invokeReceiveEventError = (invokeId) => defineEventa(`${event.receiveEventError.id}-${invokeId}`);
+	const invokeReceiveEventStreamEnd = (invokeId) => defineEventa(`${event.receiveEventStreamEnd.id}-${invokeId}`);
+	const streamStates = /* @__PURE__ */ new Map();
+	const abortControllers = /* @__PURE__ */ new Map();
+	const abortReasons = /* @__PURE__ */ new Map();
+	const scheduleAbort = (controller, reason) => {
+		if (typeof queueMicrotask !== "undefined") {
+			queueMicrotask(() => controller.abort(reason));
+			return;
+		}
+		Promise.resolve().then(() => controller.abort(reason));
+	};
+	const handleInvoke = async (invokeId, payload, options) => {
+		const receiveEvent = invokeReceiveEvent(invokeId);
+		const receiveEventError = invokeReceiveEventError(invokeId);
+		const receiveEventStreamEnd = invokeReceiveEventStreamEnd(invokeId);
+		const abortController = new AbortController();
+		abortControllers.set(invokeId, abortController);
+		if (abortReasons.has(invokeId)) scheduleAbort(abortController, abortReasons.get(invokeId));
+		const handlerOptions = options ? {
+			...options,
+			abortController
+		} : { abortController };
+		try {
+			const generator = fn(payload, handlerOptions);
+			for await (const res of generator) serverCtx.emit(receiveEvent, {
+				invokeId,
+				content: res
+			}, options);
+			serverCtx.emit(receiveEventStreamEnd, {
+				invokeId,
+				content: void 0
+			}, options);
+		} catch (error) {
+			serverCtx.emit(receiveEventError, {
+				invokeId,
+				content: { error }
+			}, options);
+		} finally {
+			abortControllers.delete(invokeId);
+			abortReasons.delete(invokeId);
+		}
+	};
+	serverCtx.on(event.sendEvent, async (payload, options) => {
+		if (!payload.body) return;
+		if (!payload.body.invokeId) return;
+		const invokeId = payload.body.invokeId;
+		if (payload.body.isReqStream) {
+			let controller = streamStates.get(invokeId);
+			if (!controller) {
+				let localController;
+				const reqStream = new ReadableStream({ start(c) {
+					localController = c;
+				} });
+				controller = localController;
+				streamStates.set(invokeId, controller);
+				handleInvoke(invokeId, reqStream, options);
+			}
+			controller.enqueue(payload.body.content);
+			return;
+		}
+		handleInvoke(invokeId, payload.body.content, options);
+	});
+	serverCtx.on(event.sendEventStreamEnd, (payload) => {
+		if (!payload.body) return;
+		if (!payload.body.invokeId) return;
+		const controller = streamStates.get(payload.body.invokeId);
+		if (!controller) return;
+		controller.close();
+		streamStates.delete(payload.body.invokeId);
+	});
+	serverCtx.on(event.sendEventAbort, (payload) => {
+		if (!payload.body) return;
+		if (!payload.body.invokeId) return;
+		const invokeId = payload.body.invokeId;
+		const reason = payload.body.content;
+		const abortController = abortControllers.get(invokeId);
+		if (!abortController) {
+			abortReasons.set(invokeId, reason);
+			let controller$1 = streamStates.get(invokeId);
+			if (!controller$1) {
+				let localController;
+				const reqStream = new ReadableStream({ start(c) {
+					localController = c;
+				} });
+				controller$1 = localController;
+				streamStates.set(invokeId, controller$1);
+				handleInvoke(invokeId, reqStream);
+			}
+			controller$1.error(createAbortError(reason));
+			streamStates.delete(invokeId);
+			return;
+		}
+		scheduleAbort(abortController, reason);
+		const controller = streamStates.get(invokeId);
+		if (controller) {
+			controller.error(createAbortError(reason));
+			streamStates.delete(invokeId);
+		}
+	});
+}
+/**
+* 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.
+*/
+function toStreamHandler(handler) {
+	return (payload, options) => {
+		const values = [];
+		let resolve;
+		let handlerError = null;
+		values.push(new Promise((r) => {
+			resolve = r;
+		}));
+		const emit = (data) => {
+			resolve([data, false]);
+			values.push(new Promise((r) => {
+				resolve = r;
+			}));
+		};
+		handler({
+			payload,
+			options,
+			emit
+		}).then(() => {
+			resolve([void 0, true]);
+		}).catch((err) => {
+			handlerError = err;
+			resolve([void 0, true]);
+		});
+		return async function* () {
+			let val;
+			for (let i = 0, done = false; !done; i++) {
+				[val, done] = await values[i];
+				delete values[i];
+				if (handlerError) throw handlerError;
+				if (!done) yield val;
+			}
+		}();
+	};
+}
+
+//#endregion
+export { isInvokeEventa as C, registerInvokeAbortEventListeners as E, defineInvokeEventa as S, isSendEvent as T, isAbortError as _, withRemoteMethods as a, randomBetween as b, defineInvokeHandler as c, isExtendableInvokeResponseLike as d, undefineInvokeHandler as f, createUntilTriggeredOnce as g, createUntilTriggered as h, createRemoteMethodTagPrefix as i, defineInvokeHandlers as l, createUntil as m, defineStreamInvokeHandler as n, withTransfer as o, createAbortError as p, toStreamHandler as r, defineInvoke as s, defineStreamInvoke as t, defineInvokes as u, isAsyncIterable as v, isReceiveEvent as w, InvokeEventType as x, isReadableStream as y };
+//# sourceMappingURL=src-DZ7si0kE.mjs.map