@mionjs/client 0.8.0-alpha.0

package/.dist/esm/src/routesFlow.js

@@ -0,0 +1,61 @@
+import { PURE_SERVER_FN_NAMESPACE, RpcError, __ΩMapFromServerFnRef as ___MapFromServerFnRef } from "@mionjs/core";
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+async function routesFlow(routeSubRequests, middleFns) {
+  if (!routeSubRequests || routeSubRequests.length === 0)
+    throw new RpcError({
+      type: "routesFlow-empty-routes",
+      publicMessage: "RoutesFlow requires at least one route subrequest."
+    });
+  const firstSubRequest = routeSubRequests[0];
+  if (!firstSubRequest.client)
+    throw new RpcError({
+      type: "routesFlow-missing-client",
+      publicMessage: "Could not extract MionClient from subrequest. Ensure subrequests are created via routes proxy."
+    });
+  const client = firstSubRequest.client;
+  for (let i = 1; i < routeSubRequests.length; i++)
+    if (routeSubRequests[i].client !== client)
+      throw new RpcError({
+        type: "routesFlow-client-mismatch",
+        publicMessage: `All subrequests in a routesFlow must use the same client instance. Subrequest at index ${i} has a different client.`
+      });
+  const [results, errors, middleFnResults, middleFnErrors] = await client.executeCallWithWorkflow(routeSubRequests, middleFns ?? {}), emptyResults = routeSubRequests.map(() => {
+  }), emptyErrors = routeSubRequests.map(() => {
+  });
+  return [results ?? emptyResults, errors ?? emptyErrors, middleFnResults, middleFnErrors];
+}
+routesFlow.__type = ["routeSubRequests", "middleFns", "WorkflowResult", "routesFlow", 'PP"@G2!"2"8"w#`/$'];
+const mapFromSymbol = /* @__PURE__ */ Symbol("MapFromServerFnRef");
+function mapFrom(source, mapper, bodyHash) {
+  if (!bodyHash)
+    throw new Error("mapFrom() requires mion vite plugin transform to inject bodyHash");
+  const ref = {
+    mapFromSymbol,
+    namespace: PURE_SERVER_FN_NAMESPACE,
+    fnName: bodyHash,
+    bodyHash,
+    pureFn: mapper,
+    isFactory: !1,
+    fromRequestId: source.id,
+    toRequestId: "",
+    paramIndex: -1,
+    type: __assignType(function() {
+      return ref;
+    }, ["type", 'P"/!'])
+  };
+  return ref;
+}
+mapFrom.__type = ["source", "resolvedValue", "value", "", "mapper", "bodyHash", () => ___MapFromServerFnRef, "resolvedValue", "mapFrom", `P"2!P"."f2#"/$2%&2&8P".(f2#"/$o'"/)`];
+function isMapFromRef(ref) {
+  return ref && ref.mapFromSymbol === mapFromSymbol;
+}
+isMapFromRef.__type = ["ref", "isMapFromRef", 'P"2!!/"'];
+export {
+  isMapFromRef,
+  mapFrom,
+  mapFromSymbol,
+  routesFlow
+};
+//# sourceMappingURL=routesFlow.js.map

package/.dist/esm/src/routesFlow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routesFlow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/serializer.d.ts

@@ -0,0 +1,13 @@
+import { ResponseBody } from '@mionjs/router';
+import { MionClientRequest } from './request.ts';
+export type SerializedBody = string | Uint8Array;
+export type ContentType = 'application/json; charset=utf-8' | 'application/octet-stream';
+export interface SerializedRequest {
+    body: SerializedBody;
+    contentType: ContentType;
+}
+export declare function serializeRequestBody(req: MionClientRequest<any, any>): SerializedRequest;
+export declare function deserializeResponseBody(response: Response): Promise<ResponseBody>;
+export declare type __ΩSerializedBody = any[];
+export declare type __ΩContentType = any[];
+export declare type __ΩSerializedRequest = any[];

