@multiagency/sdk 0.3.1

package/dist/contract/orpc-client.js

@@ -0,0 +1,2037 @@
+// ../../../node_modules/.pnpm/@standard-server+shared@0.13.0/node_modules/@standard-server/shared/dist/index.mjs
+function toArray(value2) {
+  return Array.isArray(value2) ? value2 : value2 === void 0 || value2 === null ? [] : [value2];
+}
+function sequential(fn) {
+  let lastOperationPromise = Promise.resolve();
+  return (...args) => {
+    return lastOperationPromise = lastOperationPromise.catch(() => {
+    }).then(() => {
+      return fn(...args);
+    });
+  };
+}
+function isAsyncIteratorObject(maybe) {
+  if (!maybe || typeof maybe !== "object") {
+    return false;
+  }
+  return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+var fallbackAsyncDisposeSymbol = /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
+var AsyncIteratorClass = class {
+  isDone = false;
+  isExecuteComplete = false;
+  cleanup;
+  next;
+  constructor(next, cleanup) {
+    this.cleanup = cleanup;
+    this.next = sequential(async () => {
+      if (this.isDone) {
+        return { done: true, value: void 0 };
+      }
+      let errorRef;
+      try {
+        const result = await next();
+        if (this.isDone) {
+          return { done: true, value: void 0 };
+        }
+        if (result.done) {
+          this.isDone = true;
+        }
+        return result;
+      } catch (error) {
+        if (this.isDone) {
+          return { done: true, value: void 0 };
+        }
+        errorRef = { value: error };
+        this.isDone = true;
+        throw error;
+      } finally {
+        if (this.isDone && !this.isExecuteComplete) {
+          this.isExecuteComplete = true;
+          await this.cleanup(
+            errorRef ? { kind: "error", error: errorRef.value } : { kind: "success" }
+          );
+        }
+      }
+    });
+  }
+  async return(value2) {
+    this.isDone = true;
+    if (!this.isExecuteComplete) {
+      this.isExecuteComplete = true;
+      await this.cleanup({ kind: "cancelled" });
+    }
+    return { done: true, value: value2 };
+  }
+  async throw(error) {
+    this.isDone = true;
+    if (!this.isExecuteComplete) {
+      this.isExecuteComplete = true;
+      await this.cleanup({ kind: "cancelled", error });
+    }
+    throw error;
+  }
+  /**
+   * Uses the native Symbol.asyncDispose, or Symbol.for('Symbol.asyncDispose') on runtimes without it
+   */
+  async [asyncDisposeSymbol]() {
+    this.isDone = true;
+    if (!this.isExecuteComplete) {
+      this.isExecuteComplete = true;
+      await this.cleanup({ kind: "cancelled" });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+function parseEmptyableJSON(text) {
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function stringifyJSON(value2) {
+  return JSON.stringify(value2);
+}
+function isTypescriptObject(maybeObject) {
+  if (!maybeObject) {
+    return false;
+  }
+  const type = typeof maybeObject;
+  return type === "object" || type === "function";
+}
+var GET_OR_BIND_CACHE = /* @__PURE__ */ new WeakMap();
+function getOrBind(target, property, { bind = true } = {}) {
+  const value2 = Reflect.get(target, property);
+  if (!bind || typeof value2 !== "function") {
+    return value2;
+  }
+  let targetCache = GET_OR_BIND_CACHE.get(value2);
+  if (!targetCache) {
+    GET_OR_BIND_CACHE.set(value2, targetCache = /* @__PURE__ */ new WeakMap());
+  }
+  let bound = targetCache.get(target);
+  if (!bound) {
+    targetCache.set(target, bound = value2.bind(target));
+  }
+  return bound;
+}
+var LONE_SURROGATE_REGEX = /[\uD800-\uDFFF]/gu;
+function safeEncodeURIComponent(value2) {
+  try {
+    return encodeURIComponent(value2);
+  } catch {
+    return encodeURIComponent(value2.replace(LONE_SURROGATE_REGEX, "\uFFFD"));
+  }
+}
+function safeDecodeURIComponent(value2) {
+  if (!value2.includes("%")) {
+    return value2;
+  }
+  try {
+    return decodeURIComponent(value2);
+  } catch {
+    return value2;
+  }
+}
+
+// ../../../node_modules/.pnpm/@orpc+shared@2.0.0-beta.47/node_modules/@orpc/shared/dist/index.mjs
+function resolveMaybeOptionalOptions(rest) {
+  return rest[0] ?? {};
+}
+var DEFAULT_MAX_BIGINT_DIGITS = 4300;
+var BIGINT_PATTERN = /^-?(?:0|[1-9]\d*)$/;
+function parseBigIntString(value2, maxDigits) {
+  const digits = value2.startsWith("-") ? value2.length - 1 : value2.length;
+  if (digits > maxDigits || !BIGINT_PATTERN.test(value2)) {
+    return void 0;
+  }
+  return BigInt(value2);
+}
+function* getConstructors(value2) {
+  if (!isTypescriptObject(value2)) {
+    return;
+  }
+  let proto = Object.getPrototypeOf(value2);
+  while (proto != null) {
+    if (proto.constructor) {
+      yield proto.constructor;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+}
+function isPlainObject(value2) {
+  if (!value2 || typeof value2 !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value2);
+  return proto === Object.prototype || !proto || !proto.constructor;
+}
+function setOwn(object, key, value2) {
+  if (key === "__proto__") {
+    Object.defineProperty(object, key, {
+      value: value2,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  } else {
+    object[key] = value2;
+  }
+}
+function copyOnWrite(parent, key, original) {
+  const value2 = parent[key];
+  if (value2 !== original) {
+    return value2;
+  }
+  let copy;
+  if (Array.isArray(value2)) {
+    copy = value2.slice();
+  } else if (isPlainObject(value2)) {
+    copy = { ...value2 };
+  } else {
+    return value2;
+  }
+  setOwn(parent, key, copy);
+  return copy;
+}
+var NullProtoObj = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  e.prototype = /* @__PURE__ */ Object.create(null);
+  Object.freeze(e.prototype);
+  return e;
+})();
+var ORPC_NAME = "orpc";
+function isAbortError(error) {
+  return error instanceof Error && error.name.includes("Abort");
+}
+var AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {
+}).constructor;
+function once(fn) {
+  let cached;
+  return () => {
+    if (cached) {
+      return cached.result;
+    }
+    const result = fn();
+    cached = { result };
+    return result;
+  };
+}
+function pathToHttpPath(path) {
+  return `/${path.map(safeEncodeURIComponent).join("/")}`;
+}
+var TRACER_SYMBOL = /* @__PURE__ */ Symbol.for("ORPC_TRACER");
+function getTracer() {
+  return globalThis[TRACER_SYMBOL];
+}
+function startSpan(options) {
+  const tracer = getTracer();
+  if (!tracer) {
+    return void 0;
+  }
+  if (typeof options === "string") {
+    return tracer.startSpan(options);
+  }
+  return tracer.startSpan(options.name, options.parent);
+}
+function recordSpanError(span, error) {
+  if (!span) {
+    return;
+  }
+  span.recordException(isAbortError(error) ? "info" : "error", toTracingException(error));
+}
+function toTracingException(error) {
+  if (error instanceof Error) {
+    const exception = {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+    if ("code" in error && (typeof error.code === "string" || typeof error.code === "number")) {
+      exception.code = error.code;
+    }
+    return exception;
+  }
+  return { message: String(error) };
+}
+async function runWithSpan(options, fn) {
+  const tracer = getTracer();
+  if (!tracer) {
+    return fn();
+  }
+  const name = typeof options === "string" ? options : options.name;
+  const parent = typeof options === "string" ? void 0 : options.parent;
+  return tracer.startActiveSpan(name, parent, async (span) => {
+    try {
+      return await fn(span);
+    } catch (e) {
+      recordSpanError(span, e);
+      throw e;
+    } finally {
+      span.end();
+    }
+  });
+}
+function runInSpanContext(span, fn) {
+  const tracer = getTracer();
+  if (!span || !tracer) {
+    return fn();
+  }
+  return tracer.withActiveSpan(span, fn);
+}
+function wrapAsyncIterator(iterator, { runWith, mapResult, mapError, onError, onFinish }) {
+  runWith ??= (run) => run();
+  let isDone;
+  return new AsyncIteratorClass(async () => {
+    try {
+      let result;
+      try {
+        result = await runWith(() => iterator.next());
+        isDone = result.done;
+      } catch (error) {
+        isDone = true;
+        throw error;
+      }
+      return mapResult ? await mapResult(result) : result;
+    } catch (error) {
+      await onError?.(error);
+      throw mapError ? await mapError(error) : error;
+    }
+  }, async (_state) => {
+    try {
+      if (!isDone) {
+        try {
+          await runWith(async () => iterator.return?.());
+        } catch (error) {
+          await onError?.(error);
+          throw error;
+        }
+      }
+    } finally {
+      await onFinish?.();
+    }
+  });
+}
+function traceAsyncIterator(options, iterator) {
+  const getSpan = once(() => startSpan(options));
+  return wrapAsyncIterator(iterator, {
+    runWith: (run) => runInSpanContext(getSpan(), run),
+    mapResult(result) {
+      getSpan()?.addEvent(result.done ? "completed" : "yielded");
+      return result;
+    },
+    onError(error) {
+      recordSpanError(getSpan(), error);
+    },
+    onFinish() {
+      getSpan()?.end();
+    }
+  });
+}
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
+  }
+  return value2;
+}
+function override(target, partial) {
+  const proxy = new Proxy(typeof target === "function" ? partial : target, {
+    get(_, prop) {
+      const targetValue = prop in partial ? partial : value(target);
+      return getOrBind(targetValue, prop);
+    },
+    has(_, prop) {
+      return Reflect.has(partial, prop) || Reflect.has(value(target), prop);
+    }
+  });
+  return proxy;
+}
+function wrapReadableStream(stream, { runWith, mapResult, mapError, onError, onFinish }) {
+  runWith ??= (run) => run();
+  const reader = once(() => stream.getReader());
+  const finish = once(async () => onFinish?.());
+  return new ReadableStream({
+    async pull(controller) {
+      let result;
+      try {
+        const readResult = await runWith(() => reader().read());
+        result = mapResult ? await mapResult(readResult) : readResult;
+      } catch (error) {
+        try {
+          await onError?.(error);
+          controller.error(mapError ? await mapError(error) : error);
+        } finally {
+          await finish();
+        }
+        return;
+      }
+      if (result.done) {
+        controller.close();
+        await finish();
+      } else {
+        controller.enqueue(result.value);
+      }
+    },
+    async cancel(reason) {
+      try {
+        try {
+          await runWith(() => reader().cancel(reason));
+        } catch (error) {
+          await onError?.(error);
+          throw error;
+        }
+      } finally {
+        await finish();
+      }
+    }
+  }, { highWaterMark: 0 });
+}
+function traceReadableStream(options, stream) {
+  const getSpan = once(() => startSpan(options));
+  return wrapReadableStream(stream, {
+    runWith: (run) => runInSpanContext(getSpan(), run),
+    mapResult(result) {
+      getSpan()?.addEvent(result.done ? "closed" : "enqueued");
+      return result;
+    },
+    onError(error) {
+      recordSpanError(getSpan(), error);
+    },
+    onFinish() {
+      getSpan()?.end();
+    }
+  });
+}
+function intercept(interceptors, options, main) {
+  if (!interceptors?.length) {
+    return main(options);
+  }
+  const next = (options2, index) => {
+    const interceptor = interceptors[index];
+    if (!interceptor) {
+      return main(options2);
+    }
+    return interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions, index + 1)
+    });
+  };
+  return next(options, 0);
+}
+function sortPlugins(plugins) {
+  const pluginCount = plugins.length;
+  const pluginIdToIndices = /* @__PURE__ */ new Map();
+  for (let i = 0; i < pluginCount; i++) {
+    const plugin = plugins[i];
+    const indices = pluginIdToIndices.get(plugin.name);
+    if (indices === void 0) {
+      pluginIdToIndices.set(plugin.name, [i]);
+    } else {
+      indices.push(i);
+    }
+  }
+  const dependencies = Array.from({ length: pluginCount }, () => []);
+  for (let i = 0; i < pluginCount; i++) {
+    const plugin = plugins[i];
+    if (plugin.before !== void 0) {
+      for (const beforeId of plugin.before) {
+        const beforeIndices = pluginIdToIndices.get(beforeId);
+        if (beforeIndices !== void 0) {
+          for (const beforeIndex of beforeIndices) {
+            dependencies[beforeIndex].push(i);
+          }
+        }
+      }
+    }
+    if (plugin.after !== void 0) {
+      for (const afterId of plugin.after) {
+        const afterIndices = pluginIdToIndices.get(afterId);
+        if (afterIndices !== void 0) {
+          for (const afterIndex of afterIndices) {
+            dependencies[i].push(afterIndex);
+          }
+        }
+      }
+    }
+  }
+  const sorted = [];
+  const placed = /* @__PURE__ */ new Set();
+  while (sorted.length < pluginCount) {
+    const next = plugins.findIndex((_, i) => !placed.has(i) && dependencies[i].every((dependency) => placed.has(dependency)));
+    if (next === -1) {
+      throw new Error(`Circular dependency detected involving plugin "${findCyclicPlugin(plugins, dependencies, placed).name}"`);
+    }
+    placed.add(next);
+    sorted.push(plugins[next]);
+  }
+  return sorted;
+}
+function findCyclicPlugin(plugins, dependencies, placed) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = plugins.findIndex((_, i) => !placed.has(i));
+  while (!seen.has(current)) {
+    seen.add(current);
+    current = dependencies[current].find((dependency) => !placed.has(dependency));
+  }
+  return plugins[current];
+}
+
+// ../../../node_modules/.pnpm/@standard-server+core@0.13.0/node_modules/@standard-server/core/dist/index.mjs
+var EventStreamEncoderError = class extends TypeError {
+};
+var EventStreamDecoderError = class extends TypeError {
+};
+var ErrorEvent = class extends Error {
+  constructor(data, options = {}) {
+    super(options?.message ?? "Error Event", options);
+    this.data = data;
+  }
+};
+var EVENT_STREAM_LINE_ENDING_REGEX = /\r\n|[\n\r]/;
+var EVENT_STREAM_LINE_ENDING_GLOBAL_REGEX = /\r\n|[\n\r]/g;
+var EVENT_STREAM_INVALID_ID_CHAR_REGEX = /[\r\n\0]/;
+function containsEventStreamLineBreak(value2) {
+  return EVENT_STREAM_LINE_ENDING_REGEX.test(value2);
+}
+function isEventStreamMessageId(maybe) {
+  return typeof maybe === "string" && !EVENT_STREAM_INVALID_ID_CHAR_REGEX.test(maybe);
+}
+function isEventStreamMessageRetry(maybe) {
+  return Number.isInteger(maybe) && maybe >= 0;
+}
+function isEventStreamMessageComment(maybe) {
+  return typeof maybe === "string" && !containsEventStreamLineBreak(maybe);
+}
+function assertEventStreamMessageId(id) {
+  if (!isEventStreamMessageId(id)) {
+    throw new EventStreamEncoderError(
+      "Event's id must not contain a carriage return, newline or NULL character"
+    );
+  }
+}
+function assertEventStreamMessageName(event) {
+  if (containsEventStreamLineBreak(event)) {
+    throw new EventStreamEncoderError(
+      "Event's event must not contain a carriage return or newline character"
+    );
+  }
+}
+function assertEventStreamMessageRetry(retry) {
+  if (!isEventStreamMessageRetry(retry)) {
+    throw new EventStreamEncoderError("Event's retry must be a integer and >= 0");
+  }
+}
+function assertEventStreamMessageComment(comment) {
+  if (!isEventStreamMessageComment(comment)) {
+    throw new EventStreamEncoderError(
+      "Event's comment must not contain a carriage return or newline character"
+    );
+  }
+}
+function encodeEventStreamMessageData(data) {
+  if (data === void 0) {
+    return "";
+  }
+  return `data: ${data.replace(EVENT_STREAM_LINE_ENDING_GLOBAL_REGEX, "\ndata: ")}
+`;
+}
+function encodeEventStreamMessageComments(comments) {
+  let output = "";
+  for (const comment of comments ?? []) {
+    assertEventStreamMessageComment(comment);
+    output += `: ${comment}
+`;
+  }
+  return output;
+}
+function encodeEventStreamMessage(message) {
+  let output = "";
+  output += encodeEventStreamMessageComments(message.comments);
+  if (message.event !== void 0 && (message.event !== "message" || message.data === void 0)) {
+    assertEventStreamMessageName(message.event);
+    output += `event: ${message.event}
+`;
+  }
+  if (message.retry !== void 0) {
+    assertEventStreamMessageRetry(message.retry);
+    output += `retry: ${message.retry}
+`;
+  }
+  if (message.id !== void 0) {
+    assertEventStreamMessageId(message.id);
+    output += `id: ${message.id}
+`;
+  }
+  output += encodeEventStreamMessageData(message.data);
+  output += "\n";
+  return output;
+}
+var LINE_ENDING_REGEX = /\r\n?|\n/;
+var MESSAGE_DELIMITER_REGEX = /[\r\n]{3,}|\r\r|\n[\r\n]/g;
+var LEADING_LINE_ENDINGS_REGEX = /^[\r\n]+/;
+var ASCII_DIGITS_REGEX = /^\d+$/;
+var SPACE = 32;
+var LF = 10;
+var CR = 13;
+function decodeEventStreamMessage(encoded) {
+  const message = {};
+  for (const line of encoded.split(LINE_ENDING_REGEX)) {
+    if (line === "") {
+      continue;
+    }
+    const index = line.indexOf(":");
+    const value2 = index === -1 ? "" : line.slice(line.charCodeAt(index + 1) === SPACE ? index + 2 : index + 1);
+    if (index === 0) {
+      (message.comments ??= []).push(value2);
+      continue;
+    }
+    switch (index === -1 ? line : line.slice(0, index)) {
+      case "data":
+        message.data = message.data === void 0 ? value2 : `${message.data}
+${value2}`;
+        break;
+      case "event":
+        message.event = value2;
+        break;
+      case "id":
+        if (isEventStreamMessageId(value2)) {
+          message.id = value2;
+        }
+        break;
+      case "retry": {
+        const retry = Number.parseInt(value2, 10);
+        if (ASCII_DIGITS_REGEX.test(value2) && isEventStreamMessageRetry(retry)) {
+          message.retry = retry;
+        }
+        break;
+      }
+    }
+  }
+  if (!message.event) {
+    if (message.data === void 0) {
+      delete message.event;
+    } else {
+      message.event = "message";
+    }
+  }
+  return message;
+}
+var EventStreamDecoder = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+  }
+  // The incomplete message: empty, or text that neither starts with a line
+  // ending nor contains a blank line.
+  pending = [];
+  // Last MAX_DELIMITER_OVERLAP characters of the pending text, prefixed to the
+  // next chunk so a delimiter straddling the boundary is still found.
+  tail = "";
+  feed(chunk) {
+    if (this.pending.length === 0) {
+      const first = chunk.charCodeAt(0);
+      if (first === LF || first === CR) {
+        chunk = chunk.replace(LEADING_LINE_ENDINGS_REGEX, "");
+      }
+    }
+    if (chunk === "") {
+      return;
+    }
+    const scan = this.tail + chunk;
+    this.pending.push(chunk);
+    MESSAGE_DELIMITER_REGEX.lastIndex = 0;
+    let match = MESSAGE_DELIMITER_REGEX.exec(scan);
+    if (match === null) {
+      this.tail = scan.slice(-2);
+      return;
+    }
+    const buffered = this.pending.length === 1 ? chunk : this.pending.join("");
+    const offset = buffered.length - scan.length;
+    const parts = [];
+    let start = 0;
+    while (match !== null) {
+      parts.push(buffered.slice(start, offset + match.index));
+      start = offset + match.index + match[0].length;
+      match = MESSAGE_DELIMITER_REGEX.exec(scan);
+    }
+    const incomplete = buffered.slice(start);
+    this.pending = incomplete === "" ? [] : [incomplete];
+    this.tail = incomplete.slice(-2);
+    for (const encoded of parts) {
+      this.onEvent(decodeEventStreamMessage(encoded));
+    }
+  }
+  end() {
+    if (this.pending.length !== 0) {
+      throw new EventStreamDecoderError("Event Stream ended before complete");
+    }
+  }
+};
+var EventStreamDecoderStream = class {
+  readable;
+  writable;
+  constructor() {
+    let decoder;
+    const transform = new TransformStream({
+      start(controller) {
+        decoder = new EventStreamDecoder((event) => {
+          controller.enqueue(event);
+        });
+      },
+      transform(chunk) {
+        decoder.feed(chunk);
+      },
+      flush() {
+        decoder.end();
+      }
+    });
+    this.readable = transform.readable;
+    this.writable = transform.writable;
+  }
+};
+var EVENT_META_SYMBOL = /* @__PURE__ */ Symbol.for("STANDARD_SERVER_EVENT_META");
+var EVENT_SOURCE_SYMBOL = /* @__PURE__ */ Symbol.for("STANDARD_SERVER_EVENT_SOURCE");
+function withEventMeta(container, meta) {
+  let assertedMeta;
+  if (meta.id !== void 0) {
+    assertEventStreamMessageId(meta.id);
+    assertedMeta ??= {};
+    assertedMeta.id = meta.id;
+  }
+  if (meta.retry !== void 0) {
+    assertEventStreamMessageRetry(meta.retry);
+    assertedMeta ??= {};
+    assertedMeta.retry = meta.retry;
+  }
+  if (meta.comments !== void 0) {
+    for (const comment of meta.comments) {
+      assertEventStreamMessageComment(comment);
+    }
+    assertedMeta ??= {};
+    assertedMeta.comments = meta.comments;
+  }
+  if (!assertedMeta) {
+    return container;
+  }
+  return new Proxy(container, {
+    get(target, prop, _receiver) {
+      if (prop === EVENT_SOURCE_SYMBOL) {
+        return target;
+      }
+      if (prop === EVENT_META_SYMBOL) {
+        return assertedMeta;
+      }
+      return getOrBind(target, prop, { bind: prop !== "constructor" });
+    }
+  });
+}
+function unwrapEvent(container) {
+  if (!isTypescriptObject(container)) {
+    return [container, void 0];
+  }
+  const meta = container[EVENT_META_SYMBOL];
+  const target = container[EVENT_SOURCE_SYMBOL] ?? container;
+  return [target, meta];
+}
+function getEventMeta(container) {
+  if (!isTypescriptObject(container)) {
+    return void 0;
+  }
+  return container[EVENT_META_SYMBOL];
+}
+var FALLBACK_FILENAME_UNSAFE_CHAR_REGEX = /[^\x20-\x7E]|[;=]/g;
+var QUOTED_STRING_SPECIAL_CHAR_REGEX = /[\\"]/g;
+var QUOTED_PAIR_REGEX = /\\(.)/g;
+var EXT_VALUE_RESERVED_CHAR_REGEX = /['()*]/g;
+var EXT_VALUE_ALLOWED_ESCAPE_REGEX = /%(7C|60|5E)/g;
+var EXT_VALUE_REGEX = /^([^']*)'[^']*'(.*)$/;
+var EXT_VALUE_SUPPORTED_CHARSET_REGEX = /^(?:utf-8|us-ascii)$/i;
+var CONTENT_DISPOSITION_PARAM_REGEX = /[\s;]*([^;=]*)(?:=\s*(?:"((?:\\.|[^"\\])*)"[^;]*|"[\s\S]*|([^;]*)))?/y;
+function generateContentDisposition(filename, type = "inline") {
+  const encodedFilename = filename.replace(FALLBACK_FILENAME_UNSAFE_CHAR_REGEX, "_").replace(QUOTED_STRING_SPECIAL_CHAR_REGEX, "\\$&");
+  const encodedFilenameStar = safeEncodeURIComponent(filename).replace(EXT_VALUE_RESERVED_CHAR_REGEX, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(
+    EXT_VALUE_ALLOWED_ESCAPE_REGEX,
+    (str, hex) => String.fromCharCode(Number.parseInt(hex, 16))
+  );
+  return `${type}; filename="${encodedFilename}"; filename*=utf-8''${encodedFilenameStar}`;
+}
+function getContentDispositionParam(contentDisposition, name) {
+  CONTENT_DISPOSITION_PARAM_REGEX.lastIndex = 0;
+  while (CONTENT_DISPOSITION_PARAM_REGEX.lastIndex < contentDisposition.length) {
+    const [, paramName = "", quoted, token] = CONTENT_DISPOSITION_PARAM_REGEX.exec(contentDisposition);
+    if (paramName.trimEnd().toLowerCase() === name) {
+      return quoted !== void 0 ? quoted.replace(QUOTED_PAIR_REGEX, "$1") : token?.trim() || void 0;
+    }
+  }
+  return void 0;
+}
+function getFilenameFromContentDisposition(contentDisposition) {
+  const extValue = getContentDispositionParam(contentDisposition, "filename*");
+  const extValueMatch = extValue?.match(EXT_VALUE_REGEX);
+  if (extValueMatch) {
+    const [, charset = "", encodedFilename = ""] = extValueMatch;
+    if (EXT_VALUE_SUPPORTED_CHARSET_REGEX.test(charset)) {
+      return safeDecodeURIComponent(encodedFilename);
+    }
+  } else if (extValue) {
+    return safeDecodeURIComponent(extValue);
+  }
+  return getContentDispositionParam(contentDisposition, "filename");
+}
+function flattenStandardHeader(header) {
+  if (typeof header === "string" || header === void 0) {
+    return header;
+  }
+  if (header.length === 0) {
+    return void 0;
+  }
+  return header.join(", ");
+}
+var STANDARD_BODY_HINT_SET = /* @__PURE__ */ new Set([
+  "json",
+  "form-data",
+  "url-search-params",
+  "event-stream",
+  "octet-stream",
+  "file",
+  "none"
+]);
+function resolveStandardBodyHint(headers) {
+  const hint = flattenStandardHeader(headers["standard-server"]);
+  if (hint !== void 0 && STANDARD_BODY_HINT_SET.has(hint)) {
+    return hint;
+  }
+  const mimeType = flattenStandardHeader(headers["content-type"])?.split(";")[0]?.trim().toLowerCase();
+  const contentLength = flattenStandardHeader(headers["content-length"]);
+  if (mimeType === void 0 && (contentLength === void 0 || contentLength === "0")) {
+    return "none";
+  }
+  if (mimeType === "application/json") {
+    return "json";
+  }
+  if (mimeType === "multipart/form-data") {
+    return "form-data";
+  }
+  if (mimeType === "application/x-www-form-urlencoded") {
+    return "url-search-params";
+  }
+  if (mimeType === "text/event-stream") {
+    return "event-stream";
+  }
+  if (contentLength !== void 0) {
+    return "file";
+  }
+  const contentDisposition = flattenStandardHeader(headers["content-disposition"]);
+  if (contentDisposition !== void 0 && getFilenameFromContentDisposition(contentDisposition) !== void 0) {
+    return "file";
+  }
+  return "octet-stream";
+}
+function getRequiredStandardBodyHint(hint, headers) {
+  const resolved = resolveStandardBodyHint({
+    "content-type": headers["content-type"],
+    "content-length": headers["content-length"],
+    "content-disposition": headers["content-disposition"]
+  });
+  return resolved === hint ? void 0 : hint;
+}
+function mergeStandardHeaders(a, b) {
+  const merged = { ...a, ...b };
+  for (const key of Object.keys(b)) {
+    if (!Object.hasOwn(a, key)) {
+      continue;
+    }
+    const aValue = a[key];
+    const bValue = b[key];
+    merged[key] = aValue === void 0 || bValue === void 0 ? aValue ?? bValue : [...toArray(aValue), ...toArray(bValue)];
+  }
+  return merged;
+}
+function parseStandardUrl(url) {
+  const hashStart = url.indexOf("#");
+  const searchStart = url.indexOf("?");
+  const hasSearchBeforeHash = searchStart !== -1 && (hashStart === -1 || searchStart < hashStart);
+  const pathnameEnd = hasSearchBeforeHash ? searchStart : hashStart !== -1 ? hashStart : url.length;
+  const searchEnd = hashStart !== -1 ? hashStart : url.length;
+  const pathname = url.slice(0, pathnameEnd);
+  const search = hasSearchBeforeHash ? url.slice(searchStart, searchEnd) : void 0;
+  const hash = hashStart !== -1 ? url.slice(hashStart) : void 0;
+  return [pathname, search, hash];
+}
+
+// ../../../node_modules/.pnpm/@orpc+client@2.0.0-beta.47/node_modules/@orpc/client/dist/shared/client.LF04eOvL.mjs
+var COMMON_ERROR_STATUS_MAP = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_SUPPORTED: 405,
+  NOT_ACCEPTABLE: 406,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_CONTENT: 422,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  CLIENT_CLOSED_REQUEST: 499,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+var ORPCErrorConstructors;
+var ORPCError = class _ORPCError extends Error {
+  static {
+    const ORPC_ERROR_CONSTRUCTORS_SYMBOL = /* @__PURE__ */ Symbol.for("ORPC_ERROR_CONSTRUCTORS");
+    void (globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
+    ORPCErrorConstructors = globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+    ORPCErrorConstructors.add(_ORPCError);
+  }
+  /**
+   * @remarks
+   * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
+   * an `ORPCError` instance from plain objects with a similar structure.
+   */
+  name = "ORPCError";
+  /**
+   * Indicates whether the error matches a definition in the procedure's `.errors` map,
+   * which makes its type inferable on the client.
+   */
+  defined = false;
+  code;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    const message = options.message ?? codeToMessage(code);
+    super(message, options);
+    this.code = code;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+  /**
+   * Workaround for Next.js where different contexts use separate
+   * dependency graphs, causing multiple ORPCError constructors existing and breaking
+   * `instanceof` checks across contexts.
+   *
+   * This is particularly problematic with "Optimized SSR", where orpc-client
+   * executes in one context but is invoked from another. When an error is thrown
+   * in the execution context, `instanceof ORPCError` checks fail in the
+   * invocation context due to separate class constructors.
+   *
+   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (!ORPCErrorConstructors.has(this)) {
+      return super[Symbol.hasInstance](instance);
+    }
+    for (const constructor of getConstructors(instance)) {
+      if (ORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+var ResponseError = class extends Error {
+  name = "ResponseError";
+  response;
+  constructor(options) {
+    super(options.message ?? `Received a ${options.response.status} response.`, options);
+    this.response = options.response;
+  }
+};
+var MalformedResponseError = class extends ResponseError {
+  name = "MalformedResponseError";
+  constructor(options) {
+    super({ ...options, message: options.message ?? inferMalformedResponseMessage(options.response) });
+  }
+};
+var INFERRED_MESSAGE_MAX_LENGTH = 256;
+function inferMalformedResponseMessage(response) {
+  const candidate = isPlainObject(response.body) ? response.body.message : response.body;
+  if (typeof candidate === "string" && candidate.length > 0 && candidate.length <= INFERRED_MESSAGE_MAX_LENGTH) {
+    return candidate;
+  }
+  const commonCode = Object.entries(COMMON_ERROR_STATUS_MAP).find(([, status]) => status === response.status)?.[0];
+  return commonCode ? codeToMessage(commonCode) : "Malformed oRPC Response";
+}
+function codeToMessage(code) {
+  return code.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+
+// ../../../node_modules/.pnpm/@orpc+client@2.0.0-beta.47/node_modules/@orpc/client/dist/shared/client._wG5INmC.mjs
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", { cause: error });
+}
+function isORPCErrorJson(json) {
+  if (!isPlainObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  const error = new ORPCError(json.code, {
+    ...json,
+    ...options
+  });
+  error.defined = json.defined;
+  return error;
+}
+function wrapAsyncIteratorPreservingEventMeta(iterator, { mapResult, mapError, ...rest }) {
+  return wrapAsyncIterator(iterator, {
+    ...rest,
+    mapResult: mapResult && (async (result) => {
+      const mapped = await mapResult(result);
+      if (mapped.value !== result.value) {
+        const meta = getEventMeta(result.value);
+        if (meta && isTypescriptObject(mapped.value)) {
+          return { done: mapped.done, value: withEventMeta(mapped.value, meta) };
+        }
+      }
+      return mapped;
+    }),
+    mapError: mapError && (async (error) => {
+      const mapped = await mapError(error);
+      if (mapped !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isTypescriptObject(mapped)) {
+          return withEventMeta(mapped, meta);
+        }
+      }
+      return mapped;
+    })
+  });
+}
+function invalidSerializedData(detail) {
+  return new TypeError(`Invalid RPC serialized data: ${detail}`);
+}
+function assertSerializedType(ok, type, expected) {
+  if (!ok) {
+    throw invalidSerializedData(`type "${type}" expects ${expected}.`);
+  }
+}
+function isWalkable(value2) {
+  return Array.isArray(value2) || isPlainObject(value2);
+}
+function walkInto(parent, key, original, restored) {
+  const value2 = parent[key];
+  if (!isWalkable(value2) || restored?.has(value2)) {
+    throw invalidSerializedData(`segment "${key}" cannot be walked into.`);
+  }
+  return value2 === original ? copyOnWrite(parent, key, original) : value2;
+}
+var DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
+  undefined: {
+    condition(data) {
+      return data === void 0;
+    },
+    serialize() {
+      return null;
+    },
+    deserialize(serialized) {
+      assertSerializedType(serialized === null, "undefined", "null");
+      return void 0;
+    },
+    isTerminal: true
+  },
+  bigint: {
+    condition(data) {
+      return typeof data === "bigint";
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      assertSerializedType(typeof serialized === "string", "bigint", "a string");
+      const value2 = parseBigIntString(serialized, DEFAULT_MAX_BIGINT_DIGITS);
+      if (value2 === void 0) {
+        throw invalidSerializedData(`type "bigint" expects a decimal integer string of at most ${DEFAULT_MAX_BIGINT_DIGITS} digits.`);
+      }
+      return value2;
+    },
+    isTerminal: true
+  },
+  date: {
+    condition(data) {
+      return data instanceof Date;
+    },
+    serialize(data) {
+      if (Number.isNaN(data.getTime())) {
+        return null;
+      }
+      return data.toISOString();
+    },
+    deserialize(serialized) {
+      assertSerializedType(typeof serialized === "string" || serialized === null, "date", "a string or null");
+      return new Date(serialized ?? Number.NaN);
+    },
+    isTerminal: true
+  },
+  nan: {
+    condition(data) {
+      return typeof data === "number" && Number.isNaN(data);
+    },
+    serialize() {
+      return null;
+    },
+    deserialize(serialized) {
+      assertSerializedType(serialized === null, "nan", "null");
+      return Number.NaN;
+    },
+    isTerminal: true
+  },
+  infinity: {
+    condition(data) {
+      return data === Number.POSITIVE_INFINITY || data === Number.NEGATIVE_INFINITY;
+    },
+    serialize(data) {
+      return data > 0 ? "Infinity" : "-Infinity";
+    },
+    deserialize(serialized) {
+      assertSerializedType(serialized === "Infinity" || serialized === "-Infinity", "infinity", '"Infinity" or "-Infinity"');
+      return serialized === "Infinity" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    },
+    isTerminal: true
+  },
+  url: {
+    condition(data) {
+      return data instanceof URL;
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      assertSerializedType(typeof serialized === "string", "url", "a string");
+      return new URL(serialized);
+    },
+    isTerminal: true
+  },
+  set: {
+    condition(data) {
+      return data instanceof Set;
+    },
+    serialize(data) {
+      return Array.from(data);
+    },
+    deserialize(serialized) {
+      assertSerializedType(Array.isArray(serialized), "set", "an array");
+      return new Set(serialized);
+    }
+  },
+  map: {
+    condition(data) {
+      return data instanceof Map;
+    },
+    serialize(data) {
+      return Array.from(data.entries());
+    },
+    deserialize(serialized) {
+      assertSerializedType(Array.isArray(serialized), "map", "an array");
+      return new Map(serialized);
+    }
+  }
+};
+var RPCJsonSerializer = class {
+  handlers;
+  inlineBuiltInHandlers;
+  handlerEntries;
+  omitUndefinedProperties;
+  constructor(options = {}) {
+    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
+    this.handlers = Object.assign(new NullProtoObj(), DEFAULT_RPC_JSON_SERIALIZER_HANDLERS);
+    const customHandlers = options.handlers;
+    if (customHandlers === void 0) {
+      this.inlineBuiltInHandlers = true;
+      return;
+    }
+    let inlineBuiltInHandlers = true;
+    let handlerEntries = [];
+    for (const key of Object.keys(customHandlers)) {
+      const handler = customHandlers[key];
+      this.handlers[key] = handler;
+      if (inlineBuiltInHandlers && key in DEFAULT_RPC_JSON_SERIALIZER_HANDLERS) {
+        inlineBuiltInHandlers = false;
+      }
+      if (inlineBuiltInHandlers && handler !== void 0) {
+        handlerEntries.push([key, handler]);
+      }
+    }
+    if (!inlineBuiltInHandlers) {
+      handlerEntries = [];
+      for (const key of Object.keys(this.handlers)) {
+        const handler = this.handlers[key];
+        if (handler !== void 0) {
+          handlerEntries.push([key, handler]);
+        }
+      }
+    }
+    this.inlineBuiltInHandlers = inlineBuiltInHandlers;
+    this.handlerEntries = handlerEntries;
+  }
+  serializeJson(data) {
+    let meta = [];
+    const maps = [];
+    const blobs = [];
+    const json = this.serializeValue(data, [], meta, maps, blobs);
+    meta = meta.length === 0 ? void 0 : meta;
+    if (maps.length === 0) {
+      return { json, meta };
+    }
+    return { json, meta, maps, blobs };
+  }
+  /**
+   * `segments` is a shared mutable stack (push/pop while walking),
+   * so it must be copied before being stored in `meta` or `maps`.
+   */
+  serializeValue(data, segments, meta, maps, blobs) {
+    if (this.inlineBuiltInHandlers) {
+      switch (typeof data) {
+        case "string":
+        case "boolean":
+          return data;
+        case "number":
+          if (Number.isFinite(data)) {
+            return data;
+          }
+          if (Number.isNaN(data)) {
+            meta.push(["nan", ...segments]);
+            return null;
+          }
+          meta.push(["infinity", ...segments]);
+          return data > 0 ? "Infinity" : "-Infinity";
+        case "undefined":
+          meta.push(["undefined", ...segments]);
+          return null;
+        case "bigint":
+          meta.push(["bigint", ...segments]);
+          return data.toString();
+        case "object": {
+          if (data === null) {
+            return data;
+          }
+          if (data instanceof Date) {
+            meta.push(["date", ...segments]);
+            return Number.isNaN(data.getTime()) ? null : data.toISOString();
+          }
+          if (data instanceof URL) {
+            meta.push(["url", ...segments]);
+            return data.toString();
+          }
+          if (data instanceof Set) {
+            const result = this.serializeValue(Array.from(data), segments, meta, maps, blobs);
+            meta.push(["set", ...segments]);
+            return result;
+          }
+          if (data instanceof Map) {
+            const result = this.serializeValue(Array.from(data.entries()), segments, meta, maps, blobs);
+            meta.push(["map", ...segments]);
+            return result;
+          }
+        }
+      }
+    }
+    const handlerEntries = this.handlerEntries;
+    if (handlerEntries) {
+      for (let i = 0; i < handlerEntries.length; i++) {
+        const entry = handlerEntries[i];
+        const handler = entry[1];
+        if (handler.condition(data)) {
+          const serialized = handler.serialize(data);
+          if (handler.isTerminal) {
+            meta.push([entry[0], ...segments]);
+            if (serialized instanceof Blob) {
+              maps.push(segments.slice());
+              blobs.push(serialized);
+            }
+            return serialized;
+          }
+          const result = this.serializeValue(serialized, segments, meta, maps, blobs);
+          meta.push([entry[0], ...segments]);
+          return result;
+        }
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments.slice());
+      blobs.push(data);
+      return data;
+    }
+    if (Array.isArray(data)) {
+      const json = [];
+      for (let i = 0; i < data.length; i++) {
+        segments.push(i);
+        json.push(this.serializeValue(data[i], segments, meta, maps, blobs));
+        segments.pop();
+      }
+      return json;
+    }
+    if (isPlainObject(data)) {
+      const json = new NullProtoObj();
+      for (const k of Object.keys(data)) {
+        const v = data[k];
+        if (k === "toJSON" && typeof v === "function") {
+          continue;
+        }
+        if (v === void 0 && this.omitUndefinedProperties) {
+          continue;
+        }
+        segments.push(k);
+        json[k] = this.serializeValue(v, segments, meta, maps, blobs);
+        segments.pop();
+      }
+      return json;
+    }
+    return data;
+  }
+  deserializeJson(serialized) {
+    const ref = { json: serialized.json };
+    if (serialized.blobs?.length) {
+      for (let i = 0; i < serialized.maps.length; i++) {
+        const blob = serialized.blobs[i];
+        if (!(blob instanceof Blob)) {
+          throw invalidSerializedData(`blob ${i} is not a Blob.`);
+        }
+        const segments = serialized.maps[i];
+        let original = serialized;
+        let currentRef = ref;
+        let preSegment = "json";
+        for (let j = 0; j < segments.length; j++) {
+          original = original[preSegment];
+          currentRef = walkInto(currentRef, preSegment, original);
+          preSegment = segments[j];
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+          }
+        }
+        currentRef[preSegment] = blob;
+      }
+    }
+    const meta = serialized.meta;
+    if (meta) {
+      let restored;
+      const chain = meta.length === 1 ? void 0 : [];
+      let chainDepth = 0;
+      for (const item of meta) {
+        const type = item[0];
+        const handler = this.handlers[type];
+        if (handler === void 0) {
+          throw invalidSerializedData(`type "${type}" is not supported.`);
+        }
+        const depth = item.length - 1;
+        const shared = Math.min(depth, chainDepth);
+        let d = 0;
+        let original = serialized;
+        let currentRef = ref;
+        let preSegment = "json";
+        if (chain !== void 0 && shared > 0) {
+          d = 1;
+          while (d < shared && chain[3 * d] === item[d]) {
+            d++;
+          }
+          currentRef = chain[3 * d - 2];
+          original = chain[3 * d - 1];
+          preSegment = item[d];
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+          }
+        }
+        while (d < depth) {
+          original = original[preSegment];
+          currentRef = walkInto(currentRef, preSegment, original, restored);
+          if (chain !== void 0) {
+            chain[3 * d] = preSegment;
+            chain[3 * d + 1] = currentRef;
+            chain[3 * d + 2] = original;
+          }
+          preSegment = item[++d];
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+          }
+        }
+        chainDepth = depth;
+        const value2 = handler.deserialize(currentRef[preSegment]);
+        currentRef[preSegment] = value2;
+        if (isWalkable(value2)) {
+          (restored ??= /* @__PURE__ */ new Set()).add(value2);
+        }
+      }
+    }
+    return ref.json;
+  }
+};
+var RPCSerializer = class extends RPCJsonSerializer {
+  defaultSerializeOptions;
+  constructor(options = {}) {
+    super(options);
+    this.defaultSerializeOptions = options.serialize;
+  }
+  serialize(data, options = {}) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.serializePayload(result.value, false) };
+        },
+        mapError: (e) => new ErrorEvent(
+          this.serializePayload(toORPCError(e).toJSON(), false),
+          { cause: e }
+        )
+      });
+    }
+    const useFormDataForBlobs = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
+    return this.serializePayload(data, useFormDataForBlobs);
+  }
+  serializePayload(data, useFormDataForBlobs) {
+    const { json, meta, maps, blobs } = this.serializeJson(data);
+    if (!useFormDataForBlobs || !blobs?.length) {
+      return { json, meta };
+    }
+    const form = new FormData();
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.deserializePayload(result.value) };
+        },
+        mapError: (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.deserializePayload(e.data);
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
+          }
+          return new ErrorEvent(deserialized, { cause: e });
+        }
+      });
+    }
+    return this.deserializePayload(data);
+  }
+  deserializePayload(data) {
+    if (!(data instanceof FormData)) {
+      return this.deserializeJson(data);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    const blobs = [];
+    for (const [key, value2] of data) {
+      if (value2 instanceof Blob) {
+        blobs[Number(key)] = value2;
+      }
+    }
+    return this.deserializeJson({ ...serialized, blobs });
+  }
+};
+
+// ../../../node_modules/.pnpm/@orpc+client@2.0.0-beta.47/node_modules/@orpc/client/dist/index.mjs
+var RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
+  /**
+   * Prevents the client from being treated as a thenable when users
+   * accidentally write `await client`.
+   */
+  "then",
+  /**
+   * Commonly used by libraries to bind functions to a specific `this`
+   * context.
+   */
+  "bind",
+  /**
+   * Commonly used by libraries to invoke functions with a specific `this`
+   * context.
+   */
+  "call",
+  /**
+   * Commonly used by libraries to invoke functions with a specific `this`
+   * context and an arguments array.
+   */
+  "apply",
+  /**
+   * Commonly accessed during primitive conversion, inspection, and logging.
+   */
+  "valueOf",
+  /**
+   * Commonly accessed during string conversion, inspection, and logging.
+   */
+  "toString",
+  /**
+   * Commonly accessed by serializers such as `JSON.stringify`.
+   */
+  "toJSON"
+]);
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+function resolveClientRest(rest) {
+  return [
+    rest[0],
+    // rest[0] can be undefined if TInput is optional,
+    resolveFriendlyClientOptions(rest[1] ?? {})
+    // rest[1] can be undefined if all fields of FriendlyClientOptions are optional
+  ];
+}
+function createORPCClient(link, { path = [], ...options } = {}) {
+  const procedureClient = (...rest) => {
+    const [input, callOptions] = resolveClientRest(rest);
+    const interceptors = [
+      ...toArray(options.interceptors),
+      ...toArray(options.scoped?.interceptors)
+    ];
+    return intercept(
+      interceptors,
+      { ...callOptions, input, path },
+      ({ path: path2, input: input2, ...callOptions2 }) => link.call(path2, input2, callOptions2)
+    );
+  };
+  const cache = /* @__PURE__ */ new Map();
+  const recursive = new Proxy(procedureClient, {
+    get(target, key) {
+      if (typeof key !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
+        return Reflect.get(target, key);
+      }
+      let client = cache.get(key);
+      if (client === void 0) {
+        client = createORPCClient(link, {
+          ...options,
+          path: [...path, key],
+          scoped: options.scoped?.[key]
+        });
+        cache.set(key, client);
+      }
+      return client;
+    }
+  });
+  return recursive;
+}
+
+// ../../../node_modules/.pnpm/@standard-server+fetch@0.13.0/node_modules/@standard-server/fetch/dist/index.mjs
+function toAsyncIteratorObject(stream) {
+  const eventStream = stream?.pipeThrough(new TextDecoderStream()).pipeThrough(new EventStreamDecoderStream());
+  const reader = eventStream?.getReader();
+  return new AsyncIteratorClass(
+    async () => {
+      while (true) {
+        const result = await reader?.read();
+        if (result === void 0 || result.done) {
+          throw new EventStreamDecoderError("Event Stream ended before complete");
+        }
+        const { value: value2 } = result;
+        switch (value2.event) {
+          case "message": {
+            let message = parseEmptyableJSON(value2.data);
+            if (isTypescriptObject(message)) {
+              message = withEventMeta(message, value2);
+            }
+            return { done: false, value: message };
+          }
+          case "error": {
+            let error = new ErrorEvent(parseEmptyableJSON(value2.data));
+            error = withEventMeta(error, value2);
+            throw error;
+          }
+          case "close": {
+            let close = parseEmptyableJSON(value2.data);
+            if (isTypescriptObject(close)) {
+              close = withEventMeta(close, value2);
+            }
+            return { done: true, value: close };
+          }
+        }
+      }
+    },
+    async () => {
+      await reader?.cancel();
+    }
+  );
+}
+function toEventStream(iterator, options = {}) {
+  const keepAliveEnabled = options.keepAlive?.enabled ?? true;
+  const keepAliveInterval = options.keepAlive?.interval ?? 15e3;
+  const keepAliveComment = options.keepAlive?.comment ?? "";
+  const initialCommentEnabled = options.initialComment?.enabled ?? true;
+  const initialComment = options.initialComment?.comment ?? "";
+  let cancelled = false;
+  let timeout;
+  const stream = new ReadableStream({
+    start(controller) {
+      if (initialCommentEnabled) {
+        controller.enqueue(
+          encodeEventStreamMessage({
+            comments: [initialComment]
+          })
+        );
+      }
+    },
+    async pull(controller) {
+      let result;
+      try {
+        if (keepAliveEnabled) {
+          timeout = setInterval(() => {
+            controller.enqueue(
+              encodeEventStreamMessage({
+                comments: [keepAliveComment]
+              })
+            );
+          }, keepAliveInterval);
+        }
+        result = await iterator.next();
+      } catch (err) {
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        if (err instanceof ErrorEvent) {
+          controller.enqueue(
+            encodeEventStreamMessage({
+              ...getEventMeta(err),
+              event: "error",
+              data: stringifyJSON(err.data)
+            })
+          );
+          controller.close();
+        } else {
+          controller.error(err);
+        }
+        return;
+      }
+      clearInterval(timeout);
+      if (cancelled) {
+        return;
+      }
+      try {
+        const [data, meta] = unwrapEvent(result.value);
+        controller.enqueue(
+          encodeEventStreamMessage({
+            ...meta,
+            event: result.done ? "close" : "message",
+            data: stringifyJSON(data)
+          })
+        );
+      } catch (err) {
+        try {
+          if (!result.done) {
+            await iterator.return?.();
+          }
+        } finally {
+          controller.error(err);
+        }
+        return;
+      }
+      if (result.done) {
+        controller.close();
+      }
+    },
+    async cancel() {
+      cancelled = true;
+      clearInterval(timeout);
+      await iterator.return?.();
+    }
+  }).pipeThrough(new TextEncoderStream());
+  return stream;
+}
+async function toStandardBody(re, options) {
+  const hint = options?.hint ?? resolveStandardBodyHint({
+    "standard-server": re.headers.get("standard-server") ?? void 0,
+    "content-type": re.headers.get("content-type") ?? void 0,
+    "content-length": re.headers.get("content-length") ?? void 0,
+    "content-disposition": re.headers.get("content-disposition") ?? void 0
+  });
+  if (hint === "none") {
+    return void 0;
+  }
+  if (re.bodyUsed) {
+    throw new TypeError("Failed to read body: body stream already read");
+  }
+  if (hint === "json") {
+    const text = await re.text();
+    return parseEmptyableJSON(text);
+  }
+  if (hint === "form-data") {
+    return await re.formData();
+  }
+  if (hint === "url-search-params") {
+    const text = await re.text();
+    return new URLSearchParams(text);
+  }
+  if (hint === "event-stream") {
+    return toAsyncIteratorObject(re.body);
+  }
+  if (hint === "file") {
+    const contentDisposition = re.headers.get("content-disposition");
+    const fileName = contentDisposition !== null ? getFilenameFromContentDisposition(contentDisposition) : void 0;
+    const blob = await re.blob();
+    return new File([blob], fileName ?? "blob", {
+      type: blob.type
+    });
+  }
+  return re.body ?? new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function toFetchBody(body, headers, options = {}) {
+  headers = { ...headers };
+  if (body instanceof ReadableStream) {
+    headers["standard-server"] ??= "octet-stream";
+    headers["content-type"] ??= "application/octet-stream";
+    return [body, headers];
+  }
+  if (body instanceof Blob) {
+    headers["standard-server"] ??= "file";
+    headers["content-type"] ??= body.type;
+    headers["content-disposition"] ??= generateContentDisposition(
+      body instanceof File ? body.name ?? "" : "blob"
+    );
+    if (Number.isFinite(body.size)) {
+      headers["content-length"] = body.size.toString();
+      return [body, headers];
+    }
+    return [body.stream(), headers];
+  }
+  headers["standard-server"] = void 0;
+  headers["content-length"] = void 0;
+  if (body === void 0) {
+    headers["standard-server"] = getRequiredStandardBodyHint("none", headers);
+    return [void 0, headers];
+  }
+  if (body instanceof FormData) {
+    headers["content-type"] = void 0;
+    return [body, headers];
+  }
+  if (body instanceof URLSearchParams) {
+    headers["content-type"] ??= "application/x-www-form-urlencoded";
+    headers["standard-server"] = getRequiredStandardBodyHint("url-search-params", headers);
+    return [body, headers];
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers["content-type"] ??= "text/event-stream";
+    headers["standard-server"] = getRequiredStandardBodyHint("event-stream", headers);
+    return [toEventStream(body, options.eventStream), headers];
+  }
+  headers["content-type"] ??= "application/json";
+  headers["standard-server"] = getRequiredStandardBodyHint("json", headers);
+  return [stringifyJSON(body), headers];
+}
+function toStandardHeaders(headers) {
+  const standardHeaders = /* @__PURE__ */ Object.create(null);
+  headers.forEach((value2, key) => {
+    if (Array.isArray(standardHeaders[key])) {
+      standardHeaders[key].push(value2);
+    } else if (standardHeaders[key] !== void 0) {
+      standardHeaders[key] = [standardHeaders[key], value2];
+    } else {
+      standardHeaders[key] = value2;
+    }
+  });
+  return standardHeaders;
+}
+function toFetchHeaders(standardHeaders) {
+  const headers = new Headers();
+  for (const key of Object.keys(standardHeaders)) {
+    if (key.startsWith(":")) {
+      continue;
+    }
+    const value2 = standardHeaders[key];
+    if (Array.isArray(value2)) {
+      for (const v of value2) {
+        headers.append(key, v);
+      }
+    } else if (value2 !== void 0) {
+      headers.append(key, value2);
+    }
+  }
+  return headers;
+}
+function toStandardLazyResponse(response) {
+  return {
+    resolveBody: (hint) => toStandardBody(response, { hint }),
+    status: response.status,
+    get headers() {
+      const headers = toStandardHeaders(response.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value2) {
+      Object.defineProperty(this, "headers", { value: value2, writable: true });
+    }
+  };
+}
+
+// ../../../node_modules/.pnpm/@orpc+client@2.0.0-beta.47/node_modules/@orpc/client/dist/shared/client.CKQeJJ2U.mjs
+var CompositeStandardLinkPlugin = class {
+  name = "~composite";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        options = plugin.init(options);
+      }
+    }
+    return options;
+  }
+};
+var StandardLink = class {
+  constructor(codec, transport, options = {}) {
+    this.codec = codec;
+    this.transport = transport;
+    options = new CompositeStandardLinkPlugin(options.plugins).init(options);
+    this.interceptors = options.interceptors;
+    this.transportInterceptors = options.transportInterceptors;
+  }
+  interceptors;
+  transportInterceptors;
+  /**
+   * @throws ORPCError, MalformedResponseError, transport-level errors (network failures, timeouts, etc.)
+   */
+  call(path, input, options) {
+    return runWithSpan(`${ORPC_NAME}.${path.join("/")}`, (span) => {
+      span?.setAttribute("rpc.system", ORPC_NAME);
+      span?.setAttribute("rpc.method", path.join("."));
+      if (getTracer() && isAsyncIteratorObject(input)) {
+        input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+      } else if (getTracer() && input instanceof ReadableStream) {
+        input = override(input, traceReadableStream("consume_octet_stream_input", input));
+      }
+      return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+        const tracer = getTracer();
+        const activeSpan = tracer?.getActiveSpan() ?? span;
+        let request = await runWithSpan(
+          { name: "encode_input", parent: activeSpan },
+          () => this.codec.encodeInput(input2, path2, options2)
+        );
+        if (activeSpan && tracer?.inject) {
+          const headers = { ...request.headers };
+          tracer.inject(activeSpan, headers);
+          request = { ...request, headers };
+        }
+        const response = await intercept(
+          this.transportInterceptors,
+          { ...options2, path: path2, request },
+          ({ path: path3, request: request2, ...options3 }) => {
+            const activeTransportSpan = tracer?.getActiveSpan() ?? activeSpan;
+            return runWithSpan(
+              { name: "send_request", parent: activeTransportSpan },
+              () => this.transport.send(request2, path3, options3)
+            );
+          }
+        );
+        const decodedResult = await runWithSpan(
+          { name: "decode_response", parent: activeSpan },
+          () => this.codec.decodeResponse(response, path2, options2)
+        );
+        if (decodedResult.kind === "error") {
+          throw decodedResult.error;
+        }
+        const output = decodedResult.output;
+        if (getTracer() && isAsyncIteratorObject(output)) {
+          return override(output, traceAsyncIterator("consume_async_iterator_object_output", output));
+        } else if (getTracer() && output instanceof ReadableStream) {
+          return override(output, traceReadableStream("consume_octet_stream_output", output));
+        }
+        return output;
+      });
+    });
+  }
+};
+var END_SLASH_REGEX = /\/$/;
+var RPCLinkCodec = class {
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  serializer;
+  constructor(options) {
+    this.baseUrl = options.url ?? "/";
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+    this.serializer = options.serializer ?? new RPCSerializer();
+  }
+  async encodeInput(input, path, options) {
+    let headers = toResolvedStandardHeaders(await value(this.headers, options, path, input));
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const [pathname, search, hash] = parseStandardUrl(baseUrl);
+    const newPathname = `${pathname.replace(END_SLASH_REGEX, "")}${pathToHttpPath(path)}`;
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof Blob) && !(serialized instanceof ReadableStream) && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const mergedSearch = new URLSearchParams(search);
+      mergedSearch.append("data", stringifyJSON(serialized) ?? "");
+      const url2 = `${newPathname}?${mergedSearch}${hash ?? ""}`;
+      if (url2.length <= maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: url2,
+          signal: options.signal
+        };
+      }
+    }
+    const url = `${newPathname}${search ?? ""}${hash ?? ""}`;
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decodeResponse(response) {
+    const isOk = response.status < 400;
+    const body = await response.resolveBody();
+    const deserialized = await (async () => {
+      try {
+        return this.serializer.deserialize(body);
+      } catch (cause) {
+        throw new MalformedResponseError({
+          message: "Invalid RPC response format.",
+          response: { status: response.status, headers: response.headers, body },
+          cause
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        return {
+          kind: "error",
+          error: createORPCErrorFromJson(deserialized, {
+            cause: new ResponseError({ response: { status: response.status, headers: response.headers, body } })
+          })
+        };
+      }
+      throw new MalformedResponseError({ response: { headers: response.headers, status: response.status, body } });
+    }
+    return { kind: "output", output: deserialized };
+  }
+};
+function toResolvedStandardHeaders(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders(headers);
+  }
+  return headers;
+}
+
+// ../../../node_modules/.pnpm/@orpc+client@2.0.0-beta.47/node_modules/@orpc/client/dist/adapters/fetch/index.mjs
+var GET_SUPPORTED_DUPLEX_MODE = once(() => {
+  try {
+    let duplex;
+    void new Request(
+      "https://example.com",
+      {
+        method: "POST",
+        body: new ReadableStream(),
+        get duplex() {
+          duplex = "half";
+          return "half";
+        }
+      }
+    );
+    return duplex;
+  } catch {
+    return void 0;
+  }
+});
+var FetchLinkTransport = class {
+  origin;
+  fetch;
+  toFetchRequestOptions;
+  constructor(options) {
+    this.origin = options.origin;
+    this.fetch = options.fetch ?? ((url, init) => globalThis.fetch(url, init));
+    this.toFetchRequestOptions = options.toFetchRequest;
+  }
+  async send(standardRequest, path, options) {
+    let origin = await value(this.origin, options, path);
+    if (origin?.endsWith("/")) {
+      origin = origin.slice(0, -1);
+    }
+    const url = `${origin ?? ""}${standardRequest.url}`;
+    const [body, standardHeaders] = toFetchBody(standardRequest.body, standardRequest.headers, this.toFetchRequestOptions);
+    const init = {
+      body,
+      headers: toFetchHeaders(standardHeaders),
+      method: standardRequest.method,
+      signal: options.signal,
+      redirect: "manual"
+    };
+    if (body instanceof ReadableStream) {
+      const duplex = GET_SUPPORTED_DUPLEX_MODE();
+      if (duplex !== void 0) {
+        init.duplex = duplex;
+      }
+    }
+    const fetch = this.fetch;
+    const response = await fetch(url, init, options, path);
+    if (response.type === "opaqueredirect") {
+      throw new TypeError("Unexpected redirect response: redirects are not followed.");
+    }
+    if (response.type === "opaque") {
+      throw new TypeError("Unexpected opaque response: the response is unreadable, likely due to a no-cors request.");
+    }
+    const standardResponse = toStandardLazyResponse(response);
+    return standardResponse;
+  }
+};
+var RPCLink = class extends StandardLink {
+  constructor(options) {
+    const codec = new RPCLinkCodec(options);
+    const transport = new FetchLinkTransport(options);
+    super(codec, transport, options);
+  }
+};
+export {
+  ORPCError,
+  RPCLink,
+  createORPCClient
+};