@learncard/network-plugin 1.7.11 → 1.8.1

package/dist/lcn-plugin.cjs.development.js

@@ -25,7 +25,7 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../../node_modules/.pnpm/@trpc+server@10.17.0/node_modules/@trpc/server/dist/observable-ade1bad8.mjs
+// ../../../node_modules/.pnpm/@trpc+server@10.45.2/node_modules/@trpc/server/dist/observable-ade1bad8.mjs
 function identity(x) {
   return x;
 }
@@ -104,7 +104,7 @@ function observable(subscribe) {
 }
 __name(observable, "observable");
 
-// ../../../node_modules/.pnpm/@trpc+server@10.17.0/node_modules/@trpc/server/dist/observable/index.mjs
+// ../../../node_modules/.pnpm/@trpc+server@10.45.2/node_modules/@trpc/server/dist/observable/index.mjs
 function share(_opts) {
   return (originalObserver) => {
     let refCount = 0;
@@ -207,85 +207,7 @@ function observableToPromise(observable2) {
 }
 __name(observableToPromise, "observableToPromise");
 
-// ../../../node_modules/.pnpm/@trpc+client@10.17.0_@trpc+server@10.17.0/node_modules/@trpc/client/dist/transformResult-6fb67924.mjs
-var TRPCClientError = class extends Error {
-  static from(cause, opts = {}) {
-    if (!(cause instanceof Error)) {
-      return new TRPCClientError(cause.error.message ?? "", {
-        ...opts,
-        cause: void 0,
-        result: cause
-      });
-    }
-    if (cause.name === "TRPCClientError") {
-      return cause;
-    }
-    return new TRPCClientError(cause.message, {
-      ...opts,
-      cause,
-      result: null
-    });
-  }
-  constructor(message, opts) {
-    const cause = opts?.cause;
-    super(message, {
-      cause
-    });
-    this.meta = opts?.meta;
-    this.cause = cause;
-    this.shape = opts?.result?.error;
-    this.data = opts?.result?.error.data;
-    this.name = "TRPCClientError";
-    Object.setPrototypeOf(this, TRPCClientError.prototype);
-  }
-};
-__name(TRPCClientError, "TRPCClientError");
-function transformResultInner(response, runtime) {
-  if ("error" in response) {
-    const error = runtime.transformer.deserialize(response.error);
-    return {
-      ok: false,
-      error: {
-        ...response,
-        error
-      }
-    };
-  }
-  const result = {
-    ...response.result,
-    ...(!response.result.type || response.result.type === "data") && {
-      type: "data",
-      data: runtime.transformer.deserialize(response.result.data)
-    }
-  };
-  return {
-    ok: true,
-    result
-  };
-}
-__name(transformResultInner, "transformResultInner");
-function isObject(value) {
-  return !!value && !Array.isArray(value) && typeof value === "object";
-}
-__name(isObject, "isObject");
-function transformResult(response, runtime) {
-  let result;
-  try {
-    result = transformResultInner(response, runtime);
-  } catch (err) {
-    throw new TRPCClientError("Unable to transform response from server");
-  }
-  if (!result.ok && (!isObject(result.error.error) || typeof result.error.error.code !== "number")) {
-    throw new TRPCClientError("Badly formatted response from server");
-  }
-  if (result.ok && !isObject(result.result)) {
-    throw new TRPCClientError("Badly formatted response from server");
-  }
-  return result;
-}
-__name(transformResult, "transformResult");
-
-// ../../../node_modules/.pnpm/@trpc+client@10.17.0_@trpc+server@10.17.0/node_modules/@trpc/client/dist/splitLink-4c75f7be.mjs
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/splitLink-4c75f7be.mjs
 function createChain(opts) {
   return observable((observer) => {
     function execute(index = 0, op = opts.op) {
@@ -309,7 +231,37 @@ function createChain(opts) {
 }
 __name(createChain, "createChain");
 
-// ../../../node_modules/.pnpm/@trpc+server@10.17.0/node_modules/@trpc/server/dist/index-972002da.mjs
+// ../../../node_modules/.pnpm/@trpc+server@10.45.2/node_modules/@trpc/server/dist/codes-c924c3db.mjs
+function invert(obj) {
+  const newObj = /* @__PURE__ */ Object.create(null);
+  for (const key in obj) {
+    const v = obj[key];
+    newObj[v] = key;
+  }
+  return newObj;
+}
+__name(invert, "invert");
+var TRPC_ERROR_CODES_BY_KEY = {
+  PARSE_ERROR: -32700,
+  BAD_REQUEST: -32600,
+  INTERNAL_SERVER_ERROR: -32603,
+  NOT_IMPLEMENTED: -32603,
+  UNAUTHORIZED: -32001,
+  FORBIDDEN: -32003,
+  NOT_FOUND: -32004,
+  METHOD_NOT_SUPPORTED: -32005,
+  TIMEOUT: -32008,
+  CONFLICT: -32009,
+  PRECONDITION_FAILED: -32012,
+  PAYLOAD_TOO_LARGE: -32013,
+  UNPROCESSABLE_CONTENT: -32022,
+  TOO_MANY_REQUESTS: -32029,
+  CLIENT_CLOSED_REQUEST: -32099
+};
+var TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
+
+// ../../../node_modules/.pnpm/@trpc+server@10.45.2/node_modules/@trpc/server/dist/index-f91d720c.mjs
+var TRPC_ERROR_CODES_BY_NUMBER2 = invert(TRPC_ERROR_CODES_BY_KEY);
 var noop = /* @__PURE__ */ __name(() => {
 }, "noop");
 function createInnerProxy(callback, path) {
@@ -324,9 +276,10 @@ function createInnerProxy(callback, path) {
       ]);
     },
     apply(_1, _2, args) {
+      const isApply = path[path.length - 1] === "apply";
       return callback({
-        args,
-        path
+        args: isApply ? args.length >= 2 ? args[1] : [] : args,
+        path: isApply ? path.slice(0, -1) : path
       });
     }
   });
@@ -345,21 +298,152 @@ var createFlatProxy = /* @__PURE__ */ __name((callback) => {
   });
 }, "createFlatProxy");
 
-// ../../../node_modules/.pnpm/@trpc+client@10.17.0_@trpc+server@10.17.0/node_modules/@trpc/client/dist/httpUtils-9b676ab4.mjs
-var isFunction = /* @__PURE__ */ __name((fn) => typeof fn === "function", "isFunction");
-function _bind(fn, thisArg) {
-  return isFunction(fn.bind) ? fn.bind(thisArg) : fn;
+// ../../../node_modules/.pnpm/@trpc+server@10.45.2/node_modules/@trpc/server/dist/getCauseFromUnknown-2d66414a.mjs
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
 }
-__name(_bind, "_bind");
+__name(isObject, "isObject");
+var UnknownCauseError = class extends Error {
+};
+__name(UnknownCauseError, "UnknownCauseError");
+function getCauseFromUnknown(cause) {
+  if (cause instanceof Error) {
+    return cause;
+  }
+  const type = typeof cause;
+  if (type === "undefined" || type === "function" || cause === null) {
+    return void 0;
+  }
+  if (type !== "object") {
+    return new Error(String(cause));
+  }
+  if (isObject(cause)) {
+    const err = new UnknownCauseError();
+    for (const key in cause) {
+      err[key] = cause[key];
+    }
+    return err;
+  }
+  return void 0;
+}
+__name(getCauseFromUnknown, "getCauseFromUnknown");
+
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/transformResult-ace864b8.mjs
+function isObject2(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+__name(isObject2, "isObject");
+function transformResultInner(response, runtime) {
+  if ("error" in response) {
+    const error = runtime.transformer.deserialize(response.error);
+    return {
+      ok: false,
+      error: {
+        ...response,
+        error
+      }
+    };
+  }
+  const result = {
+    ...response.result,
+    ...(!response.result.type || response.result.type === "data") && {
+      type: "data",
+      data: runtime.transformer.deserialize(response.result.data)
+    }
+  };
+  return {
+    ok: true,
+    result
+  };
+}
+__name(transformResultInner, "transformResultInner");
+var TransformResultError = class extends Error {
+  constructor() {
+    super("Unable to transform response from server");
+  }
+};
+__name(TransformResultError, "TransformResultError");
+function transformResult(response, runtime) {
+  let result;
+  try {
+    result = transformResultInner(response, runtime);
+  } catch (err) {
+    throw new TransformResultError();
+  }
+  if (!result.ok && (!isObject2(result.error.error) || typeof result.error.error.code !== "number")) {
+    throw new TransformResultError();
+  }
+  if (result.ok && !isObject2(result.result)) {
+    throw new TransformResultError();
+  }
+  return result;
+}
+__name(transformResult, "transformResult");
+
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/TRPCClientError-38f9a32a.mjs
+function isTRPCClientError(cause) {
+  return cause instanceof TRPCClientError || cause instanceof Error && cause.name === "TRPCClientError";
+}
+__name(isTRPCClientError, "isTRPCClientError");
+function isTRPCErrorResponse(obj) {
+  return isObject2(obj) && isObject2(obj.error) && typeof obj.error.code === "number" && typeof obj.error.message === "string";
+}
+__name(isTRPCErrorResponse, "isTRPCErrorResponse");
+var TRPCClientError = class extends Error {
+  static from(_cause, opts = {}) {
+    const cause = _cause;
+    if (isTRPCClientError(cause)) {
+      if (opts.meta) {
+        cause.meta = {
+          ...cause.meta,
+          ...opts.meta
+        };
+      }
+      return cause;
+    }
+    if (isTRPCErrorResponse(cause)) {
+      return new TRPCClientError(cause.error.message, {
+        ...opts,
+        result: cause
+      });
+    }
+    if (!(cause instanceof Error)) {
+      return new TRPCClientError("Unknown error", {
+        ...opts,
+        cause
+      });
+    }
+    return new TRPCClientError(cause.message, {
+      ...opts,
+      cause: getCauseFromUnknown(cause)
+    });
+  }
+  constructor(message, opts) {
+    const cause = opts?.cause;
+    super(message, {
+      cause
+    });
+    this.meta = opts?.meta;
+    this.cause = cause;
+    this.shape = opts?.result?.error;
+    this.data = opts?.result?.error.data;
+    this.name = "TRPCClientError";
+    Object.setPrototypeOf(this, TRPCClientError.prototype);
+  }
+};
+__name(TRPCClientError, "TRPCClientError");
+
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/httpUtils-b9d0cb48.mjs
+var isFunction = /* @__PURE__ */ __name((fn) => typeof fn === "function", "isFunction");
 function getFetch(customFetchImpl) {
   if (customFetchImpl) {
     return customFetchImpl;
   }
   if (typeof window !== "undefined" && isFunction(window.fetch)) {
-    return _bind(window.fetch, window);
+    return window.fetch;
   }
   if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) {
-    return _bind(globalThis.fetch, globalThis);
+    return globalThis.fetch;
   }
   throw new Error("No fetch implementation found");
 }
@@ -378,12 +462,10 @@ function getAbortController(customAbortControllerImpl) {
 }
 __name(getAbortController, "getAbortController");
 function resolveHTTPLinkOptions(opts) {
-  const headers = opts.headers || (() => ({}));
   return {
-    url: opts.url,
-    fetch: getFetch(opts.fetch),
-    AbortController: getAbortController(opts.AbortController),
-    headers: typeof headers === "function" ? headers : () => headers
+    url: opts.url.toString().replace(/\/$/, ""),
+    fetch: opts.fetch,
+    AbortController: getAbortController(opts.AbortController)
   };
 }
 __name(resolveHTTPLinkOptions, "resolveHTTPLinkOptions");
@@ -404,7 +486,7 @@ function getInput(opts) {
   return "input" in opts ? opts.runtime.transformer.serialize(opts.input) : arrayToDict(opts.inputs.map((_input) => opts.runtime.transformer.serialize(_input)));
 }
 __name(getInput, "getInput");
-function getUrl(opts) {
+var getUrl = /* @__PURE__ */ __name((opts) => {
   let url = opts.url + "/" + opts.path;
   const queryParts = [];
   if ("inputs" in opts) {
@@ -420,48 +502,73 @@ function getUrl(opts) {
     url += "?" + queryParts.join("&");
   }
   return url;
-}
-__name(getUrl, "getUrl");
-function getBody(opts) {
+}, "getUrl");
+var getBody = /* @__PURE__ */ __name((opts) => {
   if (opts.type === "query") {
     return void 0;
   }
   const input = getInput(opts);
   return input !== void 0 ? JSON.stringify(input) : void 0;
+}, "getBody");
+var jsonHttpRequester = /* @__PURE__ */ __name((opts) => {
+  return httpRequest({
+    ...opts,
+    contentTypeHeader: "application/json",
+    getUrl,
+    getBody
+  });
+}, "jsonHttpRequester");
+async function fetchHTTPResponse(opts, ac) {
+  const url = opts.getUrl(opts);
+  const body = opts.getBody(opts);
+  const { type } = opts;
+  const resolvedHeaders = await opts.headers();
+  if (type === "subscription") {
+    throw new Error("Subscriptions should use wsLink");
+  }
+  const headers = {
+    ...opts.contentTypeHeader ? {
+      "content-type": opts.contentTypeHeader
+    } : {},
+    ...opts.batchModeHeader ? {
+      "trpc-batch-mode": opts.batchModeHeader
+    } : {},
+    ...resolvedHeaders
+  };
+  return getFetch(opts.fetch)(url, {
+    method: METHOD[type],
+    signal: ac?.signal,
+    body,
+    headers
+  });
 }
-__name(getBody, "getBody");
+__name(fetchHTTPResponse, "fetchHTTPResponse");
 function httpRequest(opts) {
-  const { type } = opts;
   const ac = opts.AbortController ? new opts.AbortController() : null;
+  const meta = {};
+  let done = false;
   const promise = new Promise((resolve, reject) => {
-    const url = getUrl(opts);
-    const body = getBody(opts);
-    const meta = {};
-    Promise.resolve(opts.headers()).then((headers) => {
-      if (type === "subscription") {
-        throw new Error("Subscriptions should use wsLink");
-      }
-      return opts.fetch(url, {
-        method: METHOD[type],
-        signal: ac?.signal,
-        body,
-        headers: {
-          "content-type": "application/json",
-          ...headers
-        }
-      });
-    }).then((_res) => {
+    fetchHTTPResponse(opts, ac).then((_res) => {
       meta.response = _res;
+      done = true;
       return _res.json();
     }).then((json) => {
+      meta.responseJSON = json;
       resolve({
         json,
         meta
       });
-    }).catch(reject);
+    }).catch((err) => {
+      done = true;
+      reject(TRPCClientError.from(err, {
+        meta
+      }));
+    });
   });
   const cancel = /* @__PURE__ */ __name(() => {
-    ac?.abort();
+    if (!done) {
+      ac?.abort();
+    }
   }, "cancel");
   return {
     promise,
@@ -470,7 +577,7 @@ function httpRequest(opts) {
 }
 __name(httpRequest, "httpRequest");
 
-// ../../../node_modules/.pnpm/@trpc+client@10.17.0_@trpc+server@10.17.0/node_modules/@trpc/client/dist/links/httpBatchLink.mjs
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/httpBatchLink-d0f9eac9.mjs
 var throwFatalError = /* @__PURE__ */ __name(() => {
   throw new Error("Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new");
 }, "throwFatalError");
@@ -494,7 +601,7 @@ function dataLoader(batchLoader) {
       }
       const lastGroup = groupedItems[groupedItems.length - 1];
       if (item.aborted) {
-        item.reject(new Error("Aborted"));
+        item.reject?.(new Error("Aborted"));
         index++;
         continue;
       }
@@ -505,7 +612,7 @@ function dataLoader(batchLoader) {
         continue;
       }
       if (lastGroup.length === 0) {
-        item.reject(new Error("Input is too big for a single dispatch"));
+        item.reject?.(new Error("Input is too big for a single dispatch"));
         index++;
         continue;
       }
@@ -528,18 +635,27 @@ function dataLoader(batchLoader) {
       for (const item of items) {
         item.batch = batch;
       }
-      const { promise, cancel } = batchLoader.fetch(batch.items.map((_item) => _item.key));
+      const unitResolver = /* @__PURE__ */ __name((index, value) => {
+        const item = batch.items[index];
+        item.resolve?.(value);
+        item.batch = null;
+        item.reject = null;
+        item.resolve = null;
+      }, "unitResolver");
+      const { promise, cancel } = batchLoader.fetch(batch.items.map((_item) => _item.key), unitResolver);
       batch.cancel = cancel;
       promise.then((result) => {
         for (let i = 0; i < result.length; i++) {
           const value = result[i];
-          const item = batch.items[i];
-          item.resolve(value);
+          unitResolver(i, value);
+        }
+        for (const item of batch.items) {
+          item.reject?.(new Error("Missing result"));
           item.batch = null;
         }
       }).catch((cause) => {
         for (const item of batch.items) {
-          item.reject(cause);
+          item.reject?.(cause);
           item.batch = null;
         }
       });
@@ -583,89 +699,170 @@ function dataLoader(batchLoader) {
   };
 }
 __name(dataLoader, "dataLoader");
-function httpBatchLink(opts) {
-  const resolvedOpts = resolveHTTPLinkOptions(opts);
-  return (runtime) => {
-    const maxURLLength = opts.maxURLLength || Infinity;
-    const batchLoader = /* @__PURE__ */ __name((type) => {
-      const validate = /* @__PURE__ */ __name((batchOps) => {
-        if (maxURLLength === Infinity) {
-          return true;
-        }
-        const path = batchOps.map((op) => op.path).join(",");
-        const inputs = batchOps.map((op) => op.input);
-        const url = getUrl({
-          ...resolvedOpts,
-          runtime,
-          type,
-          path,
-          inputs
-        });
-        return url.length <= maxURLLength;
-      }, "validate");
-      const fetch2 = /* @__PURE__ */ __name((batchOps) => {
-        const path = batchOps.map((op) => op.path).join(",");
-        const inputs = batchOps.map((op) => op.input);
-        const { promise, cancel } = httpRequest({
+function createHTTPBatchLink(requester) {
+  return /* @__PURE__ */ __name(function httpBatchLink2(opts) {
+    const resolvedOpts = resolveHTTPLinkOptions(opts);
+    const maxURLLength = opts.maxURLLength ?? Infinity;
+    return (runtime) => {
+      const batchLoader = /* @__PURE__ */ __name((type) => {
+        const validate = /* @__PURE__ */ __name((batchOps) => {
+          if (maxURLLength === Infinity) {
+            return true;
+          }
+          const path = batchOps.map((op) => op.path).join(",");
+          const inputs = batchOps.map((op) => op.input);
+          const url = getUrl({
+            ...resolvedOpts,
+            runtime,
+            type,
+            path,
+            inputs
+          });
+          return url.length <= maxURLLength;
+        }, "validate");
+        const fetch2 = requester({
           ...resolvedOpts,
           runtime,
           type,
-          path,
-          inputs
+          opts
         });
         return {
-          promise: promise.then((res) => {
-            const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(() => res.json);
-            const result = resJSON.map((item) => ({
-              meta: res.meta,
-              json: item
-            }));
-            return result;
-          }),
-          cancel
+          validate,
+          fetch: fetch2
         };
-      }, "fetch");
-      return {
-        validate,
-        fetch: fetch2
+      }, "batchLoader");
+      const query = dataLoader(batchLoader("query"));
+      const mutation = dataLoader(batchLoader("mutation"));
+      const subscription = dataLoader(batchLoader("subscription"));
+      const loaders = {
+        query,
+        subscription,
+        mutation
       };
-    }, "batchLoader");
-    const query = dataLoader(batchLoader("query"));
-    const mutation = dataLoader(batchLoader("mutation"));
-    const subscription = dataLoader(batchLoader("subscription"));
-    const loaders = {
-      query,
-      subscription,
-      mutation
-    };
-    return ({ op }) => {
-      return observable((observer) => {
-        const loader = loaders[op.type];
-        const { promise, cancel } = loader.load(op);
-        promise.then((res) => {
-          const transformed = transformResult(res.json, runtime);
-          if (!transformed.ok) {
-            observer.error(TRPCClientError.from(transformed.error, {
-              meta: res.meta
+      return ({ op }) => {
+        return observable((observer) => {
+          const loader = loaders[op.type];
+          const { promise, cancel } = loader.load(op);
+          let _res = void 0;
+          promise.then((res) => {
+            _res = res;
+            const transformed = transformResult(res.json, runtime);
+            if (!transformed.ok) {
+              observer.error(TRPCClientError.from(transformed.error, {
+                meta: res.meta
+              }));
+              return;
+            }
+            observer.next({
+              context: res.meta,
+              result: transformed.result
+            });
+            observer.complete();
+          }).catch((err) => {
+            observer.error(TRPCClientError.from(err, {
+              meta: _res?.meta
             }));
-            return;
-          }
-          observer.next({
-            context: res.meta,
-            result: transformed.result
           });
-          observer.complete();
-        }).catch((err) => observer.error(TRPCClientError.from(err)));
-        return () => {
-          cancel();
-        };
-      });
+          return () => {
+            cancel();
+          };
+        });
+      };
     };
+  }, "httpBatchLink");
+}
+__name(createHTTPBatchLink, "createHTTPBatchLink");
+var batchRequester = /* @__PURE__ */ __name((requesterOpts) => {
+  return (batchOps) => {
+    const path = batchOps.map((op) => op.path).join(",");
+    const inputs = batchOps.map((op) => op.input);
+    const { promise, cancel } = jsonHttpRequester({
+      ...requesterOpts,
+      path,
+      inputs,
+      headers() {
+        if (!requesterOpts.opts.headers) {
+          return {};
+        }
+        if (typeof requesterOpts.opts.headers === "function") {
+          return requesterOpts.opts.headers({
+            opList: batchOps
+          });
+        }
+        return requesterOpts.opts.headers;
+      }
+    });
+    return {
+      promise: promise.then((res) => {
+        const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(() => res.json);
+        const result = resJSON.map((item) => ({
+          meta: res.meta,
+          json: item
+        }));
+        return result;
+      }),
+      cancel
+    };
+  };
+}, "batchRequester");
+var httpBatchLink = createHTTPBatchLink(batchRequester);
+
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/links/httpLink.mjs
+function httpLinkFactory(factoryOpts) {
+  return (opts) => {
+    const resolvedOpts = resolveHTTPLinkOptions(opts);
+    return (runtime) => ({ op }) => observable((observer) => {
+      const { path, input, type } = op;
+      const { promise, cancel } = factoryOpts.requester({
+        ...resolvedOpts,
+        runtime,
+        type,
+        path,
+        input,
+        headers() {
+          if (!opts.headers) {
+            return {};
+          }
+          if (typeof opts.headers === "function") {
+            return opts.headers({
+              op
+            });
+          }
+          return opts.headers;
+        }
+      });
+      let meta = void 0;
+      promise.then((res) => {
+        meta = res.meta;
+        const transformed = transformResult(res.json, runtime);
+        if (!transformed.ok) {
+          observer.error(TRPCClientError.from(transformed.error, {
+            meta
+          }));
+          return;
+        }
+        observer.next({
+          context: res.meta,
+          result: transformed.result
+        });
+        observer.complete();
+      }).catch((cause) => {
+        observer.error(TRPCClientError.from(cause, {
+          meta
+        }));
+      });
+      return () => {
+        cancel();
+      };
+    });
   };
 }
-__name(httpBatchLink, "httpBatchLink");
+__name(httpLinkFactory, "httpLinkFactory");
+var httpLink = httpLinkFactory({
+  requester: jsonHttpRequester
+});
 
-// ../../../node_modules/.pnpm/@trpc+client@10.17.0_@trpc+server@10.17.0/node_modules/@trpc/client/dist/index.mjs
+// ../../../node_modules/.pnpm/@trpc+client@10.45.2_@trpc+server@10.45.2/node_modules/@trpc/client/dist/index.mjs
 var TRPCUntypedClient = class {
   $request({ type, input, path, context = {} }) {
     const chain$ = createChain({
@@ -738,23 +935,34 @@ var TRPCUntypedClient = class {
   }
   constructor(opts) {
     this.requestId = 0;
-    function getTransformer() {
+    const combinedTransformer = (() => {
       const transformer = opts.transformer;
-      if (!transformer)
-        return {
-          serialize: (data) => data,
-          deserialize: (data) => data
-        };
-      if ("input" in transformer)
+      if (!transformer) {
         return {
-          serialize: transformer.input.serialize,
-          deserialize: transformer.output.deserialize
+          input: {
+            serialize: (data) => data,
+            deserialize: (data) => data
+          },
+          output: {
+            serialize: (data) => data,
+            deserialize: (data) => data
+          }
         };
-      return transformer;
-    }
-    __name(getTransformer, "getTransformer");
+      }
+      if ("input" in transformer) {
+        return opts.transformer;
+      }
+      return {
+        input: transformer,
+        output: transformer
+      };
+    })();
     this.runtime = {
-      transformer: getTransformer()
+      transformer: {
+        serialize: (data) => combinedTransformer.input.serialize(data),
+        deserialize: (data) => combinedTransformer.output.deserialize(data)
+      },
+      combinedTransformer
     };
     this.links = opts.links.map((link) => link(this.runtime));
   }
@@ -765,18 +973,23 @@ var clientCallTypeMap = {
   mutate: "mutation",
   subscribe: "subscription"
 };
+var clientCallTypeToProcedureType = /* @__PURE__ */ __name((clientCallType) => {
+  return clientCallTypeMap[clientCallType];
+}, "clientCallTypeToProcedureType");
 function createTRPCClientProxy(client) {
   return createFlatProxy((key) => {
     if (client.hasOwnProperty(key)) {
       return client[key];
     }
+    if (key === "__untypedClient") {
+      return client;
+    }
     return createRecursiveProxy(({ path, args }) => {
       const pathCopy = [
         key,
         ...path
       ];
-      const clientCallType = pathCopy.pop();
-      const procedureType = clientCallTypeMap[clientCallType];
+      const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
       const fullPath = pathCopy.join(".");
       return client[procedureType](fullPath, ...args);
     });
@@ -789,6 +1002,161 @@ function createTRPCProxyClient(opts) {
   return proxy;
 }
 __name(createTRPCProxyClient, "createTRPCProxyClient");
+function getTextDecoder(customTextDecoder) {
+  if (customTextDecoder) {
+    return customTextDecoder;
+  }
+  if (typeof window !== "undefined" && window.TextDecoder) {
+    return new window.TextDecoder();
+  }
+  if (typeof globalThis !== "undefined" && globalThis.TextDecoder) {
+    return new globalThis.TextDecoder();
+  }
+  throw new Error("No TextDecoder implementation found");
+}
+__name(getTextDecoder, "getTextDecoder");
+async function parseJSONStream(opts) {
+  const parse = opts.parse ?? JSON.parse;
+  const onLine = /* @__PURE__ */ __name((line) => {
+    if (opts.signal?.aborted)
+      return;
+    if (!line || line === "}") {
+      return;
+    }
+    const indexOfColon = line.indexOf(":");
+    const indexAsStr = line.substring(2, indexOfColon - 1);
+    const text = line.substring(indexOfColon + 1);
+    opts.onSingle(Number(indexAsStr), parse(text));
+  }, "onLine");
+  await readLines(opts.readableStream, onLine, opts.textDecoder);
+}
+__name(parseJSONStream, "parseJSONStream");
+async function readLines(readableStream, onLine, textDecoder) {
+  let partOfLine = "";
+  const onChunk = /* @__PURE__ */ __name((chunk) => {
+    const chunkText = textDecoder.decode(chunk);
+    const chunkLines = chunkText.split("\n");
+    if (chunkLines.length === 1) {
+      partOfLine += chunkLines[0];
+    } else if (chunkLines.length > 1) {
+      onLine(partOfLine + chunkLines[0]);
+      for (let i = 1; i < chunkLines.length - 1; i++) {
+        onLine(chunkLines[i]);
+      }
+      partOfLine = chunkLines[chunkLines.length - 1];
+    }
+  }, "onChunk");
+  if ("getReader" in readableStream) {
+    await readStandardChunks(readableStream, onChunk);
+  } else {
+    await readNodeChunks(readableStream, onChunk);
+  }
+  onLine(partOfLine);
+}
+__name(readLines, "readLines");
+function readNodeChunks(stream, onChunk) {
+  return new Promise((resolve) => {
+    stream.on("data", onChunk);
+    stream.on("end", resolve);
+  });
+}
+__name(readNodeChunks, "readNodeChunks");
+async function readStandardChunks(stream, onChunk) {
+  const reader = stream.getReader();
+  let readResult = await reader.read();
+  while (!readResult.done) {
+    onChunk(readResult.value);
+    readResult = await reader.read();
+  }
+}
+__name(readStandardChunks, "readStandardChunks");
+var streamingJsonHttpRequester = /* @__PURE__ */ __name((opts, onSingle) => {
+  const ac = opts.AbortController ? new opts.AbortController() : null;
+  const responsePromise = fetchHTTPResponse({
+    ...opts,
+    contentTypeHeader: "application/json",
+    batchModeHeader: "stream",
+    getUrl,
+    getBody
+  }, ac);
+  const cancel = /* @__PURE__ */ __name(() => ac?.abort(), "cancel");
+  const promise = responsePromise.then(async (res) => {
+    if (!res.body)
+      throw new Error("Received response without body");
+    const meta = {
+      response: res
+    };
+    return parseJSONStream({
+      readableStream: res.body,
+      onSingle,
+      parse: (string) => ({
+        json: JSON.parse(string),
+        meta
+      }),
+      signal: ac?.signal,
+      textDecoder: opts.textDecoder
+    });
+  });
+  return {
+    cancel,
+    promise
+  };
+}, "streamingJsonHttpRequester");
+var streamRequester = /* @__PURE__ */ __name((requesterOpts) => {
+  const textDecoder = getTextDecoder(requesterOpts.opts.textDecoder);
+  return (batchOps, unitResolver) => {
+    const path = batchOps.map((op) => op.path).join(",");
+    const inputs = batchOps.map((op) => op.input);
+    const { cancel, promise } = streamingJsonHttpRequester({
+      ...requesterOpts,
+      textDecoder,
+      path,
+      inputs,
+      headers() {
+        if (!requesterOpts.opts.headers) {
+          return {};
+        }
+        if (typeof requesterOpts.opts.headers === "function") {
+          return requesterOpts.opts.headers({
+            opList: batchOps
+          });
+        }
+        return requesterOpts.opts.headers;
+      }
+    }, (index, res) => {
+      unitResolver(index, res);
+    });
+    return {
+      promise: promise.then(() => []),
+      cancel
+    };
+  };
+}, "streamRequester");
+var unstable_httpBatchStreamLink = createHTTPBatchLink(streamRequester);
+var getBody2 = /* @__PURE__ */ __name((opts) => {
+  if (!("input" in opts)) {
+    return void 0;
+  }
+  if (!(opts.input instanceof FormData)) {
+    throw new Error("Input is not FormData");
+  }
+  return opts.input;
+}, "getBody");
+var formDataRequester = /* @__PURE__ */ __name((opts) => {
+  if (opts.type !== "mutation") {
+    throw new Error("We only handle mutations with formdata");
+  }
+  return httpRequest({
+    ...opts,
+    getUrl() {
+      return `${opts.url}/${opts.path}`;
+    },
+    getBody: getBody2
+  });
+}, "formDataRequester");
+var experimental_formDataLink = httpLinkFactory({
+  requester: formDataRequester
+});
 
 // ../../learn-card-network/brain-client/dist/brain-client.esm.js
 var __defProp2 = Object.defineProperty;
@@ -831,7 +1199,11 @@ var getClient = /* @__PURE__ */ __name2(async (url, didAuthFunction) => {
   let challenges = [];
   const challengeRequester = createTRPCProxyClient({
     links: [
-      httpBatchLink({ url, headers: { Authorization: `Bearer ${await didAuthFunction()}` } })
+      httpBatchLink({
+        url,
+        maxURLLength: 2048,
+        headers: { Authorization: `Bearer ${await didAuthFunction()}` }
+      })
     ]
   });
   const getChallenges = /* @__PURE__ */ __name2(async (amount = 95 + Math.round((Math.random() - 0.5) * 5)) => {
@@ -844,6 +1216,7 @@ var getClient = /* @__PURE__ */ __name2(async (url, didAuthFunction) => {
         challenges = await getChallenges();
       }),
       httpBatchLink({
+        maxURLLength: 2048,
         url,
         headers: async () => {
           if (challenges.length === 0)
@@ -4608,11 +4981,17 @@ var BoostValidator = mod.object({
   status: LCNBoostStatus.optional(),
   autoConnectRecipients: mod.boolean().optional()
 });
+var PaginatedBoostsValidator = PaginationResponseValidator.extend({
+  records: BoostValidator.array()
+});
 var BoostRecipientValidator = mod.object({
   to: LCNProfileValidator,
   from: mod.string(),
   received: mod.string().optional()
 });
+var PaginatedBoostRecipientsValidator = PaginationResponseValidator.extend({
+  records: BoostRecipientValidator.array()
+});
 var LCNBoostClaimLinkSigningAuthorityValidator = mod.object({
   endpoint: mod.string(),
   name: mod.string(),
@@ -4945,21 +5324,39 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
           throw new Error("Please make an account first!");
         return client.profile.acceptConnectionRequest.mutate({ profileId });
       },
-      getConnections: async () => {
+      getConnections: async (_learnCard) => {
+        console.warn("The getConnections method is deprecated! Please use getPaginatedConnections instead!");
         if (!userData)
           throw new Error("Please make an account first!");
         return client.profile.connections.query();
       },
-      getPendingConnections: async () => {
+      getPaginatedConnections: async (_learnCard, options) => {
+        if (!userData)
+          throw new Error("Please make an account first!");
+        return client.profile.paginatedConnections.query(options);
+      },
+      getPendingConnections: async (_learnCard) => {
+        console.warn("The getPendingConnections method is deprecated! Please use getPaginatedPendingConnections instead!");
         if (!userData)
           throw new Error("Please make an account first!");
         return client.profile.pendingConnections.query();
       },
-      getConnectionRequests: async () => {
+      getPaginatedPendingConnections: async (_learnCard, options) => {
+        if (!userData)
+          throw new Error("Please make an account first!");
+        return client.profile.paginatedPendingConnections.query(options);
+      },
+      getConnectionRequests: async (_learnCard) => {
+        console.warn("The getConnectionRequests method is deprecated! Please use getPaginatedConnectionRequests instead!");
         if (!userData)
           throw new Error("Please make an account first!");
         return client.profile.connectionRequests.query();
       },
+      getPaginatedConnectionRequests: async (_learnCard, options) => {
+        if (!userData)
+          throw new Error("Please make an account first!");
+        return client.profile.paginatedConnectionRequests.query(options);
+      },
       generateInvite: async (_learnCard, challenge, expiration) => {
         if (!userData)
           throw new Error("Please make an account first!");
@@ -5067,12 +5464,19 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
           throw new Error("Please make an account first!");
         return client.boost.getBoost.query({ uri });
       },
-      getBoosts: async () => {
+      getBoosts: async (_learnCard) => {
+        console.warn("The getBoosts method is deprecated! Please use getPaginatedBoosts instead!");
         if (!userData)
           throw new Error("Please make an account first!");
         return client.boost.getBoosts.query();
       },
+      getPaginatedBoosts: async (_learnCard, options) => {
+        if (!userData)
+          throw new Error("Please make an account first!");
+        return client.boost.getPaginatedBoosts.query(options);
+      },
       getBoostRecipients: async (_learnCard, uri, limit = 25, skip = void 0, includeUnacceptedBoosts = true) => {
+        console.warn("The getBoostRecipients method is deprecated! Please use getPaginatedBoostRecipients instead!");
         if (!userData)
           throw new Error("Please make an account first!");
         return client.boost.getBoostRecipients.query({
@@ -5082,6 +5486,16 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
           includeUnacceptedBoosts
         });
       },
+      getPaginatedBoostRecipients: async (_learnCard, uri, limit = 25, cursor = void 0, includeUnacceptedBoosts = true) => {
+        if (!userData)
+          throw new Error("Please make an account first!");
+        return client.boost.getPaginatedBoostRecipients.query({
+          uri,
+          limit,
+          cursor,
+          includeUnacceptedBoosts
+        });
+      },
       countBoostRecipients: async (_learnCard, uri, includeUnacceptedBoosts = true) => {
         if (!userData)
           throw new Error("Please make an account first!");