package/.dist/esm/src/serializer.js

@@ -0,0 +1,139 @@
+import { MION_ROUTES, isRpcError, RpcError, deserializeBinaryBody, routesCache, HandlerType, serializeBinaryBody as serializeBinaryBody$1 } from "@mionjs/core";
+import { DEFAULT_PREFILL_OPTIONS } from "./constants.js";
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+const __ΩSerializedBody = ["SerializedBody", "P&WJw!y"], __ΩContentType = ["application/json; charset=utf-8", "application/octet-stream", "ContentType", 'P.!."Jw#y'], __ΩSerializedRequest = [() => __ΩSerializedBody, "body", () => __ΩContentType, "contentType", "SerializedRequest", 'Pn!4"n#4$Mw%y'];
+function getSerializerMode(req) {
+  const methodId = req.route?.id ?? req.workflowSubRequests?.[0]?.id, serializerMode = routesCache.getMethodJitFns(methodId)?.options.serializer || DEFAULT_PREFILL_OPTIONS.serializer;
+  return serializerMode === "json" ? DEFAULT_PREFILL_OPTIONS.serializer : serializerMode;
+}
+getSerializerMode.__type = ["MionClientRequest", "req", "SerializerMode", "getSerializerMode", 'P"w!2""w#/$'];
+function serializeRequestBody(req) {
+  const serializerMode = getSerializerMode(req);
+  switch (serializerMode) {
+    case "json":
+    case "stringifyJson":
+      return {
+        body: stringifyBody(req),
+        contentType: "application/json; charset=utf-8"
+      };
+    case "binary":
+      return {
+        body: serializeBinaryBody(req),
+        contentType: "application/octet-stream"
+      };
+    default:
+      throw new Error(`Invalid serializer mode ${serializerMode}`);
+  }
+}
+serializeRequestBody.__type = ["MionClientRequest", "req", () => __ΩSerializedRequest, "serializeRequestBody", 'P"w!2"n#/$'];
+function serializeBinaryBody(req) {
+  const subRequestIds = Object.keys(req.subRequestList), body = {}, executionChain = [];
+  for (const id of subRequestIds) {
+    let params = req.subRequestList[id].params;
+    const method = routesCache.useMethodJitFns(id);
+    method.type === HandlerType.headersMiddleFn && method.headersParam && (params = getParamsWithoutHeadersSubset(params)), body[id] = params, executionChain.push(method);
+  }
+  const workflowRouteIds = req.workflowSubRequests?.map(__assignType((sr) => sr.id, ["sr", "", 'P"2!"/"'])), { buffer } = serializeBinaryBody$1(req.path, executionChain, body, !1, workflowRouteIds);
+  return new Uint8Array(buffer);
+}
+serializeBinaryBody.__type = ["MionClientRequest", "req", "serializeBinaryBody", 'P"w!2"W/#'];
+async function deserializeResponseBody(response) {
+  const contentType = response.headers.get("content-type"), isJson = contentType?.includes("application/json"), isBinary = contentType?.includes("application/octet-stream");
+  let parsedBody;
+  if (isJson ? parsedBody = await deserializeJsonResponseBody(response) : isBinary ? parsedBody = await deserializeBinaryResponseBody(response) : parsedBody = await deserializeJsonResponseBody(response), MION_ROUTES.thrownErrors in parsedBody) {
+    const unexpectedErrors = parsedBody[MION_ROUTES.thrownErrors];
+    if (MION_ROUTES.platformError in unexpectedErrors) {
+      const globalErrorValue = unexpectedErrors[MION_ROUTES.platformError], platformError = isRpcError(globalErrorValue) ? new RpcError(globalErrorValue) : globalErrorValue;
+      return { [MION_ROUTES.platformError]: platformError };
+    }
+    Object.assign(parsedBody, unexpectedErrors), delete parsedBody[MION_ROUTES.thrownErrors];
+  }
+  if (isJson || !isJson && !isBinary) {
+    const deserializedBody = {};
+    return Object.entries(parsedBody).forEach(__assignType(([methodId, returnValue]) => {
+      const method = routesCache.useMethodJitFns(methodId), deserialized = parseHandlerReturnValue(method, returnValue);
+      deserializedBody[methodId] = deserialized;
+    }, ["param0", "", 'P"2!"/"'])), deserializedBody;
+  }
+  return parsedBody;
+}
+deserializeResponseBody.__type = ["response", "ResponseBody", "deserializeResponseBody", 'P!2!"w"`/#'];
+async function deserializeJsonResponseBody(response) {
+  try {
+    return await response.json();
+  } catch (err) {
+    throw new RpcError({
+      type: "parsing-json-response-error",
+      publicMessage: `Invalid json response body: ${err?.message || "unknown parsing error."}`
+    });
+  }
+}
+deserializeJsonResponseBody.__type = ["response", "deserializeJsonResponseBody", 'P!2!"`/"'];
+async function deserializeBinaryResponseBody(response) {
+  const arrayBuffer = await response.arrayBuffer(), { body } = deserializeBinaryBody("client-response", arrayBuffer, !0);
+  return body;
+}
+deserializeBinaryResponseBody.__type = ["response", "ResponseBody", "deserializeBinaryResponseBody", 'P!2!"w"`/#'];
+function stringifyBody(req) {
+  const props = [], subRequestIds = Object.keys(req.subRequestList);
+  for (let i = 0; i < subRequestIds.length; i++) {
+    const id = subRequestIds[i], subRequest = req.subRequestList[id];
+    if (!subRequest)
+      continue;
+    let params = subRequest.params;
+    const method = routesCache.useMethodJitFns(id);
+    method.type === HandlerType.headersMiddleFn && method.headersParam && (params = getParamsWithoutHeadersSubset(params));
+    try {
+      const jsonValue = stringifyHandlerParams(method, params);
+      if (!jsonValue)
+        continue;
+      props.push(`${JSON.stringify(id)}:${jsonValue}`);
+    } catch (e) {
+      throw new RpcError({
+        type: "json-stringify-request-error",
+        publicMessage: `Failed to stringify params for handler ${id}`,
+        originalError: e
+      });
+    }
+  }
+  return `{${props.join(",")}}`;
+}
+stringifyBody.__type = ["MionClientRequest", "req", "stringifyBody", 'P"w!2"&/#'];
+function getParamsWithoutHeadersSubset(params) {
+  return !params || params.length === 0 ? [] : params.slice(1);
+}
+getParamsWithoutHeadersSubset.__type = ["params", "getParamsWithoutHeadersSubset", 'P"F2!"F/"'];
+function stringifyHandlerParams(method, params) {
+  if (!method.paramNames || method.paramNames.length === 0)
+    return "";
+  const paramsJit = method.paramsJitFns;
+  return paramsJit.prepareForJson.isNoop ? JSON.stringify(params) : paramsJit.stringifyJson.fn(params);
+}
+stringifyHandlerParams.__type = ["MethodWithJitFns", "method", "params", "stringifyHandlerParams", 'P"w!2""F2#&/$'];
+function parseHandlerReturnValue(method, returnValue) {
+  if (!method.hasReturnData)
+    return returnValue;
+  const returnJit = method.returnJitFns;
+  if (returnJit.restoreFromJson.isNoop || !returnValue)
+    return returnValue;
+  try {
+    return returnValue instanceof RpcError ? returnValue : isRpcError(returnValue) ? new RpcError(returnValue) : returnJit.restoreFromJson.fn(returnValue);
+  } catch (e) {
+    return new RpcError({
+      type: "deserialization-error",
+      publicMessage: `Invalid response from Route or MiddleFn '${method.id}', can not deserialize return value: ${e.message}`,
+      errorData: e?.errors
+    });
+  }
+}
+parseHandlerReturnValue.__type = ["MethodWithJitFns", "method", "returnValue", "parseHandlerReturnValue", 'P"w!2""2#"/$'];
+export {
+  __ΩContentType,
+  __ΩSerializedBody,
+  __ΩSerializedRequest,
+  deserializeResponseBody,
+  serializeRequestBody
+};
+//# sourceMappingURL=serializer.js.map

package/.dist/esm/src/serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/storage.d.ts

@@ -0,0 +1,11 @@
+export declare class MemoryStorage {
+    private data;
+    get length(): number;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    key(index: number): string | null;
+}
+export declare function getStorage(): Storage | MemoryStorage;
+export declare function resetStorageInstance(): void;

package/.dist/esm/src/storage.js

@@ -0,0 +1,48 @@
+const STORAGE_GLOBAL_KEY = "__mion_storage__";
+class MemoryStorage {
+  data = (Map.Ω = [["&"], ["&"]], /* @__PURE__ */ new Map());
+  get length() {
+    return this.data.size;
+  }
+  getItem(key) {
+    return this.data.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.data.set(key, value);
+  }
+  removeItem(key) {
+    this.data.delete(key);
+  }
+  clear() {
+    this.data.clear();
+  }
+  key(index) {
+    return [...this.data.keys()][index] ?? null;
+  }
+  static __type = ["data", function() {
+    return Map.Ω = [["&"], ["&"]], /* @__PURE__ */ new Map();
+  }, "key", "getItem", "value", "setItem", "removeItem", "clear", "index", "MemoryStorage", `!3!;>"!P&2#P&,J0$P&2#&2%"0&P&2#"0'P"0(P'2)P&,J0#5w*`];
+}
+function getStorage() {
+  const existing = globalThis[STORAGE_GLOBAL_KEY];
+  if (existing)
+    return existing;
+  let storage;
+  try {
+    typeof localStorage < "u" ? (localStorage.setItem("__mion_test__", "1"), localStorage.removeItem("__mion_test__"), storage = localStorage) : storage = new MemoryStorage();
+  } catch {
+    storage = new MemoryStorage();
+  }
+  return globalThis[STORAGE_GLOBAL_KEY] = storage, storage;
+}
+getStorage.__type = [() => MemoryStorage, "getStorage", 'PP!P7!J/"'];
+function resetStorageInstance() {
+  delete globalThis[STORAGE_GLOBAL_KEY];
+}
+resetStorageInstance.__type = ["resetStorageInstance", 'P"/!'];
+export {
+  MemoryStorage,
+  getStorage,
+  resetStorageInstance
+};
+//# sourceMappingURL=storage.js.map

package/.dist/esm/src/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/subRequest.d.ts

@@ -0,0 +1,23 @@
+import { RpcError, RunTypeError, MapFromServerFnRef } from '@mionjs/core';
+import { CallWithMiddleFnsResult, HSubRequest, RequestErrors, Result, RSubRequest, SubRequest, WorkflowResult } from './types.ts';
+import { MionClient } from './client.ts';
+import { TypedEvent } from './typedEvent.ts';
+export declare class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RSubRequest<any>, HSubRequest<any> {
+    readonly client: MionClient;
+    pointer: string[];
+    id: string;
+    isResolved: boolean;
+    params: any[];
+    resolvedValue?: S;
+    error?: E;
+    serializedParams?: any[];
+    mappings: MapFromServerFnRef[];
+    constructor(parentProps: string[], handlerId: string, argArray: any[], client: MionClient);
+    prefill(): TypedEvent<S, E>;
+    removePrefill(): Promise<void>;
+    call(): Promise<Result<S, E>>;
+    callWithMiddleFns<H extends Record<string, HSubRequest<any>>>(middleFns: H): Promise<CallWithMiddleFnsResult<S, E, H>>;
+    callWithWorkflow<OtherRoutes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(otherRoutes: [...OtherRoutes], middleFns?: H): Promise<WorkflowResult<[RSubRequest<any>, ...OtherRoutes], H>>;
+    typeErrors(): Promise<RunTypeError[]>;
+}
+export declare function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string>;

package/.dist/esm/src/subRequest.js

@@ -0,0 +1,73 @@
+import { RpcError } from "@mionjs/core";
+import { TypedEvent } from "./typedEvent.js";
+import { isMapFromRef } from "./routesFlow.js";
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+class MionSubRequest {
+  client;
+  pointer;
+  id;
+  isResolved = !1;
+  params;
+  resolvedValue;
+  error;
+  serializedParams;
+  mappings = [];
+  constructor(parentProps, handlerId, argArray, client) {
+    this.client = client, this.pointer = [...parentProps], this.id = handlerId, this.params = argArray.map(__assignType((arg, index) => isMapFromRef(arg) ? (arg.toRequestId = this.id, arg.paramIndex = index, this.mappings.push(arg), null) : arg, ["arg", "index", "", 'P"2!"2""/#']));
+  }
+  /** Prefills MiddleFn's parameters and returns TypedEvent for event handler registration */
+  prefill() {
+    const typedEvent = (TypedEvent.Ω = [["!"], ["!"]], new TypedEvent(this.id, this.client.handlersRegistry));
+    return this.client.prefill(this).catch(__assignType((errors) => {
+      console.error("Prefill error:", findSubRequestError(this, errors));
+    }, ["RequestErrors", "errors", "", 'P"w!2""/#'])), typedEvent;
+  }
+  /** Removes prefilled value and clears any registered error handlers for this middleFn */
+  removePrefill() {
+    return this.client.handlersRegistry.clearHandlers(this.id), this.client.removePrefill(this);
+  }
+  /** Calls a remote route and returns a Result 4-tuple with full typing preserved */
+  call() {
+    return this.client.executeCall(this);
+  }
+  /** Calls a remote route with middleFns and returns a fully-typed 4-tuple result */
+  callWithMiddleFns(middleFns) {
+    if (Object.keys(middleFns).length === 0)
+      throw new Error("callWithMiddleFns requires at least one middleFn. Use call() instead for requests without middleFns.");
+    return this.client.executeCallWithMiddleFns(this, middleFns);
+  }
+  /** Calls this route as part of a routesFlow with other routes in a single HTTP request */
+  async callWithWorkflow(otherRoutes, middleFns) {
+    const allRoutes = [this, ...otherRoutes], [results, errors, middleFnResults, middleFnErrors] = await this.client.executeCallWithWorkflow(allRoutes, middleFns ?? {}), emptyResults = allRoutes.map(() => {
+    }), emptyErrors = allRoutes.map(() => {
+    });
+    return [results ?? emptyResults, errors ?? emptyErrors, middleFnResults, middleFnErrors];
+  }
+  /** Validates parameters and returns type errors */
+  typeErrors() {
+    return this.client.typeErrors(this).catch(__assignType((errors) => Promise.reject(findSubRequestError(this, errors)), ["RequestErrors", "errors", "", 'P"w!2""/#']));
+  }
+  static __type = ["S", "E", "pointer", "id", "isResolved", function() {
+    return !1;
+  }, "params", "resolvedValue", "error", "serializedParams", "MapFromServerFnRef", "mappings", function() {
+    return [];
+  }, "parentProps", "handlerId", "argArray", "MionClient", "client", "constructor", () => TypedEvent, "prefill", "removePrefill", "Result", "call", "middleFns", "CallWithMiddleFnsResult", "callWithMiddleFns", "otherRoutes", "WorkflowResult", "callWithWorkflow", "RunTypeError", "typeErrors", "RSubRequest", "HSubRequest", "MionSubRequest", '"c!"c"&F3#&3$)3%>&"F3\'e!!3(8e!"3)8"F3*8"w+F3,>-P&F2.&2/"F20"w1229"03PPe#!e#"7405P$`06P"w7`08P"29"w:`0;PP"@G2<"298"w=`0>P"w?F`0@5"wA"wBx#wC'];
+}
+function findSubRequestError(subRequest, errors) {
+  const specificError = errors.get(subRequest.id);
+  if (specificError)
+    return specificError;
+  const firstError = errors.values().next().value;
+  return firstError || new RpcError({
+    type: "unknown-error",
+    publicMessage: "An unknown error occurred"
+  });
+}
+findSubRequestError.__type = ["SubRequest", "subRequest", "RequestErrors", "errors", () => RpcError, "findSubRequestError", 'P"w!2""w#2$P&7%/&'];
+export {
+  MionSubRequest,
+  findSubRequestError
+};
+//# sourceMappingURL=subRequest.js.map

package/.dist/esm/src/subRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/testUtils.d.ts

@@ -0,0 +1 @@
+export declare function resetClientCaches(): void;

package/.dist/esm/src/testUtils.js

@@ -0,0 +1,48 @@
+import { MION_ROUTES, routesCache, resetJitFnCaches, resetJitFunctionsCache, addAOTCaches, getJitFnHashes } from "@mionjs/core";
+import { getAOTCaches } from "./clientMethodsMetadata.js";
+function resetClientCaches() {
+  const { jitFnsCache, pureFnsCache } = getAOTCaches(), mionRouteIds = new Set(Object.values(MION_ROUTES)), cache = routesCache.getCache();
+  for (const key in cache)
+    mionRouteIds.has(key) || delete cache[key];
+  resetJitFnCaches(), resetJitFunctionsCache();
+  const neededJitHashes = (Set.Ω = [["&"]], /* @__PURE__ */ new Set()), neededPureFnKeys = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+  for (const routeId of mionRouteIds) {
+    const meta = routesCache.getMetadata(routeId);
+    meta && (collectJitDepsFromParentHash(meta.paramsJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), collectJitDepsFromParentHash(meta.returnJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), meta.headersParam && collectJitDepsFromParentHash(meta.headersParam.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), meta.headersReturn && collectJitDepsFromParentHash(meta.headersReturn.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache));
+  }
+  const filteredJitFns = {};
+  for (const hash of neededJitHashes)
+    hash in jitFnsCache && (filteredJitFns[hash] = jitFnsCache[hash]);
+  const filteredPureFns = {};
+  for (const key of neededPureFnKeys) {
+    const [ns, fnHash] = key.split("::");
+    pureFnsCache[ns]?.[fnHash] && (filteredPureFns[ns] || (filteredPureFns[ns] = {}), filteredPureFns[ns][fnHash] = pureFnsCache[ns][fnHash]);
+  }
+  (Object.keys(filteredJitFns).length > 0 || Object.keys(filteredPureFns).length > 0) && addAOTCaches(filteredJitFns, filteredPureFns);
+}
+resetClientCaches.__type = ["resetClientCaches", 'P"/!'];
+function collectJitDepsFromParentHash(parentHash, jitHashes, pureFnKeys, jitFnsCache) {
+  if (!parentHash)
+    return;
+  const hashes = getJitFnHashes(parentHash);
+  for (const individualHash of Object.values(hashes))
+    collectJitDeps(individualHash, jitHashes, pureFnKeys, jitFnsCache);
+}
+collectJitDepsFromParentHash.__type = ["parentHash", "jitHashes", "pureFnKeys", "PersistedJitFunctionsCache", "jitFnsCache", "collectJitDepsFromParentHash", 'P&2!&D2"&D2#"w$2%"/&'];
+function collectJitDeps(hash, jitHashes, pureFnKeys, jitFnsCache) {
+  if (!hash || jitHashes.has(hash))
+    return;
+  jitHashes.add(hash);
+  const entry = jitFnsCache[hash];
+  if (entry) {
+    for (const dep of entry.jitDependencies)
+      collectJitDeps(dep, jitHashes, pureFnKeys, jitFnsCache);
+    for (const pureDep of entry.pureFnDependencies)
+      pureFnKeys.add(pureDep);
+  }
+}
+collectJitDeps.__type = ["hash", "jitHashes", "pureFnKeys", "PersistedJitFunctionsCache", "jitFnsCache", "collectJitDeps", 'P&2!&D2"&D2#"w$2%"/&'];
+export {
+  resetClientCaches
+};
+//# sourceMappingURL=testUtils.js.map

package/.dist/esm/src/testUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/typedEvent.d.ts

@@ -0,0 +1,17 @@
+import { RpcError } from '@mionjs/core';
+import { HandlersRegistry } from './handlersRegistry.ts';
+import { SuccessHandler } from './types.ts';
+export declare class TypedEvent<S = void, E extends RpcError<string, any> = never> {
+    private readonly handlerId;
+    private readonly registry;
+    constructor(handlerId: string, registry: HandlersRegistry);
+    onSuccess(handler: SuccessHandler<S>): TypedEvent<S, E>;
+    offSuccess(): TypedEvent<S, E>;
+    onError<T extends E['type']>(errorType: T, handler: (error: Extract<E, {
+        type: T;
+    }>) => void): TypedEvent<S, E>;
+    offError<T extends E['type']>(errorType: T): TypedEvent<S, E>;
+    getHandlerId(): string;
+    hasErrorHandler(errorType: string): boolean;
+    hasSuccessHandler(): boolean;
+}

package/.dist/esm/src/typedEvent.js

@@ -0,0 +1,41 @@
+const __ΩExtract = ["T", "U", "Extract", `l6e$!R!RPe#!e$"qk#'QRb!b"Pde"!p)w#y`];
+class TypedEvent {
+  handlerId;
+  registry;
+  constructor(handlerId, registry) {
+    this.handlerId = handlerId, this.registry = registry;
+  }
+  /** Register a persistent success handler for this middleFn */
+  onSuccess(handler) {
+    return this.registry.registerSuccess(this.handlerId, handler), this;
+  }
+  /** Remove a previously registered success handler from HandlersRegistry */
+  offSuccess() {
+    return this.registry.unregisterSuccess(this.handlerId), this;
+  }
+  /** Register a persistent error handler for this middleFn */
+  onError(errorType, handler) {
+    return this.registry.register(this.handlerId, errorType, handler), this;
+  }
+  /** Remove a previously registered error handler from HandlersRegistry */
+  offError(errorType) {
+    return this.registry.unregister(this.handlerId, errorType), this;
+  }
+  /** Get the handler ID this event is associated with */
+  getHandlerId() {
+    return this.handlerId;
+  }
+  /** Check if an error handler is registered for a specific error type */
+  hasErrorHandler(errorType) {
+    return this.registry.hasHandler(this.handlerId, errorType);
+  }
+  /** Check if a success handler is registered */
+  hasSuccessHandler() {
+    return this.registry.hasSuccessHandler(this.handlerId);
+  }
+  static __type = ["S", "E", "handlerId", "HandlersRegistry", "registry", "constructor", "SuccessHandler", "handler", () => TypedEvent, "onSuccess", () => TypedEvent, "offSuccess", "errorType", () => __ΩExtract, "type", "error", "", () => TypedEvent, "onError", () => TypedEvent, "offError", "getHandlerId", "hasErrorHandler", "hasSuccessHandler", "TypedEvent", `$c!!c"P&2#;9"w$2%;9"0&P"w'2(Pe#!e#"7)0*PPe#!e#"7+0,P"2-Pe#"P"4/Mo.#20$/12(Pe#!e#"7203P"2-Pe#!e#"7405P&06P&2-)07P)085w9`];
+}
+export {
+  TypedEvent
+};
+//# sourceMappingURL=typedEvent.js.map

package/.dist/esm/src/typedEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedEvent.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}