apps 0.0.1-beta.0

package/js/chunk-W7Q5EOTS.js

@@ -0,0 +1,4375 @@
+import {
+  BaseProto,
+  Class,
+  Clock,
+  CurrentMemoMap,
+  CurrentRedactedNames,
+  Defect,
+  DisablePropagation,
+  Done,
+  Error as Error2,
+  Error2 as Error3,
+  FileSystem,
+  Int,
+  JsonFromUrlParamsField,
+  Literals,
+  NodeInspectSymbol,
+  Path,
+  PipeInspectableProto,
+  RecordFromUrlParams,
+  Reference,
+  Scope,
+  Service,
+  String as String2,
+  Struct,
+  TaggedError,
+  TaggedError2,
+  Union,
+  addFinalizer2 as addFinalizer,
+  andThen,
+  append,
+  appendAll2 as appendAll,
+  as,
+  assignProperty,
+  badArgument,
+  buildWithMemoMap,
+  cached,
+  catchCause,
+  catchCauseFilter,
+  catchIf,
+  catchTag,
+  catchTags,
+  catch_,
+  close,
+  constFalse,
+  constTrue,
+  constVoid,
+  constant,
+  context,
+  contextWith,
+  decodeEffect,
+  decodeTo,
+  decodeUnknownEffect2 as decodeUnknownEffect,
+  delay,
+  done,
+  dual,
+  effect,
+  effectContext,
+  effectDiscard,
+  empty,
+  empty2,
+  empty4 as empty3,
+  empty5 as empty4,
+  empty6 as empty5,
+  empty7 as empty6,
+  encodeText,
+  encodeUnknownEffect,
+  ensuring,
+  ensuring2,
+  equals2 as equals,
+  expireCookie,
+  expireCookieUnsafe,
+  externalSpan,
+  fail,
+  fail3 as fail2,
+  fail4 as fail3,
+  fail5 as fail4,
+  failCause,
+  failCause2,
+  filterNoDone,
+  filterOrElse,
+  filterOrFail,
+  flatMap2 as flatMap,
+  flatMap3 as flatMap2,
+  flow,
+  fnUntraced,
+  forEach,
+  forever2 as forever,
+  fork,
+  forkIn,
+  format,
+  fromChannel,
+  fromInput,
+  fromInput2,
+  fromInput3,
+  fromInputUnsafe,
+  fromInputUnsafe2,
+  fromIterable,
+  fromIterable2,
+  fromJsonString,
+  fromNullishOr,
+  fromPull,
+  fromReadableStream,
+  fromRecordUnsafe,
+  fromResult,
+  fromSetCookie,
+  fromTransform,
+  gen,
+  get,
+  get3 as get2,
+  get4 as get3,
+  getCurrent,
+  getOrElse,
+  getOrUndefined,
+  getOrUndefinedUnsafe,
+  getUnsafe,
+  hasInterrupts,
+  hasProperty,
+  identity,
+  ignore2 as ignore,
+  isDoneCause,
+  isEffect,
+  isEmpty,
+  isExit,
+  isFailure,
+  isNone,
+  isOption,
+  isReadonlyArrayNonEmpty,
+  isRedactedName,
+  isSchedule,
+  isSome,
+  isStream,
+  isSuccess,
+  isTimeoutError,
+  isZero,
+  makeUnsafe,
+  map3 as map,
+  map4 as map2,
+  mapEffect,
+  mapError,
+  mapError2,
+  mapError3,
+  match,
+  matchCauseEffect,
+  matchEffect,
+  max,
+  mebibytes,
+  merge,
+  merge2,
+  merge3,
+  millis,
+  mkUint8Array,
+  mkUint8Array2,
+  none,
+  onInterrupt,
+  optional,
+  or,
+  parseHeader,
+  passthrough,
+  pipeArguments,
+  pipeThroughChannel,
+  provide,
+  provide2,
+  provideContext2 as provideContext,
+  provideMerge,
+  redact,
+  remove2 as remove,
+  remove3 as remove2,
+  repeat,
+  retry,
+  run,
+  runForEach,
+  runSync,
+  seconds,
+  set2 as set,
+  set3 as set2,
+  set4 as set3,
+  setAll,
+  setAll2,
+  setAll3,
+  setAllUnsafe,
+  setUnsafe,
+  sleep,
+  some,
+  stringOrRedacted,
+  succeed,
+  succeed4 as succeed2,
+  succeed5 as succeed3,
+  succeedContext,
+  suspend,
+  suspend2,
+  sync2 as sync,
+  tag,
+  tap,
+  tapError,
+  toCodecJson,
+  toCookieHeader,
+  toReadableStreamWith,
+  toSetCookieHeaders,
+  toString,
+  tryPromise,
+  try_,
+  try_2,
+  uninterruptibleMask,
+  unwrap2 as unwrap,
+  unwrap3 as unwrap2,
+  update,
+  updateContext,
+  useSpan,
+  void_,
+  void_2,
+  withFiber,
+  withParentSpan,
+  zero2 as zero
+} from "./chunk-2OTCEKL2.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpClientRequest.js
+var HttpClientRequest_exports = {};
+__export(HttpClientRequest_exports, {
+  accept: () => accept,
+  acceptJson: () => acceptJson,
+  appendUrl: () => appendUrl,
+  appendUrlParam: () => appendUrlParam,
+  appendUrlParams: () => appendUrlParams,
+  basicAuth: () => basicAuth,
+  bearerToken: () => bearerToken,
+  bodyFile: () => bodyFile,
+  bodyFormData: () => bodyFormData,
+  bodyFormDataRecord: () => bodyFormDataRecord,
+  bodyJson: () => bodyJson,
+  bodyJsonUnsafe: () => bodyJsonUnsafe,
+  bodyStream: () => bodyStream,
+  bodyText: () => bodyText,
+  bodyUint8Array: () => bodyUint8Array,
+  bodyUrlParams: () => bodyUrlParams,
+  delete: () => del,
+  empty: () => empty8,
+  fromWeb: () => fromWeb,
+  get: () => get4,
+  head: () => head,
+  isHttpClientRequest: () => isHttpClientRequest,
+  make: () => make2,
+  makeWith: () => makeWith,
+  modify: () => modify,
+  options: () => options,
+  patch: () => patch,
+  post: () => post,
+  prependUrl: () => prependUrl,
+  put: () => put,
+  query: () => query,
+  removeHash: () => removeHash,
+  removeHeader: () => removeHeader,
+  schemaBodyJson: () => schemaBodyJson,
+  setBody: () => setBody,
+  setHash: () => setHash,
+  setHeader: () => setHeader,
+  setHeaders: () => setHeaders,
+  setMethod: () => setMethod,
+  setUrl: () => setUrl,
+  setUrlParam: () => setUrlParam,
+  setUrlParams: () => setUrlParams,
+  toUrl: () => toUrl,
+  toWeb: () => toWeb,
+  toWebResult: () => toWebResult,
+  trace: () => trace,
+  updateHeaders: () => updateHeaders2,
+  updateUrl: () => updateUrl
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpBody.js
+var HttpBody_exports = {};
+__export(HttpBody_exports, {
+  Empty: () => Empty,
+  FormData: () => FormData2,
+  HttpBodyError: () => HttpBodyError,
+  Raw: () => Raw,
+  Stream: () => Stream,
+  Uint8Array: () => Uint8Array2,
+  empty: () => empty7,
+  file: () => file,
+  fileFromInfo: () => fileFromInfo,
+  formData: () => formData,
+  formDataRecord: () => formDataRecord,
+  isHttpBody: () => isHttpBody,
+  json: () => json,
+  jsonSchema: () => jsonSchema,
+  jsonUnsafe: () => jsonUnsafe,
+  raw: () => raw,
+  stream: () => stream,
+  text: () => text,
+  uint8Array: () => uint8Array,
+  urlParams: () => urlParams
+});
+var TypeId = "~effect/http/HttpBody";
+var isHttpBody = (u) => hasProperty(u, TypeId);
+var HttpBodyErrorTypeId = "~effect/http/HttpBody/HttpBodyError";
+var HttpBodyError = class extends (/* @__PURE__ */ TaggedError("HttpBodyError")) {
+  /**
+   * Marks this value as an HTTP body error for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [HttpBodyErrorTypeId] = HttpBodyErrorTypeId;
+};
+var Proto = class {
+  [TypeId];
+  constructor() {
+    this[TypeId] = TypeId;
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  toString() {
+    return format(this, {
+      ignoreToString: true
+    });
+  }
+};
+var Empty = class extends Proto {
+  _tag = "Empty";
+  toJSON() {
+    return {
+      _id: "effect/HttpBody",
+      _tag: "Empty"
+    };
+  }
+};
+var empty7 = /* @__PURE__ */ new Empty();
+var Raw = class extends Proto {
+  _tag = "Raw";
+  body;
+  contentType;
+  contentLength;
+  constructor(body, contentType, contentLength) {
+    super();
+    this.body = body;
+    this.contentType = contentType;
+    this.contentLength = contentLength;
+  }
+  toJSON() {
+    return {
+      _id: "effect/HttpBody",
+      _tag: "Raw",
+      body: this.body,
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    };
+  }
+};
+var raw = (body, options3) => new Raw(body, options3?.contentType, options3?.contentLength);
+var Uint8Array2 = class extends Proto {
+  _tag = "Uint8Array";
+  contentType;
+  contentLength;
+  /** Original text retained for adapters that can skip encoding. */
+  text;
+  _body;
+  constructor(body, contentType, contentLength, text3) {
+    super();
+    this._body = body;
+    this.text = text3;
+    this.contentType = contentType;
+    this.contentLength = contentLength;
+  }
+  get body() {
+    return this._body ??= encodeText2(this.text);
+  }
+  toJSON() {
+    const toString2 = this.contentType.startsWith("text/") || this.contentType.endsWith("json");
+    return {
+      _id: "effect/HttpBody",
+      _tag: "Uint8Array",
+      body: toString2 ? new TextDecoder().decode(this.body) : `Uint8Array(${this.body.length})`,
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    };
+  }
+};
+var uint8Array = (body, contentType) => new Uint8Array2(body, contentType ?? "application/octet-stream", body.length);
+var encoder = /* @__PURE__ */ new TextEncoder();
+var buffer = globalThis.Buffer;
+var encodeText2 = buffer !== void 0 ? (body) => buffer.from(body, "utf8") : (body) => encoder.encode(body);
+var text = (body, contentType) => {
+  if (typeof body !== "string") {
+    body = body === void 0 ? "" : String(body);
+  }
+  if (buffer !== void 0) {
+    return new Uint8Array2(void 0, contentType ?? "text/plain", buffer.byteLength(body, "utf8"), body);
+  }
+  const bytes = encoder.encode(body);
+  return new Uint8Array2(bytes, contentType ?? "text/plain", bytes.length, body);
+};
+var jsonUnsafe = (body, contentType) => text(JSON.stringify(body), contentType ?? "application/json");
+var json = (body, contentType) => try_2({
+  try: () => text(JSON.stringify(body), contentType ?? "application/json"),
+  catch: (cause) => new HttpBodyError({
+    reason: {
+      _tag: "JsonError"
+    },
+    cause
+  })
+});
+var jsonSchema = (schema, options3) => {
+  const encode = encodeUnknownEffect(toCodecJson(schema));
+  return (body, contentType) => encode(body, options3).pipe(mapError((issue) => new HttpBodyError({
+    reason: {
+      _tag: "SchemaError",
+      issue
+    },
+    cause: issue
+  })), flatMap((body2) => json(body2, contentType)));
+};
+var urlParams = (urlParams3, contentType) => text(toString(fromInput3(urlParams3)), contentType ?? "application/x-www-form-urlencoded");
+var FormData2 = class extends Proto {
+  _tag = "FormData";
+  contentType = void 0;
+  contentLength = void 0;
+  formData;
+  constructor(formData3) {
+    super();
+    this.formData = formData3;
+  }
+  toJSON() {
+    return {
+      _id: "effect/HttpBody",
+      _tag: "FormData",
+      formData: this.formData
+    };
+  }
+};
+var formData = (body) => new FormData2(body);
+var appendFormDataValue = (formData3, key, value) => {
+  if (value == null) {
+    return;
+  }
+  if (typeof value === "object") {
+    formData3.append(key, value);
+    return;
+  }
+  formData3.append(key, String(value));
+};
+var formDataRecord = (entries) => {
+  const data = new globalThis.FormData();
+  for (const [key, value] of Object.entries(entries)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        appendFormDataValue(data, key, item);
+      }
+    } else {
+      appendFormDataValue(data, key, value);
+    }
+  }
+  return formData(data);
+};
+var Stream = class extends Proto {
+  _tag = "Stream";
+  stream;
+  contentType;
+  contentLength;
+  constructor(stream4, contentType, contentLength) {
+    super();
+    this.stream = stream4;
+    this.contentType = contentType;
+    this.contentLength = contentLength;
+  }
+  toJSON() {
+    return {
+      _id: "effect/HttpBody",
+      _tag: "Stream",
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    };
+  }
+};
+var stream = (body, contentType, contentLength) => new Stream(body, contentType ?? "application/octet-stream", contentLength);
+var fileRangeSize = (input, field, method) => {
+  const size = fromInput(input);
+  return isSome(size) ? succeed2(size.value) : fail3(badArgument({
+    module: "HttpBody",
+    method,
+    description: `Invalid ${field}: ${input}`
+  }));
+};
+var fileContentLength = /* @__PURE__ */ fnUntraced(function* (size, method, options3) {
+  const offset = options3?.offset === void 0 ? zero : yield* fileRangeSize(options3.offset, "offset", method);
+  const bytesToRead = options3?.bytesToRead === void 0 ? void 0 : yield* fileRangeSize(options3.bytesToRead, "bytesToRead", method);
+  const available = offset >= size ? BigInt("0") : size - offset;
+  const length = bytesToRead === void 0 || bytesToRead > available ? available : bytesToRead;
+  if (length > BigInt(Number.MAX_SAFE_INTEGER)) {
+    return yield* fail3(badArgument({
+      module: "HttpBody",
+      method,
+      description: `Content length exceeds Number.MAX_SAFE_INTEGER: ${length}`
+    }));
+  }
+  return Number(length);
+});
+var file = (path, options3) => flatMap(FileSystem, (fs) => flatMap(fs.stat(path), (info) => map(fileContentLength(info.size, "file", options3), (contentLength) => stream(fs.stream(path, options3), options3?.contentType, contentLength))));
+var fileFromInfo = (path, info, options3) => flatMap(FileSystem, (fs) => map(fileContentLength(info.size, "fileFromInfo", options3), (contentLength) => stream(fs.stream(path, options3), options3?.contentType, contentLength)));
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpMethod.js
+var hasBody = (method) => method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE";
+var allShort = [["GET", "get"], ["POST", "post"], ["PUT", "put"], ["DELETE", "del"], ["PATCH", "patch"], ["HEAD", "head"], ["OPTIONS", "options"], ["TRACE", "trace"], ["QUERY", "query"]];
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/internal/httpBody.js
+var updateHeaders = (headers, body) => {
+  if (body._tag === "Empty" || body._tag === "FormData") {
+    return remove2(remove2(headers, "content-type"), "content-length");
+  }
+  headers = body.contentType === void 0 ? remove2(headers, "content-type") : set2(headers, "content-type", body.contentType);
+  return body.contentLength === void 0 ? remove2(headers, "content-length") : set2(headers, "content-length", body.contentLength.toString());
+};
+var parseContentLength = (contentLength) => {
+  if (contentLength === null || contentLength === void 0 || !/^\d+$/.test(contentLength)) {
+    return void 0;
+  }
+  const parsed = Number(contentLength);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/Url.js
+var UrlError = class extends (/* @__PURE__ */ TaggedError("UrlError")) {
+};
+var make = (url, params, hash) => try_({
+  try: () => {
+    const urlInstance = new URL(url, baseUrl());
+    for (let i = 0; i < params.params.length; i++) {
+      const [key, value] = params.params[i];
+      if (value !== void 0) {
+        urlInstance.searchParams.append(key, value);
+      }
+    }
+    if (hash !== void 0) {
+      urlInstance.hash = hash;
+    }
+    return urlInstance;
+  },
+  catch: (cause) => new UrlError({
+    cause
+  })
+});
+var baseUrl = () => {
+  if ("location" in globalThis && globalThis.location !== void 0 && globalThis.location.origin !== void 0 && globalThis.location.pathname !== void 0) {
+    return location.origin + location.pathname;
+  }
+  return void 0;
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpClientRequest.js
+var TypeId2 = "~effect/http/HttpClientRequest";
+var isHttpClientRequest = (u) => hasProperty(u, TypeId2);
+var Proto2 = {
+  [TypeId2]: TypeId2,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "HttpClientRequest",
+      method: this.method,
+      url: this.url,
+      urlParams: this.urlParams,
+      hash: this.hash,
+      headers: redact(this.headers),
+      body: this.body.toJSON()
+    };
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeWith(method, url, urlParams3, hash, headers, body) {
+  const self = Object.create(Proto2);
+  self.method = method;
+  self.url = url;
+  self.urlParams = urlParams3;
+  self.hash = hash;
+  self.headers = headers;
+  self.body = body;
+  return self;
+}
+var empty8 = /* @__PURE__ */ makeWith("GET", "", empty5, /* @__PURE__ */ none(), empty4, empty7);
+var make2 = (method) => (url, options3) => modify(empty8, {
+  method,
+  url,
+  ...options3 ?? void 0
+});
+var get4 = /* @__PURE__ */ make2("GET");
+var query = /* @__PURE__ */ make2("QUERY");
+var post = /* @__PURE__ */ make2("POST");
+var patch = /* @__PURE__ */ make2("PATCH");
+var put = /* @__PURE__ */ make2("PUT");
+var del = /* @__PURE__ */ make2("DELETE");
+var head = /* @__PURE__ */ make2("HEAD");
+var options = /* @__PURE__ */ make2("OPTIONS");
+var trace = /* @__PURE__ */ make2("TRACE");
+var modify = /* @__PURE__ */ dual(2, (self, options3) => {
+  let result = self;
+  if (options3.method) {
+    result = setMethod(result, options3.method);
+  }
+  if (options3.url) {
+    result = setUrl(result, options3.url);
+  }
+  if (options3.headers) {
+    result = setHeaders(result, options3.headers);
+  }
+  if (options3.urlParams) {
+    result = setUrlParams(result, options3.urlParams);
+  }
+  if (options3.hash) {
+    result = setHash(result, options3.hash);
+  }
+  if (options3.body) {
+    result = setBody(result, options3.body);
+  }
+  if (options3.accept) {
+    result = accept(result, options3.accept);
+  }
+  if (options3.acceptJson) {
+    result = acceptJson(result);
+  }
+  return result;
+});
+var setMethod = /* @__PURE__ */ dual(2, (self, method) => makeWith(method, self.url, self.urlParams, self.hash, self.headers, self.body));
+var setHeader = /* @__PURE__ */ dual(3, (self, key, value) => makeWith(self.method, self.url, self.urlParams, self.hash, set2(self.headers, key, value), self.body));
+var setHeaders = /* @__PURE__ */ dual(2, (self, input) => makeWith(self.method, self.url, self.urlParams, self.hash, setAll2(self.headers, input), self.body));
+var updateHeaders2 = /* @__PURE__ */ dual(2, (self, f) => makeWith(self.method, self.url, self.urlParams, self.hash, f(self.headers), self.body));
+var removeHeader = /* @__PURE__ */ dual(2, (self, key) => updateHeaders2(self, remove2(key)));
+var basicAuth = /* @__PURE__ */ dual(3, (self, username, password) => setHeader(self, "Authorization", `Basic ${btoa(`${stringOrRedacted(username)}:${stringOrRedacted(password)}`)}`));
+var bearerToken = /* @__PURE__ */ dual(2, (self, token) => setHeader(self, "Authorization", `Bearer ${stringOrRedacted(token)}`));
+var accept = /* @__PURE__ */ dual(2, (self, mediaType) => setHeader(self, "Accept", mediaType));
+var acceptJson = /* @__PURE__ */ accept("application/json");
+var setUrl = /* @__PURE__ */ dual(2, (self, url) => {
+  if (typeof url === "string") {
+    return makeWith(self.method, url, self.urlParams, self.hash, self.headers, self.body);
+  }
+  const clone = new URL(url.toString());
+  const urlParams3 = fromInput3(clone.searchParams);
+  const hash = fromNullishOr(clone.hash === "" ? void 0 : clone.hash.slice(1));
+  clone.search = "";
+  clone.hash = "";
+  return makeWith(self.method, clone.toString(), urlParams3, hash, self.headers, self.body);
+});
+var prependUrl = /* @__PURE__ */ dual(2, (self, path) => {
+  if (path === "") return self;
+  return makeWith(self.method, joinSegments(path, self.url), self.urlParams, self.hash, self.headers, self.body);
+});
+var appendUrl = /* @__PURE__ */ dual(2, (self, path) => {
+  if (path === "") return self;
+  return makeWith(self.method, joinSegments(self.url, path), self.urlParams, self.hash, self.headers, self.body);
+});
+var joinSegments = (first, second) => {
+  const endsWithSlash = first.endsWith("/");
+  const startsWithSlash = second.startsWith("/");
+  const needsTrim = endsWithSlash && startsWithSlash;
+  const needsSlash = !endsWithSlash && !startsWithSlash;
+  return needsTrim ? first + second.slice(1) : needsSlash ? first + "/" + second : first + second;
+};
+var updateUrl = /* @__PURE__ */ dual(2, (self, f) => makeWith(self.method, f(self.url), self.urlParams, self.hash, self.headers, self.body));
+var setUrlParam = /* @__PURE__ */ dual(3, (self, key, value) => makeWith(self.method, self.url, set3(self.urlParams, key, value), self.hash, self.headers, self.body));
+var setUrlParams = /* @__PURE__ */ dual(2, (self, input) => makeWith(self.method, self.url, setAll3(self.urlParams, input), self.hash, self.headers, self.body));
+var appendUrlParam = /* @__PURE__ */ dual(3, (self, key, value) => makeWith(self.method, self.url, append(self.urlParams, key, value), self.hash, self.headers, self.body));
+var appendUrlParams = /* @__PURE__ */ dual(2, (self, input) => makeWith(self.method, self.url, appendAll(self.urlParams, input), self.hash, self.headers, self.body));
+var setHash = /* @__PURE__ */ dual(2, (self, hash) => makeWith(self.method, self.url, self.urlParams, some(hash), self.headers, self.body));
+var removeHash = (self) => makeWith(self.method, self.url, self.urlParams, none(), self.headers, self.body);
+var setBody = /* @__PURE__ */ dual(2, (self, body) => {
+  return makeWith(self.method, self.url, self.urlParams, self.hash, updateHeaders(self.headers, body), body);
+});
+var bodyUint8Array = /* @__PURE__ */ dual((args) => isHttpClientRequest(args[0]), (self, body, contentType) => setBody(self, uint8Array(body, contentType)));
+var bodyText = /* @__PURE__ */ dual((args) => isHttpClientRequest(args[0]), (self, body, contentType) => setBody(self, text(body, contentType)));
+var bodyJson = /* @__PURE__ */ dual(2, (self, body) => map(json(body), (body2) => setBody(self, body2)));
+var bodyJsonUnsafe = /* @__PURE__ */ dual(2, (self, body) => setBody(self, jsonUnsafe(body)));
+var schemaBodyJson = (schema, options3) => {
+  const encode = jsonSchema(schema, options3);
+  return dual(2, (self, body) => map(encode(body), (body2) => setBody(self, body2)));
+};
+var bodyUrlParams = /* @__PURE__ */ dual(2, (self, input) => setBody(self, urlParams(fromInput3(input))));
+var bodyFormData = /* @__PURE__ */ dual(2, (self, body) => setBody(self, formData(body)));
+var bodyFormDataRecord = /* @__PURE__ */ dual(2, (self, entries) => setBody(self, formDataRecord(entries)));
+var bodyStream = /* @__PURE__ */ dual((args) => isHttpClientRequest(args[0]), (self, body, options3) => setBody(self, stream(body, options3?.contentType, options3?.contentLength)));
+var bodyFile = /* @__PURE__ */ dual((args) => isHttpClientRequest(args[0]), (self, path, options3) => map(file(path, options3), (body) => setBody(self, body)));
+function toUrl(self) {
+  const r = make(self.url, self.urlParams, getOrUndefined(self.hash));
+  if (isSuccess(r)) {
+    return some(r.success);
+  }
+  return none();
+}
+var fromWeb = (request) => {
+  const method = request.method.toUpperCase();
+  return modify(empty8, {
+    method,
+    url: new URL(request.url),
+    headers: request.headers,
+    body: fromWebBody(request, method)
+  });
+};
+var fromWebBody = (request, method) => {
+  if (!hasBody(method) || request.body === null) {
+    return empty7;
+  }
+  return raw(request.body, {
+    contentType: request.headers.get("content-type") ?? void 0,
+    contentLength: parseContentLength(request.headers.get("content-length"))
+  });
+};
+var toWebResult = (self, options3) => {
+  const url = make(self.url, self.urlParams, getOrUndefined(self.hash));
+  if (isFailure(url)) {
+    return fail(url.failure);
+  }
+  const requestInit = {
+    method: self.method,
+    headers: self.headers
+  };
+  if (options3?.signal) {
+    requestInit.signal = options3.signal;
+  }
+  if (hasBody(self.method)) {
+    switch (self.body._tag) {
+      case "Empty": {
+        break;
+      }
+      case "Raw": {
+        requestInit.body = self.body.body;
+        if (isReadableStream(self.body.body)) {
+          ;
+          requestInit.duplex = "half";
+        }
+        break;
+      }
+      case "Uint8Array": {
+        requestInit.body = self.body.body;
+        break;
+      }
+      case "FormData": {
+        requestInit.body = self.body.formData;
+        break;
+      }
+      case "Stream": {
+        requestInit.body = toReadableStreamWith(self.body.stream, options3?.context ?? empty2());
+        requestInit.duplex = "half";
+        break;
+      }
+    }
+  }
+  return try_({
+    try: () => new Request(url.success, requestInit),
+    catch: (cause) => new UrlError({
+      cause
+    })
+  });
+};
+var isReadableStream = (u) => typeof ReadableStream !== "undefined" && u instanceof ReadableStream;
+var toWeb = (self, options3) => contextWith((context2) => fromResult(toWebResult(self, {
+  context: context2,
+  signal: options3?.signal
+})));
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpClient.js
+var HttpClient_exports = {};
+__export(HttpClient_exports, {
+  HttpClient: () => HttpClient,
+  SpanNameGenerator: () => SpanNameGenerator,
+  TracerDisabledWhen: () => TracerDisabledWhen,
+  TracerHeaderFilter: () => TracerHeaderFilter,
+  TracerPropagationEnabled: () => TracerPropagationEnabled,
+  catch: () => catch_2,
+  catchTag: () => catchTag2,
+  catchTags: () => catchTags2,
+  del: () => del2,
+  execute: () => execute,
+  filterOrElse: () => filterOrElse2,
+  filterOrFail: () => filterOrFail2,
+  filterStatus: () => filterStatus2,
+  filterStatusOk: () => filterStatusOk2,
+  followRedirects: () => followRedirects,
+  get: () => get5,
+  head: () => head2,
+  isHttpClient: () => isHttpClient,
+  layerMergedContext: () => layerMergedContext,
+  make: () => make3,
+  makeWith: () => makeWith2,
+  mapRequest: () => mapRequest,
+  mapRequestEffect: () => mapRequestEffect,
+  mapRequestInput: () => mapRequestInput,
+  mapRequestInputEffect: () => mapRequestInputEffect,
+  options: () => options2,
+  patch: () => patch2,
+  post: () => post2,
+  put: () => put2,
+  query: () => query2,
+  retry: () => retry2,
+  retryTransient: () => retryTransient,
+  tap: () => tap2,
+  tapError: () => tapError2,
+  tapRequest: () => tapRequest,
+  transform: () => transform,
+  transformResponse: () => transformResponse,
+  withCookiesRef: () => withCookiesRef,
+  withRateLimiter: () => withRateLimiter,
+  withScope: () => withScope
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpClientError.js
+var HttpClientError_exports = {};
+__export(HttpClientError_exports, {
+  DecodeError: () => DecodeError,
+  EmptyBodyError: () => EmptyBodyError,
+  EncodeError: () => EncodeError,
+  HttpClientError: () => HttpClientError,
+  HttpClientErrorSchema: () => HttpClientErrorSchema,
+  InvalidUrlError: () => InvalidUrlError,
+  StatusCodeError: () => StatusCodeError,
+  TransportError: () => TransportError,
+  isHttpClientError: () => isHttpClientError
+});
+var TypeId3 = "~effect/http/HttpClientError";
+var isHttpClientError = (u) => hasProperty(u, TypeId3);
+var HttpClientError = class extends (/* @__PURE__ */ TaggedError("HttpClientError")) {
+  constructor(props) {
+    if ("cause" in props.reason) {
+      super({
+        ...props,
+        cause: props.reason.cause
+      });
+    } else {
+      super(props);
+    }
+  }
+  /**
+   * Marks this value as an HTTP client error for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [TypeId3] = TypeId3;
+  /**
+   * HTTP request associated with the client failure.
+   *
+   * @since 4.0.0
+   */
+  get request() {
+    return this.reason.request;
+  }
+  /**
+   * HTTP response associated with the client failure, when one was received.
+   *
+   * @since 4.0.0
+   */
+  get response() {
+    return "response" in this.reason ? this.reason.response : void 0;
+  }
+  get message() {
+    return this.reason.message;
+  }
+};
+var formatReason = (tag2) => tag2.endsWith("Error") ? tag2.slice(0, -5) : tag2;
+var formatMessage = (reason, description, info) => description ? `${reason}: ${description} (${info})` : `${reason} error (${info})`;
+var TransportError = class extends (/* @__PURE__ */ TaggedError("TransportError")) {
+  /**
+   * Formats the request method and URL for transport error messages.
+   *
+   * @since 4.0.0
+   */
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  /**
+   * Builds the transport error message from the optional description and request details.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);
+  }
+};
+var EncodeError = class extends (/* @__PURE__ */ TaggedError("EncodeError")) {
+  /**
+   * Formats the request method and URL for request encoding error messages.
+   *
+   * @since 4.0.0
+   */
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  /**
+   * Builds the request encoding error message from the optional description and request details.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);
+  }
+};
+var InvalidUrlError = class extends (/* @__PURE__ */ TaggedError("InvalidUrlError")) {
+  /**
+   * Formats the request method and URL for invalid URL error messages.
+   *
+   * @since 4.0.0
+   */
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  /**
+   * Builds the invalid URL error message from the optional description and request details.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);
+  }
+};
+var StatusCodeError = class extends (/* @__PURE__ */ TaggedError("StatusCodeError")) {
+  /**
+   * Formats the request method and URL for status code error messages.
+   *
+   * @since 4.0.0
+   */
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  /**
+   * Builds the status code error message from the response status, optional description, and request details.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return formatMessage(formatReason(this._tag), this.description, info);
+  }
+};
+var DecodeError = class extends (/* @__PURE__ */ TaggedError("DecodeError")) {
+  /**
+   * Formats the request method and URL for response decoding error messages.
+   *
+   * @since 4.0.0
+   */
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  /**
+   * Builds the response decoding error message from the response status, optional description, and request details.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return formatMessage(formatReason(this._tag), this.description, info);
+  }
+};
+var EmptyBodyError = class extends (/* @__PURE__ */ TaggedError("EmptyBodyError")) {
+  /**
+   * Formats the request method and URL for empty response body error messages.
+   *
+   * @since 4.0.0
+   */
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  /**
+   * Builds the empty body error message from the response status, optional description, and request details.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return formatMessage(formatReason(this._tag), this.description, info);
+  }
+};
+var HttpClientErrorSchema = class _HttpClientErrorSchema extends (/* @__PURE__ */ Error3(TypeId3)({
+  _tag: /* @__PURE__ */ tag("HttpError"),
+  kind: /* @__PURE__ */ Literals(["EncodeError", "DecodeError", "TransportError", "InvalidUrlError", "StatusCodeError", "EmptyBodyError"]),
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+  /**
+   * Builds the serializable schema representation for an HTTP client error.
+   *
+   * @since 4.0.0
+   */
+  static fromHttpClientError(error) {
+    return new _HttpClientErrorSchema({
+      _tag: "HttpError",
+      kind: error.reason._tag,
+      cause: error.reason
+    });
+  }
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpIncomingMessage.js
+var TypeId4 = "~effect/http/HttpIncomingMessage";
+var schemaBodyJson2 = (schema, options3) => {
+  const decode = decodeEffect(toCodecJson(schema));
+  const decodeJson = options3?.reviver === void 0 ? void 0 : decodeEffect(fromJsonString(toCodecJson(schema), options3));
+  return (self) => decodeJson === void 0 ? flatMap(self.json, (u) => decode(u, options3)) : flatMap(self.text, (body) => body === "" ? flatMap(self.json, (u) => decode(u, options3)) : decodeJson(body, options3));
+};
+var schemaBodyUrlParams = (schema, options3) => {
+  const decode = RecordFromUrlParams.pipe(decodeTo(schema), decodeEffect);
+  return (self) => flatMap(self.urlParamsBody, (u) => decode(u, options3));
+};
+var MaxBodySize = /* @__PURE__ */ Reference("effect/http/HttpIncomingMessage/MaxBodySize", {
+  defaultValue: () => void 0
+});
+var inspect = (self, that) => {
+  const contentType = self.headers["content-type"] ?? "";
+  let body;
+  if (contentType.includes("application/json")) {
+    try {
+      body = runSync(self.json);
+    } catch (_) {
+    }
+  } else if (contentType.includes("text/") || contentType.includes("urlencoded")) {
+    try {
+      body = runSync(self.text);
+    } catch (_) {
+    }
+  }
+  const obj = {
+    ...that,
+    headers: redact(self.headers),
+    remoteAddress: self.remoteAddress
+  };
+  if (body !== void 0) {
+    obj.body = body;
+  }
+  return obj;
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpClientResponse.js
+var TypeId5 = "~effect/http/HttpClientResponse";
+var fromWeb2 = (request, source) => new WebHttpClientResponse(request, source);
+var filterStatus = /* @__PURE__ */ dual(2, (self, f) => suspend(() => f(self.status) ? succeed2(self) : fail3(new HttpClientError({
+  reason: new StatusCodeError({
+    response: self,
+    request: self.request,
+    description: "invalid status code"
+  })
+}))));
+var filterStatusOk = (self) => self.status >= 200 && self.status < 300 ? succeed2(self) : fail3(new HttpClientError({
+  reason: new StatusCodeError({
+    response: self,
+    request: self.request,
+    description: "non 2xx status code"
+  })
+}));
+var WebHttpClientResponse = class extends Class {
+  [TypeId4];
+  [TypeId5];
+  request;
+  source;
+  constructor(request, source) {
+    super();
+    this.request = request;
+    this.source = source;
+    this[TypeId4] = TypeId4;
+    this[TypeId5] = TypeId5;
+  }
+  toJSON() {
+    return inspect(this, {
+      _id: "HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  get status() {
+    return this.source.status;
+  }
+  get url() {
+    if (this.source.url) return this.source.url.split("#")[0];
+    const url = toUrl(this.request);
+    if (isNone(url)) return "";
+    url.value.hash = "";
+    return url.value.href;
+  }
+  get headers() {
+    return fromInput2(this.source.headers);
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = fromSetCookie(this.source.headers.getSetCookie());
+  }
+  get remoteAddress() {
+    return none();
+  }
+  get stream() {
+    return this.source.body ? fromReadableStream({
+      evaluate: () => this.source.body,
+      onError: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }) : fail4(new HttpClientError({
+      reason: new EmptyBodyError({
+        request: this.request,
+        response: this,
+        description: "can not create stream from empty body"
+      })
+    }));
+  }
+  get json() {
+    return flatMap(this.text, (text3) => try_2({
+      try: () => text3 === "" ? null : JSON.parse(text3),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  textBody;
+  get text() {
+    return this.textBody ??= map(this.arrayBuffer, (_) => new TextDecoder().decode(_));
+  }
+  get urlParamsBody() {
+    return flatMap(this.text, (_) => try_2({
+      try: () => fromInput3(new URLSearchParams(_)),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  formDataBody;
+  get formData() {
+    return this.formDataBody ??= tryPromise({
+      try: () => this.source.formData(),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(cached, runSync);
+  }
+  arrayBufferBody;
+  get arrayBuffer() {
+    if (this.arrayBufferBody) {
+      return this.arrayBufferBody;
+    }
+    this.arrayBufferBody = tryPromise({
+      try: () => this.source.arrayBuffer(),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(cached, runSync);
+    return this.arrayBufferBody;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpTraceContext.js
+var HttpTraceContext_exports = {};
+__export(HttpTraceContext_exports, {
+  b3: () => b3,
+  fromHeaders: () => fromHeaders,
+  toHeaders: () => toHeaders,
+  w3c: () => w3c,
+  xb3: () => xb3
+});
+var toHeaders = (span) => fromRecordUnsafe({
+  b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${match(span.parent, {
+    onNone: () => "",
+    onSome: (parent) => `-${parent.spanId}`
+  })}`,
+  traceparent: `00-${span.traceId}-${span.spanId}-${span.sampled ? "01" : "00"}`
+});
+var fromHeaders = (headers) => {
+  let span = w3c(headers);
+  if (isSome(span)) {
+    return span;
+  }
+  span = b3(headers);
+  if (isSome(span)) {
+    return span;
+  }
+  return xb3(headers);
+};
+var b3 = (headers) => {
+  if (!("b3" in headers)) {
+    return none();
+  }
+  const parts = headers["b3"].split("-");
+  if (parts.length < 2) {
+    return none();
+  }
+  return some(externalSpan({
+    traceId: parts[0],
+    spanId: parts[1],
+    sampled: parts[2] ? parts[2] === "1" : true
+  }));
+};
+var xb3 = (headers) => {
+  if (!headers["x-b3-traceid"] || !headers["x-b3-spanid"]) {
+    return none();
+  }
+  return some(externalSpan({
+    traceId: headers["x-b3-traceid"],
+    spanId: headers["x-b3-spanid"],
+    sampled: headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" : true
+  }));
+};
+var w3cTraceId = /^[0-9a-f]{32}$/i;
+var w3cSpanId = /^[0-9a-f]{16}$/i;
+var w3c = (headers) => {
+  if (!headers["traceparent"]) {
+    return none();
+  }
+  const parts = headers["traceparent"].split("-");
+  if (parts.length !== 4) {
+    return none();
+  }
+  const [version, traceId, spanId, flags] = parts;
+  switch (version) {
+    case "00": {
+      if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false) {
+        return none();
+      }
+      return some(externalSpan({
+        traceId,
+        spanId,
+        sampled: (parseInt(flags, 16) & 1) === 1
+      }));
+    }
+    default: {
+      return none();
+    }
+  }
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpClient.js
+var TypeId6 = "~effect/http/HttpClient";
+var isHttpClient = (u) => hasProperty(u, TypeId6);
+var HttpClient = /* @__PURE__ */ Service("effect/HttpClient");
+var accessor = (method) => (...args) => flatMap(HttpClient, (client) => client[method](...args));
+var execute = /* @__PURE__ */ accessor("execute");
+var get5 = /* @__PURE__ */ accessor("get");
+var query2 = /* @__PURE__ */ accessor("query");
+var head2 = /* @__PURE__ */ accessor("head");
+var post2 = /* @__PURE__ */ accessor("post");
+var patch2 = /* @__PURE__ */ accessor("patch");
+var put2 = /* @__PURE__ */ accessor("put");
+var del2 = /* @__PURE__ */ accessor("del");
+var options2 = /* @__PURE__ */ accessor("options");
+var transform = /* @__PURE__ */ dual(2, (self, f) => makeWith2(flatMap((request) => f(self.postprocess(succeed2(request)), request)), self.preprocess));
+var transformResponse = /* @__PURE__ */ dual(2, (self, f) => makeWith2((request) => f(self.postprocess(request)), self.preprocess));
+var catch_2 = /* @__PURE__ */ dual(2, (self, f) => transformResponse(self, catch_(f)));
+var catchTag2 = /* @__PURE__ */ dual(3, (self, tag2, f) => transformResponse(self, (effect2) => catchTag(effect2, tag2, f)));
+var catchTags2 = /* @__PURE__ */ dual(2, (self, cases) => transformResponse(self, catchTags(cases)));
+var filterOrElse2 = /* @__PURE__ */ dual(3, (self, f, orElse) => transformResponse(self, filterOrElse(f, orElse)));
+var filterOrFail2 = /* @__PURE__ */ dual(3, (self, f, orFailWith) => transformResponse(self, filterOrFail(f, orFailWith)));
+var filterStatus2 = /* @__PURE__ */ dual(2, (self, f) => transformResponse(self, flatMap(filterStatus(f))));
+var filterStatusOk2 = /* @__PURE__ */ transformResponse(/* @__PURE__ */ flatMap(filterStatusOk));
+var makeWith2 = (postprocess, preprocess) => {
+  const self = Object.create(Proto3);
+  self.preprocess = preprocess;
+  self.postprocess = postprocess;
+  self.execute = function(request) {
+    return postprocess(preprocess(request));
+  };
+  return self;
+};
+var Proto3 = {
+  [TypeId6]: TypeId6,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "effect/HttpClient"
+    };
+  },
+  .../* @__PURE__ */ Object.fromEntries(/* @__PURE__ */ allShort.map(([fullMethod, method]) => [method, function(url, options3) {
+    return this.execute(make2(fullMethod)(url, options3));
+  }]))
+};
+var make3 = (f) => makeWith2((effect2) => flatMap(effect2, (request) => withFiber((fiber) => {
+  const scopedController = scopedRequests.get(request);
+  const controller = scopedController ?? new AbortController();
+  const urlResult = make(request.url, request.urlParams, getOrUndefined(request.hash));
+  if (isFailure(urlResult)) {
+    return fail3(new HttpClientError({
+      reason: new InvalidUrlError({
+        request,
+        cause: urlResult.failure
+      })
+    }));
+  }
+  const url = urlResult.success;
+  const tracerDisabled = fiber.getRef(DisablePropagation) || fiber.getRef(TracerDisabledWhen)(request);
+  if (tracerDisabled) {
+    const effect3 = f(request, url, controller.signal, fiber);
+    if (scopedController) return effect3;
+    return uninterruptibleMask((restore) => matchCauseEffect(restore(effect3), {
+      onSuccess(response) {
+        responseRegistry.register(response, controller);
+        return succeed2(new InterruptibleResponse(response, controller));
+      },
+      onFailure(cause) {
+        if (hasInterrupts(cause)) {
+          controller.abort();
+        }
+        return failCause2(cause);
+      }
+    }));
+  }
+  return useSpan(fiber.getRef(SpanNameGenerator)(request), {
+    kind: "client"
+  }, (span) => {
+    span.attribute("http.request.method", request.method);
+    span.attribute("server.address", url.origin);
+    if (url.port !== "") {
+      span.attribute("server.port", +url.port);
+    }
+    span.attribute("url.full", url.toString());
+    span.attribute("url.path", url.pathname);
+    span.attribute("url.scheme", url.protocol.slice(0, -1));
+    const query3 = url.search.slice(1);
+    if (query3 !== "") {
+      span.attribute("url.query", query3);
+    }
+    const redactedHeaderNames = fiber.getRef(CurrentRedactedNames);
+    const headerFilter = fiber.getRef(TracerHeaderFilter);
+    for (const name in request.headers) {
+      if (!headerFilter(name, "request")) continue;
+      span.attribute(`http.request.header.${name}`, isRedactedName(name, redactedHeaderNames) ? "<redacted>" : request.headers[name]);
+    }
+    request = fiber.getRef(TracerPropagationEnabled) ? setHeaders(request, toHeaders(span)) : request;
+    return uninterruptibleMask((restore) => restore(f(request, url, controller.signal, fiber)).pipe(withParentSpan(span, {
+      captureStackTrace: false
+    }), matchCauseEffect({
+      onSuccess: (response) => {
+        span.attribute("http.response.status_code", response.status);
+        for (const name in response.headers) {
+          if (!headerFilter(name, "response")) continue;
+          span.attribute(`http.response.header.${name}`, isRedactedName(name, redactedHeaderNames) ? "<redacted>" : response.headers[name]);
+        }
+        if (scopedController) return succeed2(response);
+        responseRegistry.register(response, controller);
+        return succeed2(new InterruptibleResponse(response, controller));
+      },
+      onFailure(cause) {
+        if (!scopedController && hasInterrupts(cause)) {
+          controller.abort();
+        }
+        return failCause2(cause);
+      }
+    })));
+  });
+})), succeed2);
+var mapRequest = /* @__PURE__ */ dual(2, (self, f) => makeWith2(self.postprocess, (request) => map(self.preprocess(request), f)));
+var mapRequestEffect = /* @__PURE__ */ dual(2, (self, f) => makeWith2(self.postprocess, (request) => flatMap(self.preprocess(request), f)));
+var mapRequestInput = /* @__PURE__ */ dual(2, (self, f) => makeWith2(self.postprocess, (request) => self.preprocess(f(request))));
+var mapRequestInputEffect = /* @__PURE__ */ dual(2, (self, f) => makeWith2(self.postprocess, (request) => flatMap(f(request), self.preprocess)));
+var retry2 = /* @__PURE__ */ dual(2, (self, policy) => transformResponse(self, retry(policy)));
+var retryTransient = /* @__PURE__ */ dual(2, (self, options3) => {
+  const isOnlySchedule = isSchedule(options3);
+  const retryOn = isOnlySchedule ? "errors-and-responses" : options3.retryOn ?? "errors-and-responses";
+  const schedule = isOnlySchedule ? options3 : options3.schedule;
+  const passthroughSchedule = schedule && passthrough(schedule);
+  const times = isOnlySchedule ? void 0 : options3.times;
+  return transformResponse(self, flow(retryOn === "errors-only" ? identity : repeat({
+    schedule: passthroughSchedule,
+    times,
+    while: isTransientResponse
+  }), retryOn === "response-only" ? identity : retry({
+    while: isOnlySchedule || options3.while === void 0 ? isTransientError : or(isTransientError, options3.while),
+    schedule,
+    times
+  })));
+});
+var withRateLimiter = /* @__PURE__ */ dual(2, (self, options3) => {
+  const initialState = {
+    initial: true,
+    limit: options3.limit,
+    window: max(fromInputUnsafe(options3.window), millis(1))
+  };
+  const states = /* @__PURE__ */ new Map();
+  const keyOption = options3.key;
+  const resolveKey = typeof keyOption === "function" ? keyOption : constant(keyOption);
+  const tokensOption = options3.tokens;
+  const resolveTokens = typeof tokensOption === "function" ? tokensOption : constant(tokensOption ?? 1);
+  const adaptiveLearningEnabled = !options3.disableAdaptiveLearning;
+  const headerNames = resolveRateLimiterHeaderNames(options3.responseHeaders);
+  const getState = (key) => {
+    const current = states.get(key);
+    if (current !== void 0) {
+      return current;
+    }
+    states.set(key, initialState);
+    return initialState;
+  };
+  const onResponse = options3.disableResponseInspection ? void 0 : (clock, key, headers, tokens) => {
+    const current = getState(key);
+    const next = parseRateLimiterState(current, clock, headers, tokens, headerNames);
+    if (next.limit !== current.limit || !equals(next.window, current.window)) {
+      states.set(key, next);
+    }
+  };
+  return transform(self, function loop(effect2, request, retries = 0) {
+    const fiber = getCurrent();
+    const clock = fiber.getRef(Clock);
+    const key = resolveKey(request);
+    const tokens = Math.max(resolveTokens(request), 1);
+    const current = getState(key);
+    const canRetry = options3.times === void 0 || retries < options3.times;
+    function retry3(retryAfter) {
+      return retryAfter ? flatMap(sleep(retryAfter), () => loop(effect2, request, retries + 1)) : loop(effect2, request, retries + 1);
+    }
+    const inspectResponse = (response, adaptive) => {
+      onResponse?.(clock, key, response.headers, tokens);
+      if (options3.disableResponseInspection || response.status !== 429) {
+        return succeed2(void 0);
+      }
+      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, ...headerNames.retryAfter));
+      if (retryAfter === void 0) {
+        return succeed2(void 0);
+      }
+      const delay2 = parseRateLimitWindow(clock, response.headers, headerNames) ?? retryAfter;
+      if (adaptive === void 0) {
+        return succeed2(delay2);
+      }
+      return as(options3.limiter.adaptiveFeedback({
+        key,
+        epoch: adaptive.epoch,
+        tokens,
+        status: response.status,
+        retryAfter: delay2
+      }), delay2);
+    };
+    return flatMap(options3.limiter.consume({
+      algorithm: options3.algorithm,
+      onExceeded: "delay",
+      key,
+      limit: current.limit,
+      window: current.window,
+      tokens
+    }), ({
+      delay: delay2
+    }) => {
+      const runAdaptive = () => {
+        const runRequest = (adaptive) => {
+          const request2 = matchEffect(effect2, {
+            onSuccess(response) {
+              return flatMap(inspectResponse(response, adaptive), (retryAfter) => {
+                if (response.status !== 429 || !canRetry) return succeed2(response);
+                return retry3(retryAfter);
+              });
+            },
+            onFailure(error) {
+              if (isTooManyRequestsHttpClientError(error)) {
+                return flatMap(inspectResponse(error.reason.response, adaptive), (retryAfter) => canRetry ? retry3(retryAfter) : fail3(error));
+              }
+              return fail3(error);
+            }
+          });
+          return adaptive === void 0 || isZero(adaptive.delay) ? request2 : delay(request2, adaptive.delay);
+        };
+        if (!adaptiveLearningEnabled) {
+          return runRequest(void 0);
+        }
+        return flatMap(options3.limiter.adaptiveConsume({
+          key,
+          tokens,
+          fallbackLimit: current.limit,
+          fallbackWindow: current.window
+        }), (adaptive) => {
+          if (!isZero(adaptive.delay) && adaptive.phase === "cooldown") {
+            return flatMap(sleep(adaptive.delay), runAdaptive);
+          }
+          return runRequest(adaptive);
+        });
+      };
+      return isZero(delay2) ? runAdaptive() : flatMap(sleep(delay2), runAdaptive);
+    });
+  });
+});
+var resolveRateLimiterHeaderNames = (responseHeaders) => ({
+  limit: responseHeaders?.limit === void 0 ? ["ratelimit-limit", "x-ratelimit-limit"] : [responseHeaders.limit.toLowerCase()],
+  remaining: responseHeaders?.remaining === void 0 ? ["ratelimit-remaining", "x-ratelimit-remaining"] : [responseHeaders.remaining.toLowerCase()],
+  reset: responseHeaders?.reset === void 0 ? ["ratelimit-reset", "x-ratelimit-reset"] : [responseHeaders.reset.toLowerCase()],
+  resetAfter: responseHeaders?.resetAfter === void 0 ? ["ratelimit-reset-after", "x-ratelimit-reset-after"] : [responseHeaders.resetAfter.toLowerCase()],
+  retryAfter: responseHeaders?.retryAfter === void 0 ? ["retry-after"] : [responseHeaders.retryAfter.toLowerCase()]
+});
+var parseRateLimiterState = (state, clock, headers, tokens, headerNames) => {
+  const limit = parseRateLimitLimit(state, headers, tokens, headerNames) ?? state.limit;
+  const window = parseRateLimitWindow(clock, headers, headerNames) ?? state.window;
+  if (limit === state.limit && equals(window, state.window)) {
+    return state;
+  }
+  return {
+    limit,
+    window,
+    initial: false
+  };
+};
+var parseRateLimitLimit = (state, headers, tokens, headerNames) => {
+  const raw3 = getHeader(headers, ...headerNames.limit);
+  const value = parseNumberHeader(raw3);
+  if (value !== void 0 && value > 0) {
+    return value;
+  }
+  const remaining = parseRateLimitRemaining(headers, headerNames);
+  if (remaining === void 0) {
+    return void 0;
+  }
+  return state.initial ? remaining + tokens : Math.max(remaining + tokens, state.limit);
+};
+var parseRateLimitRemaining = (headers, headerNames) => {
+  const raw3 = getHeader(headers, ...headerNames.remaining);
+  const value = parseNumberHeader(raw3);
+  return value !== void 0 && value >= 0 ? value : void 0;
+};
+var parseRateLimitWindow = (clock, headers, headerNames) => {
+  const resetAfter = parseResetAfter(getHeader(headers, ...headerNames.resetAfter));
+  if (resetAfter !== void 0) {
+    return resetAfter;
+  }
+  return parseResetHeader(clock, getHeader(headers, ...headerNames.reset));
+};
+var parseRetryAfter = (clock, value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const numeric = parseNumberHeader(value);
+  if (numeric !== void 0) {
+    return max(seconds(numeric), millis(1));
+  }
+  const parsedDate = Date.parse(value);
+  if (Number.isNaN(parsedDate)) {
+    return void 0;
+  }
+  const millis2 = parsedDate - clock.currentTimeMillisUnsafe();
+  if (millis2 <= 0) {
+    return millis(1);
+  }
+  return millis(millis2);
+};
+var parseResetAfter = (value) => {
+  const numeric = parseNumberHeader(value);
+  if (numeric === void 0 || numeric <= 0) {
+    return void 0;
+  }
+  return max(seconds(numeric), millis(1));
+};
+var parseResetHeader = (clock, value) => {
+  const numeric = parseNumberHeader(value);
+  if (numeric === void 0 || numeric <= 0) {
+    return void 0;
+  }
+  const nowMillis = clock.currentTimeMillisUnsafe();
+  if (numeric > 1e12) {
+    return millis(Math.max(numeric - nowMillis, 1));
+  }
+  if (numeric > 1e9) {
+    return millis(Math.max(numeric * 1e3 - nowMillis, 1));
+  }
+  return max(seconds(numeric), millis(1));
+};
+var parseNumberHeader = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const match2 = /-?\d+(?:\.\d+)?/.exec(value);
+  if (match2 === null) {
+    return void 0;
+  }
+  const parsed = Number(match2[0]);
+  return Number.isFinite(parsed) ? parsed : void 0;
+};
+var getHeader = (headers, ...keys) => {
+  for (let i = 0; i < keys.length; i++) {
+    const value = headers[keys[i]];
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+};
+var tap2 = /* @__PURE__ */ dual(2, (self, f) => transformResponse(self, tap(f)));
+var tapError2 = /* @__PURE__ */ dual(2, (self, f) => transformResponse(self, tapError(f)));
+var tapRequest = /* @__PURE__ */ dual(2, (self, f) => makeWith2(self.postprocess, (request) => tap(self.preprocess(request), f)));
+var withCookiesRef = /* @__PURE__ */ dual(2, (self, ref) => makeWith2((request) => tap(self.postprocess(request), (response) => update(ref, (cookies) => merge2(cookies, response.cookies))), (request) => flatMap(self.preprocess(request), (request2) => map(get3(ref), (cookies) => isEmpty(cookies) ? request2 : setHeader(request2, "cookie", toCookieHeader(cookies))))));
+var withScope = (self) => transform(self, (effect2, request) => {
+  const controller = new AbortController();
+  scopedRequests.set(request, controller);
+  return andThen(addFinalizer(() => sync(() => controller.abort())), effect2);
+});
+var followRedirects = /* @__PURE__ */ dual((args) => isHttpClient(args[0]), (self, maxRedirects) => makeWith2((request) => {
+  const loop = (request2, redirects) => suspend(() => {
+    let currentRequest;
+    return flatMap(self.postprocess(map(request2, (request3) => {
+      currentRequest = request3;
+      return request3;
+    })), (response) => {
+      if (response.status < 300 || response.status >= 400 || !response.headers.location || redirects >= (maxRedirects ?? 10)) {
+        return succeed2(response);
+      }
+      const url = new URL(response.headers.location, response.request.url);
+      const request3 = currentRequest ?? response.request;
+      let nextRequest = request3;
+      if ((response.status === 301 || response.status === 302) && request3.method === "POST" || response.status === 303 && request3.method !== "GET" && request3.method !== "HEAD") {
+        nextRequest = setMethod(nextRequest, "GET");
+        nextRequest = setBody(nextRequest, empty7);
+      }
+      if (url.origin !== new URL(response.request.url).origin) {
+        nextRequest = removeHeader(nextRequest, "authorization");
+        nextRequest = removeHeader(nextRequest, "proxy-authorization");
+        nextRequest = removeHeader(nextRequest, "cookie");
+      }
+      return loop(succeed2(setUrl(nextRequest, url)), redirects + 1);
+    });
+  });
+  return loop(request, 0);
+}, self.preprocess));
+var TracerDisabledWhen = /* @__PURE__ */ Reference("effect/http/HttpClient/TracerDisabledWhen", {
+  defaultValue: () => constFalse
+});
+var TracerHeaderFilter = /* @__PURE__ */ Reference("effect/http/HttpClient/TracerHeaderFilter", {
+  defaultValue: () => constTrue
+});
+var TracerPropagationEnabled = /* @__PURE__ */ Reference("effect/http/HttpClient/TracerPropagationEnabled", {
+  defaultValue: constTrue
+});
+var SpanNameGenerator = /* @__PURE__ */ Reference("effect/http/HttpClient/SpanNameGenerator", {
+  defaultValue: () => (request) => `http.client ${request.method}`
+});
+var layerMergedContext = (effect2) => effect(HttpClient)(contextWith((context2) => map(effect2, (client) => transformResponse(client, updateContext((input) => merge(context2, input))))));
+var responseRegistry = /* @__PURE__ */ (() => {
+  if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
+    const registry = /* @__PURE__ */ new FinalizationRegistry((controller) => {
+      controller.abort();
+    });
+    return {
+      register(response, controller) {
+        registry.register(response, controller, response);
+      },
+      unregister(response) {
+        registry.unregister(response);
+      }
+    };
+  }
+  const timers = /* @__PURE__ */ new Map();
+  return {
+    register(response, controller) {
+      timers.set(response, setTimeout(() => controller.abort(), 5e3));
+    },
+    unregister(response) {
+      const timer = timers.get(response);
+      if (timer === void 0) return;
+      clearTimeout(timer);
+      timers.delete(response);
+    }
+  };
+})();
+var scopedRequests = /* @__PURE__ */ new WeakMap();
+var InterruptibleResponse = class {
+  original;
+  controller;
+  constructor(original, controller) {
+    this.original = original;
+    this.controller = controller;
+  }
+  [TypeId5] = TypeId5;
+  [TypeId4] = TypeId4;
+  applyInterrupt(effect2) {
+    return suspend(() => {
+      responseRegistry.unregister(this.original);
+      return onInterrupt(effect2, () => sync(() => {
+        this.controller.abort();
+      }));
+    });
+  }
+  get request() {
+    return this.original.request;
+  }
+  get url() {
+    return this.original.url;
+  }
+  get status() {
+    return this.original.status;
+  }
+  get headers() {
+    return this.original.headers;
+  }
+  get cookies() {
+    return this.original.cookies;
+  }
+  get remoteAddress() {
+    return this.original.remoteAddress;
+  }
+  get formData() {
+    return this.applyInterrupt(this.original.formData);
+  }
+  get text() {
+    return this.applyInterrupt(this.original.text);
+  }
+  get json() {
+    return this.applyInterrupt(this.original.json);
+  }
+  get urlParamsBody() {
+    return this.applyInterrupt(this.original.urlParamsBody);
+  }
+  get arrayBuffer() {
+    return this.applyInterrupt(this.original.arrayBuffer);
+  }
+  get stream() {
+    return suspend2(() => {
+      responseRegistry.unregister(this.original);
+      return ensuring2(this.original.stream, sync(() => {
+        this.controller.abort();
+      }));
+    });
+  }
+  toJSON() {
+    return this.original.toJSON();
+  }
+  [NodeInspectSymbol]() {
+    return this.original[NodeInspectSymbol]();
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var isTransientError = (error) => isTimeoutError(error) || isTransientHttpError(error);
+var isTransientHttpError = (error) => isHttpClientError(error) && (error.reason._tag === "TransportError" || error.reason._tag === "StatusCodeError" && isTransientResponse(error.reason.response));
+var isTooManyRequestsHttpClientError = (error) => isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429;
+var isTransientResponse = (response) => response.status === 408 || response.status === 429 || response.status === 500 || response.status === 502 || response.status === 503 || response.status === 504;
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/Template.js
+function make4(strings, ...args) {
+  const argsLength = args.length;
+  const values = new Array(argsLength);
+  const effects = [];
+  for (let i = 0; i < argsLength; i++) {
+    const arg = args[i];
+    if (isOption(arg)) {
+      values[i] = arg._tag === "Some" ? primitiveToString(arg.value) : "";
+    } else if (isSuccess2(arg)) {
+      values[i] = primitiveToString(arg.value);
+    } else if (isEffect(arg)) {
+      effects.push([i, arg]);
+    } else {
+      values[i] = primitiveToString(arg);
+    }
+  }
+  if (effects.length === 0) {
+    return succeed2(consolidate(strings, values));
+  }
+  return map(forEach(effects, ([index, effect2]) => tap(effect2, (value) => sync(() => {
+    values[index] = primitiveToString(value);
+  })), {
+    concurrency: "unbounded",
+    discard: true
+  }), (_) => consolidate(strings, values));
+}
+function stream2(strings, ...args) {
+  const chunks = [];
+  let buffer2 = "";
+  for (let i = 0, len = args.length; i < len; i++) {
+    buffer2 += strings[i];
+    const arg = args[i];
+    if (isOption(arg)) {
+      buffer2 += arg._tag === "Some" ? primitiveToString(arg.value) : "";
+    } else if (isSuccess2(arg)) {
+      buffer2 += primitiveToString(arg.value);
+    } else if (isEffect(arg)) {
+      if (buffer2.length > 0) {
+        chunks.push(buffer2);
+        buffer2 = "";
+      }
+      chunks.push(map(arg, primitiveToString));
+    } else if (isStream(arg)) {
+      if (buffer2.length > 0) {
+        chunks.push(buffer2);
+        buffer2 = "";
+      }
+      chunks.push(map2(arg, primitiveToString));
+    } else {
+      buffer2 += primitiveToString(arg);
+    }
+  }
+  buffer2 += strings[strings.length - 1];
+  if (buffer2.length > 0) {
+    chunks.push(buffer2);
+    buffer2 = "";
+  }
+  return fromIterable2(chunks).pipe(mapEffect((chunk) => isEffect(chunk) ? chunk : succeed2(chunk), {
+    concurrency: "unbounded"
+  }), flatMap2((chunk) => typeof chunk === "string" ? succeed3(chunk) : chunk));
+}
+function primitiveToString(value) {
+  if (Array.isArray(value)) {
+    return value.map(primitiveToString).join("");
+  }
+  switch (typeof value) {
+    case "string": {
+      return value;
+    }
+    case "number":
+    case "bigint": {
+      return value.toString();
+    }
+    case "boolean": {
+      return value ? "true" : "false";
+    }
+    default: {
+      return "";
+    }
+  }
+}
+function consolidate(strings, values) {
+  let out = "";
+  for (let i = 0, len = values.length; i < len; i++) {
+    out += strings[i];
+    out += values[i];
+  }
+  return out + strings[strings.length - 1];
+}
+function isSuccess2(u) {
+  return isExit(u) && u._tag === "Success";
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpServerResponse.js
+var HttpServerResponse_exports = {};
+__export(HttpServerResponse_exports, {
+  empty: () => empty9,
+  expireCookie: () => expireCookie2,
+  expireCookieUnsafe: () => expireCookieUnsafe2,
+  file: () => file2,
+  fileWeb: () => fileWeb,
+  formData: () => formData2,
+  fromClientResponse: () => fromClientResponse,
+  fromWeb: () => fromWeb3,
+  html: () => html,
+  htmlStream: () => htmlStream,
+  isHttpServerResponse: () => isHttpServerResponse,
+  json: () => json2,
+  jsonUnsafe: () => jsonUnsafe2,
+  mergeCookies: () => mergeCookies,
+  omitsBody: () => omitsBody,
+  raw: () => raw2,
+  redirect: () => redirect,
+  removeCookie: () => removeCookie,
+  removeHeader: () => removeHeader2,
+  replaceCookies: () => replaceCookies,
+  schemaJson: () => schemaJson,
+  setBody: () => setBody2,
+  setBodyKeepHeaders: () => setBodyKeepHeaders,
+  setCookie: () => setCookie,
+  setCookieUnsafe: () => setCookieUnsafe,
+  setCookies: () => setCookies,
+  setCookiesUnsafe: () => setCookiesUnsafe,
+  setHeader: () => setHeader2,
+  setHeaders: () => setHeaders2,
+  setStatus: () => setStatus,
+  stream: () => stream3,
+  text: () => text2,
+  toClientResponse: () => toClientResponse,
+  toWeb: () => toWeb2,
+  uint8Array: () => uint8Array2,
+  updateCookies: () => updateCookies,
+  urlParams: () => urlParams2
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/internal/headers.js
+var Proto4 = /* @__PURE__ */ Object.getPrototypeOf(empty4);
+var emptyMutableUnsafe = () => Object.create(Proto4);
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpServerResponse.js
+var TypeId7 = "~effect/http/HttpServerResponse";
+var isHttpServerResponse = (u) => hasProperty(u, TypeId7);
+var empty9 = (options3) => makeResponse({
+  status: options3?.status ?? 204,
+  statusText: options3?.statusText,
+  headers: options3?.headers ? fromInput2(options3.headers) : void 0,
+  cookies: options3?.cookies
+});
+var redirect = (location2, options3) => {
+  const headers = fromRecordUnsafe({
+    location: location2.toString()
+  });
+  return makeResponse({
+    status: options3?.status ?? 302,
+    statusText: options3?.statusText,
+    headers: options3?.headers ? merge3(headers, fromInput2(options3.headers)) : headers,
+    cookies: options3?.cookies ?? empty3
+  });
+};
+var uint8Array2 = (body, options3) => {
+  const headers = options3?.headers ? fromInput2(options3.headers) : empty4;
+  return makeResponse({
+    status: options3?.status ?? 200,
+    statusText: options3?.statusText,
+    headers,
+    cookies: options3?.cookies ?? empty3,
+    body: uint8Array(body, getContentType(options3, headers))
+  });
+};
+var getContentType = (options3, headers) => {
+  if (options3?.contentType) {
+    return options3.contentType;
+  } else if (options3?.headers) {
+    return headers["content-type"];
+  }
+};
+var text2 = (body, options3) => {
+  const headers = options3?.headers ? fromInput2(options3.headers) : empty4;
+  return makeResponse({
+    status: options3?.status ?? 200,
+    statusText: options3?.statusText,
+    headers,
+    cookies: options3?.cookies ?? empty3,
+    body: text(body, getContentType(options3, headers))
+  });
+};
+var html = (strings, ...args) => {
+  if (typeof strings === "string") {
+    return text2(strings, {
+      contentType: "text/html"
+    });
+  }
+  return map(make4(strings, ...args), (_) => text2(_, {
+    contentType: "text/html"
+  }));
+};
+var htmlStream = (strings, ...args) => map(context(), (context2) => stream3(provideContext(encodeText(stream2(strings, ...args)), context2), {
+  contentType: "text/html"
+}));
+var json2 = (body, options3) => {
+  const headers = options3?.headers ? fromInput2(options3.headers) : empty4;
+  return map(json(body, getContentType(options3, headers)), (body2) => makeResponse({
+    status: options3?.status ?? 200,
+    statusText: options3?.statusText,
+    headers,
+    cookies: options3?.cookies,
+    body: body2
+  }));
+};
+var schemaJson = (schema, options3) => {
+  const encode = jsonSchema(schema, options3);
+  return (body, options4) => {
+    const headers = options4?.headers ? fromInput2(options4.headers) : empty4;
+    return map(encode(body, getContentType(options4, headers)), (body2) => makeResponse({
+      status: options4?.status ?? 200,
+      statusText: options4?.statusText,
+      headers,
+      cookies: options4?.cookies,
+      body: body2
+    }));
+  };
+};
+var jsonUnsafe2 = (body, options3) => {
+  const headers = options3?.headers ? fromInput2(options3.headers) : empty4;
+  return makeResponse({
+    status: options3?.status ?? 200,
+    statusText: options3?.statusText,
+    headers,
+    cookies: options3?.cookies,
+    body: jsonUnsafe(body, getContentType(options3, headers))
+  });
+};
+var urlParams2 = (body, options3) => {
+  const headers = options3?.headers ? fromInput2(options3.headers) : empty4;
+  return makeResponse({
+    status: options3?.status ?? 200,
+    statusText: options3?.statusText,
+    headers,
+    cookies: options3?.cookies,
+    body: text(toString(fromInput3(body)), getContentType(options3, headers) ?? "application/x-www-form-urlencoded")
+  });
+};
+var raw2 = (body, options3) => makeResponse({
+  status: options3?.status ?? 200,
+  statusText: options3?.statusText,
+  headers: options3?.headers && fromInput2(options3.headers),
+  cookies: options3?.cookies,
+  body: raw(body, {
+    contentType: options3?.contentType,
+    contentLength: options3?.contentLength
+  })
+});
+var formData2 = (body, options3) => makeResponse({
+  status: options3?.status ?? 200,
+  statusText: options3?.statusText,
+  headers: options3?.headers && fromInput2(options3.headers),
+  cookies: options3?.cookies,
+  body: formData(body)
+});
+var stream3 = (body, options3) => {
+  const headers = options3?.headers ? fromInput2(options3.headers) : empty4;
+  return makeResponse({
+    status: options3?.status ?? 200,
+    statusText: options3?.statusText,
+    headers,
+    cookies: options3?.cookies,
+    body: stream(body, getContentType(options3, headers), options3?.contentLength)
+  });
+};
+var HttpPlatformKey = /* @__PURE__ */ Service("effect/http/HttpPlatform");
+var file2 = (path, options3) => flatMap(HttpPlatformKey, (platform) => platform.fileResponse(path, options3));
+var fileWeb = (file3, options3) => flatMap(HttpPlatformKey, (platform) => platform.fileWebResponse(file3, options3));
+var setHeader2 = /* @__PURE__ */ dual(3, (self, key, value) => makeResponse(self, set2(self.headers, key, value)));
+var removeHeader2 = /* @__PURE__ */ dual(2, (self, key) => makeResponse({
+  ...self,
+  headers: remove2(self.headers, key)
+}));
+var setHeaders2 = /* @__PURE__ */ dual(2, (self, input) => makeResponse(self, setAll2(self.headers, input)));
+var removeCookie = /* @__PURE__ */ dual(2, (self, name) => makeResponse({
+  ...self,
+  cookies: remove(self.cookies, name)
+}));
+var replaceCookies = /* @__PURE__ */ dual(2, (self, cookies) => makeResponse({
+  ...self,
+  cookies
+}));
+var setCookie = /* @__PURE__ */ dual((args) => isHttpServerResponse(args[0]), (self, name, value, options3) => map(fromResult(set(self.cookies, name, value, options3)), (cookies) => makeResponse({
+  ...self,
+  cookies
+})));
+var expireCookie2 = /* @__PURE__ */ dual((args) => isHttpServerResponse(args[0]), (self, name, options3) => map(fromResult(expireCookie(self.cookies, name, options3)), (cookies) => makeResponse({
+  ...self,
+  cookies
+})));
+var setCookieUnsafe = /* @__PURE__ */ dual((args) => isHttpServerResponse(args[0]), (self, name, value, options3) => makeResponse({
+  ...self,
+  cookies: setUnsafe(self.cookies, name, value, options3)
+}));
+var expireCookieUnsafe2 = /* @__PURE__ */ dual((args) => isHttpServerResponse(args[0]), (self, name, options3) => makeResponse({
+  ...self,
+  cookies: expireCookieUnsafe(self.cookies, name, options3)
+}));
+var updateCookies = /* @__PURE__ */ dual(2, (self, f) => makeResponse({
+  ...self,
+  cookies: f(self.cookies)
+}));
+var mergeCookies = /* @__PURE__ */ dual(2, (self, cookies) => makeResponse({
+  ...self,
+  cookies: merge2(self.cookies, cookies)
+}));
+var setCookies = /* @__PURE__ */ dual(2, (self, cookies) => map(fromResult(setAll(self.cookies, cookies)), (cookies2) => makeResponse({
+  ...self,
+  cookies: cookies2
+})));
+var setCookiesUnsafe = /* @__PURE__ */ dual(2, (self, cookies) => makeResponse({
+  ...self,
+  cookies: setAllUnsafe(self.cookies, cookies)
+}));
+var setBody2 = /* @__PURE__ */ dual(2, (self, body) => makeResponse({
+  ...self,
+  body
+}, updateHeaders(self.headers, body)));
+var setBodyKeepHeaders = (self, body) => {
+  const response = Object.create(Proto5);
+  response.status = self.status;
+  response.statusText = self.statusText;
+  response.headers = self.headers;
+  response.cookies = self.cookies;
+  response.body = body;
+  return response;
+};
+var setStatus = /* @__PURE__ */ dual((args) => isHttpServerResponse(args[0]), (self, status, statusText) => makeResponse({
+  ...self,
+  status,
+  statusText: statusText ?? self.statusText
+}));
+var omitsBody = (response, withoutBody = false) => withoutBody || response.status === 204 || response.status === 205 || response.status === 304;
+var toWeb2 = (response, options3) => {
+  const headers = new globalThis.Headers(response.headers);
+  if (!isEmpty(response.cookies)) {
+    const toAdd = toSetCookieHeaders(response.cookies);
+    for (const header of toAdd) {
+      headers.append("set-cookie", header);
+    }
+  }
+  const body = response.body;
+  const outerOmitsBody = omitsBody(response);
+  const withoutBody = outerOmitsBody || options3?.withoutBody === true;
+  if (body._tag === "Raw" && body.body instanceof Response) {
+    const raw3 = body.body;
+    for (const [key, value] of headers) {
+      if (key === "set-cookie") {
+        raw3.headers.append(key, value);
+      } else {
+        raw3.headers.set(key, value);
+      }
+    }
+    if (!withoutBody) {
+      return raw3;
+    }
+    const source = outerOmitsBody ? response : raw3;
+    return new Response(void 0, {
+      status: source.status,
+      statusText: source.statusText,
+      headers: raw3.headers
+    });
+  }
+  if (withoutBody) {
+    if (body._tag === "Raw" && isReadableStream2(body.body)) {
+      body.body.cancel().catch(constVoid);
+    }
+    return new Response(void 0, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  switch (body._tag) {
+    case "Empty": {
+      return new Response(void 0, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    case "Uint8Array": {
+      return new Response(body.text ?? body.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    case "Raw": {
+      return new Response(body.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    case "FormData": {
+      return new Response(body.formData, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    case "Stream": {
+      return new Response(toReadableStreamWith(body.stream, options3?.context ?? empty2()), {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+  }
+};
+var toClientResponse = (response, options3) => new ServerHttpClientResponse(options3?.request ?? empty8, response);
+var ServerHttpClientResponse = class extends Class {
+  [TypeId4];
+  [TypeId5];
+  request;
+  response;
+  constructor(request, response) {
+    super();
+    this.request = request;
+    this.response = response;
+    this[TypeId4] = TypeId4;
+    this[TypeId5] = TypeId5;
+  }
+  toJSON() {
+    return inspect(this, {
+      _id: "HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  get status() {
+    return this.response.status;
+  }
+  get url() {
+    if (this.request === empty8) return "";
+    const url = toUrl(this.request);
+    if (isNone(url)) return "";
+    url.value.hash = "";
+    return url.value.href;
+  }
+  cachedHeaders;
+  get headers() {
+    return this.cachedHeaders ??= this.response.body._tag === "FormData" ? merge3(this.response.headers, fromInput2(this.getFormDataResponse().headers)) : this.response.headers;
+  }
+  get cookies() {
+    return this.response.cookies;
+  }
+  get remoteAddress() {
+    return none();
+  }
+  get stream() {
+    const body = this.response.body;
+    switch (body._tag) {
+      case "Empty": {
+        return empty6;
+      }
+      case "Stream": {
+        return mapError3(body.stream, (cause) => this.decodeError(cause));
+      }
+      case "Uint8Array": {
+        return succeed3(body.body);
+      }
+      case "Raw": {
+        const rawBody = body.body;
+        if (rawBody instanceof Response) {
+          return rawBody.body ? fromReadableStream({
+            evaluate: () => rawBody.body,
+            onError: (cause) => this.decodeError(cause)
+          }) : empty6;
+        }
+        if (isReadableStream2(rawBody)) {
+          return fromReadableStream({
+            evaluate: () => rawBody,
+            onError: (cause) => this.decodeError(cause)
+          });
+        }
+        if (rawBody instanceof Blob) {
+          return fromReadableStream({
+            evaluate: () => rawBody.stream(),
+            onError: (cause) => this.decodeError(cause)
+          });
+        }
+        return unwrap2(map(this.bytes, succeed3));
+      }
+      case "FormData": {
+        const response = this.getFormDataResponse();
+        return fromReadableStream({
+          evaluate: () => response.body,
+          onError: (cause) => this.decodeError(cause)
+        });
+      }
+    }
+  }
+  get json() {
+    return flatMap(this.text, (text3) => try_2({
+      try: () => text3 === "" ? null : JSON.parse(text3),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  get bytes() {
+    const body = this.response.body;
+    switch (body._tag) {
+      case "Empty": {
+        return succeed2(new Uint8Array(0));
+      }
+      case "Uint8Array": {
+        return succeed2(body.body);
+      }
+      case "Stream": {
+        return mkUint8Array2(this.stream);
+      }
+      case "Raw": {
+        const rawBody = body.body;
+        if (rawBody instanceof Response) {
+          return tryPromise({
+            try: () => rawBody.clone().arrayBuffer().then((buffer2) => new Uint8Array(buffer2)),
+            catch: (cause) => this.decodeError(cause)
+          });
+        }
+        return tryPromise({
+          try: () => new Response(rawBody).arrayBuffer().then((buffer2) => new Uint8Array(buffer2)),
+          catch: (cause) => this.decodeError(cause)
+        });
+      }
+      case "FormData": {
+        return tryPromise({
+          try: () => new Response(body.formData).arrayBuffer().then((buffer2) => new Uint8Array(buffer2)),
+          catch: (cause) => this.decodeError(cause)
+        });
+      }
+    }
+  }
+  get text() {
+    return map(this.bytes, (bytes) => textDecoder.decode(bytes));
+  }
+  get urlParamsBody() {
+    return flatMap(this.text, (_) => try_2({
+      try: () => fromInput3(new URLSearchParams(_)),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  get formData() {
+    const body = this.response.body;
+    if (body._tag === "FormData") {
+      return succeed2(body.formData);
+    }
+    return contextWith((context2) => {
+      const readableStream = toReadableStreamWith(this.stream, context2);
+      return tryPromise({
+        try: () => new Response(readableStream, {
+          headers: this.headers
+        }).formData(),
+        catch: (cause) => this.decodeError(cause)
+      });
+    });
+  }
+  get arrayBuffer() {
+    return map(
+      this.bytes,
+      // Copy this view because Buffer views may share a larger ArrayBuffer.
+      (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+    );
+  }
+  decodeError(cause) {
+    return new HttpClientError({
+      reason: new DecodeError({
+        request: this.request,
+        response: this,
+        cause
+      })
+    });
+  }
+  formDataResponse;
+  getFormDataResponse() {
+    return this.formDataResponse ??= new Response(this.response.body.formData);
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var textDecoder = /* @__PURE__ */ new TextDecoder();
+var fromClientResponse = (response) => {
+  const headers = remove2(response.headers, "set-cookie");
+  return makeResponse({
+    status: response.status,
+    headers,
+    cookies: response.cookies,
+    body: stream(catchIf(response.stream, isEmptyBodyError, () => empty6), getOrUndefined(get2(headers, "content-type")), parseContentLength(headers["content-length"]))
+  });
+};
+var isReadableStream2 = (u) => typeof ReadableStream !== "undefined" && u instanceof ReadableStream;
+var isEmptyBodyError = (error) => isHttpClientError(error) && error.reason._tag === "EmptyBodyError";
+var Proto5 = {
+  ...PipeInspectableProto,
+  [TypeId7]: TypeId7,
+  [ignore]: true,
+  toJSON() {
+    return {
+      _id: "HttpServerResponse",
+      status: this.status,
+      statusText: this.statusText,
+      headers: redact(this.headers),
+      cookies: this.cookies.toJSON(),
+      body: this.body.toJSON()
+    };
+  }
+};
+var makeResponse = (options3, ownedHeaders) => {
+  const self = Object.create(Proto5);
+  self.status = options3.status;
+  self.statusText = options3.statusText;
+  self.cookies = options3.cookies ?? empty3;
+  self.body = options3.body ?? empty7;
+  if (self.body._tag !== "Empty" && (self.body.contentType || self.body.contentLength !== void 0)) {
+    const owned = ownedHeaders !== void 0;
+    const newHeaders = owned ? ownedHeaders : options3.headers === void 0 || options3.headers === empty4 ? emptyMutableUnsafe() : fromRecordUnsafe({
+      ...options3.headers
+    });
+    if (self.body.contentType && (!owned || newHeaders["content-type"] === void 0)) {
+      newHeaders["content-type"] = self.body.contentType;
+    }
+    if (self.body.contentLength !== void 0 && (!owned || newHeaders["content-length"] === void 0)) {
+      newHeaders["content-length"] = self.body.contentLength.toString();
+    }
+    self.headers = newHeaders;
+  } else {
+    self.headers = ownedHeaders ?? options3.headers ?? empty4;
+  }
+  return self;
+};
+var fromWeb3 = (response) => {
+  const headers = new globalThis.Headers(response.headers);
+  const setCookieHeaders = headers.getSetCookie();
+  headers.delete("set-cookie");
+  let self = empty9({
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+    cookies: fromSetCookie(setCookieHeaders)
+  });
+  if (response.body) {
+    const contentType = response.headers.get("content-type");
+    self = setBody2(self, stream(fromReadableStream({
+      evaluate: () => response.body,
+      onError: (e) => e
+    }), contentType ?? void 0, parseContentLength(response.headers.get("content-length"))));
+  }
+  return self;
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpServerRespondable.js
+var symbol = "~effect/http/HttpServerRespondable";
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpServerError.js
+var TypeId8 = "~effect/http/HttpServerError";
+var HttpServerError = class extends (/* @__PURE__ */ TaggedError("HttpServerError")) {
+  constructor(props) {
+    if ("cause" in props.reason) {
+      super({
+        ...props,
+        cause: props.reason.cause
+      });
+    } else {
+      super(props);
+    }
+  }
+  [TypeId8] = TypeId8;
+  stack = `${this.name}: ${this.message}`;
+  get request() {
+    return this.reason.request;
+  }
+  get response() {
+    return "response" in this.reason ? this.reason.response : void 0;
+  }
+  [symbol]() {
+    return this.reason[symbol]();
+  }
+  get [ignore]() {
+    return this.reason[ignore] ?? false;
+  }
+  get message() {
+    return this.reason.message;
+  }
+};
+var RequestParseError = class extends (/* @__PURE__ */ TaggedError("RequestParseError")) {
+  /**
+   * Converts the request error into a `400 Bad Request` response.
+   *
+   * @since 4.0.0
+   */
+  [symbol]() {
+    return succeed2(empty9({
+      status: 400
+    }));
+  }
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    return formatRequestMessage(this._tag, this.description, this.methodAndUrl);
+  }
+};
+var RouteNotFound = class extends (/* @__PURE__ */ TaggedError("RouteNotFound")) {
+  [symbol]() {
+    return succeed2(empty9({
+      status: 404
+    }));
+  }
+  [ignore] = true;
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    return formatRequestMessage(this._tag, this.description, this.methodAndUrl);
+  }
+};
+var InternalError = class extends (/* @__PURE__ */ TaggedError("InternalError")) {
+  /**
+   * Converts the server error into a `500 Internal Server Error` response.
+   *
+   * @since 4.0.0
+   */
+  [symbol]() {
+    return succeed2(empty9({
+      status: 500
+    }));
+  }
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    return formatRequestMessage(this._tag, this.description, this.methodAndUrl);
+  }
+};
+var ResponseError = class extends (/* @__PURE__ */ TaggedError("ResponseError")) {
+  [symbol]() {
+    return succeed2(empty9({
+      status: 500
+    }));
+  }
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    const info = `${this._tag} (${this.response.status} ${this.methodAndUrl})`;
+    return this.description ? `${info}: ${this.description}` : info;
+  }
+};
+var formatRequestMessage = (reason, description, info) => {
+  const prefix = `${reason} (${info})`;
+  return description ? `${prefix}: ${description}` : prefix;
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/MultipartParser/internal/contentType.js
+var paramRE = /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\v\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+) */gu;
+var quotedPairRE = /\\([\v\u0020-\u{10ffff}])/gu;
+var mediaTypeRE = /^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u;
+var mediaTypeRENoSlash = /^[!#$%&'*+.^\w|~-]+$/u;
+var defaultContentType = {
+  value: "",
+  parameters: /* @__PURE__ */ Object.create(null)
+};
+function parse(header, withoutSlash = false) {
+  if (typeof header !== "string") {
+    return defaultContentType;
+  }
+  let index = header.indexOf(";");
+  const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+  const mediaRE = withoutSlash ? mediaTypeRENoSlash : mediaTypeRE;
+  if (mediaRE.test(type) === false) {
+    return defaultContentType;
+  }
+  const result = {
+    value: type.toLowerCase(),
+    parameters: /* @__PURE__ */ Object.create(null)
+  };
+  if (index === -1) {
+    return result;
+  }
+  let key;
+  let match2;
+  let value;
+  paramRE.lastIndex = index;
+  while (match2 = paramRE.exec(header)) {
+    if (match2.index !== index) {
+      return defaultContentType;
+    }
+    index += match2[0].length;
+    key = match2[1].toLowerCase();
+    value = match2[2];
+    if (value[0] === '"') {
+      value = value.slice(1, value.length - 1);
+      if (!withoutSlash && quotedPairRE.test(value)) {
+        value = value.replace(quotedPairRE, "$1");
+      }
+    }
+    result.parameters[key] = value;
+  }
+  if (index !== header.length) {
+    return defaultContentType;
+  }
+  return result;
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/MultipartParser/internal/headers.js
+var constMaxPairs = 100;
+var constMaxSize = 16 * 1024;
+var State = {
+  key: 0,
+  whitespace: 1,
+  value: 2
+};
+var constContinue = {
+  _tag: "Continue"
+};
+var constNameChars = /* @__PURE__ */ new Uint8Array(256);
+for (const char of "!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+  constNameChars[/* @__PURE__ */ char.charCodeAt(0)] = 1;
+}
+var constValueChars = /* @__PURE__ */ new Uint8Array(256);
+constValueChars[9] = 1;
+for (let i = 32; i <= 126; i++) {
+  constValueChars[i] = 1;
+}
+for (let i = 128; i <= 255; i++) {
+  constValueChars[i] = 1;
+}
+function make5() {
+  const decoder = new TextDecoder();
+  const state = {
+    state: State.key,
+    headers: /* @__PURE__ */ Object.create(null),
+    key: "",
+    value: void 0,
+    crlf: 0,
+    previousChunk: void 0,
+    pairs: 0,
+    size: 0
+  };
+  function reset(value) {
+    state.state = State.key;
+    state.headers = /* @__PURE__ */ Object.create(null);
+    state.key = "";
+    state.value = void 0;
+    state.crlf = 0;
+    state.previousChunk = void 0;
+    state.pairs = 0;
+    state.size = 0;
+    return value;
+  }
+  function concatUint8Array(a, b) {
+    const newUint8Array = new Uint8Array(a.length + b.length);
+    newUint8Array.set(a);
+    newUint8Array.set(b, a.length);
+    return newUint8Array;
+  }
+  function error(reason) {
+    return reset({
+      _tag: "Failure",
+      reason,
+      headers: state.headers
+    });
+  }
+  return function write(chunk, start) {
+    let endOffset = 0;
+    let previousCursor;
+    if (state.previousChunk !== void 0) {
+      endOffset = state.previousChunk.length;
+      previousCursor = endOffset;
+      const newChunk = new Uint8Array(chunk.length + endOffset);
+      newChunk.set(state.previousChunk);
+      newChunk.set(chunk, endOffset);
+      state.previousChunk = void 0;
+      chunk = newChunk;
+    }
+    const end = chunk.length;
+    outer: while (start < end) {
+      if (state.state === State.key) {
+        let i = start;
+        for (; i < end; i++) {
+          if (state.size++ > constMaxSize) {
+            return error("HeaderTooLarge");
+          }
+          if (chunk[i] === 58) {
+            state.key += decoder.decode(chunk.subarray(start, i)).toLowerCase();
+            if (state.key.length === 0) {
+              return error("InvalidHeaderName");
+            }
+            if (chunk[i + 1] === 32 && chunk[i + 2] !== 32 && chunk[i + 2] !== 9) {
+              start = i + 2;
+              state.state = State.value;
+              state.size++;
+            } else if (chunk[i + 1] !== 32 && chunk[i + 1] !== 9) {
+              start = i + 1;
+              state.state = State.value;
+            } else {
+              start = i + 1;
+              state.state = State.whitespace;
+            }
+            break;
+          } else if (constNameChars[chunk[i]] !== 1) {
+            return error("InvalidHeaderName");
+          }
+        }
+        if (i === end) {
+          state.key += decoder.decode(chunk.subarray(start, end)).toLowerCase();
+          return constContinue;
+        }
+      }
+      if (state.state === State.whitespace) {
+        for (; start < end; start++) {
+          if (state.size++ > constMaxSize) {
+            return error("HeaderTooLarge");
+          }
+          if (chunk[start] !== 32 && chunk[start] !== 9) {
+            state.state = State.value;
+            break;
+          }
+        }
+        if (start === end) {
+          return constContinue;
+        }
+      }
+      if (state.state === State.value) {
+        let i = start;
+        if (previousCursor !== void 0) {
+          i = previousCursor;
+          previousCursor = void 0;
+        }
+        for (; i < end; i++) {
+          if (state.size++ > constMaxSize) {
+            return error("HeaderTooLarge");
+          }
+          if (chunk[i] === 13 || state.crlf > 0) {
+            let byte = chunk[i];
+            if (byte === 13 && state.crlf === 0) {
+              state.crlf = 1;
+              i++;
+              state.size++;
+              byte = chunk[i];
+            }
+            if (byte === 10 && state.crlf === 1) {
+              state.crlf = 2;
+              i++;
+              state.size++;
+              byte = chunk[i];
+            }
+            if (byte === 13 && state.crlf === 2) {
+              state.crlf = 3;
+              i++;
+              state.size++;
+              byte = chunk[i];
+            }
+            if (byte === 10 && state.crlf === 3) {
+              state.crlf = 4;
+              i++;
+              state.size++;
+            }
+            if (state.crlf < 4 && i >= end) {
+              state.previousChunk = chunk.subarray(start);
+              return constContinue;
+            } else if (state.crlf >= 2) {
+              state.value = state.value === void 0 ? chunk.subarray(start, i - state.crlf) : concatUint8Array(state.value, chunk.subarray(start, i - state.crlf));
+              const value = decoder.decode(state.value);
+              if (state.headers[state.key] === void 0) {
+                state.headers[state.key] = value;
+              } else if (typeof state.headers[state.key] === "string") {
+                state.headers[state.key] = [state.headers[state.key], value];
+              } else {
+                ;
+                state.headers[state.key].push(value);
+              }
+              start = i;
+              state.size--;
+              if (state.crlf !== 4 && state.pairs === constMaxPairs) {
+                return error("TooManyHeaders");
+              } else if (state.crlf === 3) {
+                return error("InvalidHeaderValue");
+              } else if (state.crlf === 4) {
+                return reset({
+                  _tag: "Headers",
+                  headers: state.headers,
+                  endPosition: start - endOffset
+                });
+              }
+              state.pairs++;
+              state.key = "";
+              state.value = void 0;
+              state.crlf = 0;
+              state.state = State.key;
+              continue outer;
+            }
+          } else if (constValueChars[chunk[i]] !== 1) {
+            return error("InvalidHeaderValue");
+          }
+        }
+        if (i === end) {
+          state.value = state.value === void 0 ? chunk.subarray(start, end) : concatUint8Array(state.value, chunk.subarray(start, end));
+          return constContinue;
+        }
+      }
+    }
+    if (start > end) {
+      state.size += end - start;
+    }
+    return constContinue;
+  };
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/MultipartParser/internal/search.js
+function makeState(needle_) {
+  const needle = new TextEncoder().encode(needle_);
+  const needleLength = needle.length;
+  const indexes = {};
+  for (let i = 0; i < needleLength; i++) {
+    const b = needle[i];
+    if (indexes[b] === void 0) indexes[b] = [];
+    indexes[b].push(i);
+  }
+  return {
+    needle,
+    needleLength,
+    indexes,
+    firstByte: needle[0],
+    previousChunk: void 0,
+    previousChunkLength: 0,
+    matchIndex: 0
+  };
+}
+function make6(needle, callback2, seed, minimumChunkLength) {
+  const state = makeState(needle);
+  const minChunkLength = minimumChunkLength ?? state.needleLength;
+  if (seed !== void 0) {
+    state.previousChunk = seed;
+    state.previousChunkLength = seed.length;
+  }
+  function makeIndexOf() {
+    if ("Buffer" in globalThis && !("Bun" in globalThis || "Deno" in globalThis)) {
+      return function(chunk, needle2, fromIndex) {
+        return Buffer.prototype.indexOf.call(chunk, needle2, fromIndex);
+      };
+    }
+    const skipTable = new Uint8Array(256).fill(state.needle.length);
+    for (let i = 0, lastIndex = state.needle.length - 1; i < lastIndex; ++i) {
+      skipTable[state.needle[i]] = lastIndex - i;
+    }
+    return function(chunk, needle2, fromIndex) {
+      const lengthTotal = chunk.length;
+      let i = fromIndex + state.needleLength - 1;
+      while (i < lengthTotal) {
+        for (let j = state.needleLength - 1, k = i; j >= 0 && chunk[k] === needle2[j]; j--, k--) {
+          if (j === 0) return k;
+        }
+        i += skipTable[chunk[i]];
+      }
+      return -1;
+    };
+  }
+  const indexOf = makeIndexOf();
+  function write(chunk) {
+    let chunkLength = chunk.length;
+    if (state.previousChunk !== void 0) {
+      const newChunk = new Uint8Array(state.previousChunkLength + chunkLength);
+      newChunk.set(state.previousChunk);
+      newChunk.set(chunk, state.previousChunkLength);
+      chunk = newChunk;
+      chunkLength = state.previousChunkLength + chunkLength;
+      state.previousChunk = void 0;
+    }
+    let pos = 0;
+    while (pos < chunkLength) {
+      const remaining = chunkLength - pos;
+      if (remaining < minChunkLength) {
+        state.previousChunk = chunk.subarray(pos);
+        state.previousChunkLength = remaining;
+        return;
+      }
+      const match2 = indexOf(chunk, state.needle, pos);
+      if (match2 > -1) {
+        if (match2 > pos) {
+          callback2(state.matchIndex, chunk.subarray(pos, match2));
+        }
+        state.matchIndex += 1;
+        pos = match2 + state.needleLength;
+        continue;
+      } else if (chunk[chunkLength - 1] in state.indexes) {
+        const indexes = state.indexes[chunk[chunkLength - 1]];
+        let earliestIndex = -1;
+        for (let i = 0, len = indexes.length; i < len; i++) {
+          const index = indexes[i];
+          if (chunk[chunkLength - 1 - index] === state.firstByte && i > earliestIndex) {
+            earliestIndex = index;
+          }
+        }
+        if (earliestIndex === -1) {
+          if (pos === 0) {
+            callback2(state.matchIndex, chunk);
+          } else {
+            callback2(state.matchIndex, chunk.subarray(pos));
+          }
+        } else {
+          if (chunkLength - 1 - earliestIndex > pos) {
+            callback2(state.matchIndex, chunk.subarray(pos, chunkLength - 1 - earliestIndex));
+          }
+          state.previousChunk = chunk.subarray(chunkLength - 1 - earliestIndex);
+          state.previousChunkLength = earliestIndex + 1;
+        }
+      } else if (pos === 0) {
+        callback2(state.matchIndex, chunk);
+      } else {
+        callback2(state.matchIndex, chunk.subarray(pos));
+      }
+      break;
+    }
+  }
+  function end() {
+    if (state.previousChunk !== void 0 && state.previousChunk !== seed) {
+      callback2(state.matchIndex, state.previousChunk);
+    }
+    state.previousChunk = seed;
+    state.previousChunkLength = seed?.length ?? 0;
+    state.matchIndex = 0;
+  }
+  return {
+    write,
+    end
+  };
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/MultipartParser/internal/multipart.js
+var State2 = {
+  headers: 0,
+  body: 1
+};
+var errInvalidDisposition = {
+  _tag: "InvalidDisposition"
+};
+var errEndNotReached = {
+  _tag: "EndNotReached"
+};
+var errMaxParts = {
+  _tag: "ReachedLimit",
+  limit: "MaxParts"
+};
+var errMaxTotalSize = {
+  _tag: "ReachedLimit",
+  limit: "MaxTotalSize"
+};
+var errMaxPartSize = {
+  _tag: "ReachedLimit",
+  limit: "MaxPartSize"
+};
+var errMaxFieldSize = {
+  _tag: "ReachedLimit",
+  limit: "MaxFieldSize"
+};
+var constCR = /* @__PURE__ */ new TextEncoder().encode("\r\n");
+function defaultIsFile(info) {
+  return info.filename !== void 0 || info.contentType === "application/octet-stream";
+}
+function parseBoundary(headers) {
+  const contentType = parse(headers["content-type"]);
+  return contentType.parameters.boundary;
+}
+function noopOnChunk(_chunk) {
+}
+var toLimit = (input) => input === Infinity ? Infinity : Number(fromInputUnsafe2(input));
+function make7({
+  headers,
+  onFile: onPart,
+  onField,
+  onError,
+  onDone,
+  isFile = defaultIsFile,
+  maxParts = Infinity,
+  maxTotalSize: maxTotalSizeInput = Infinity,
+  maxPartSize: maxPartSizeInput = Infinity,
+  maxFieldSize: maxFieldSizeInput = 1024 * 1024
+}) {
+  const maxTotalSize = toLimit(maxTotalSizeInput);
+  const maxPartSize = toLimit(maxPartSizeInput);
+  const maxFieldSize = toLimit(maxFieldSizeInput);
+  const boundary = parseBoundary(headers);
+  if (boundary === void 0) {
+    onError({
+      _tag: "InvalidBoundary"
+    });
+    return {
+      write: noopOnChunk,
+      end() {
+      }
+    };
+  }
+  const state = {
+    state: State2.headers,
+    index: 0,
+    parts: 0,
+    onChunk: noopOnChunk,
+    info: void 0,
+    headerSkip: 0,
+    partSize: 0,
+    totalSize: 0,
+    isFile: false,
+    fieldChunks: [],
+    fieldSize: 0,
+    done: false,
+    stopped: false
+  };
+  function skipBody() {
+    state.state = State2.body;
+    state.isFile = true;
+    state.onChunk = noopOnChunk;
+  }
+  function stop(error) {
+    state.stopped = true;
+    if (state.state === State2.body && state.isFile) {
+      state.onChunk(null);
+    }
+    onError(error);
+  }
+  const headerParser = make5();
+  const split = make6(`\r
+--${boundary}`, function(index, chunk) {
+    if (state.stopped) {
+      return;
+    }
+    if (index === 0) {
+      skipBody();
+      return;
+    } else if (index !== state.index) {
+      if (state.index > 0) {
+        if (state.isFile) {
+          state.onChunk(null);
+        } else {
+          if (state.fieldChunks.length === 1) {
+            onField(state.info, state.fieldChunks[0]);
+          } else {
+            const buf = new Uint8Array(state.fieldSize);
+            let offset = 0;
+            for (let i = 0; i < state.fieldChunks.length; i++) {
+              const chunk2 = state.fieldChunks[i];
+              buf.set(chunk2, offset);
+              offset += chunk2.length;
+            }
+            onField(state.info, buf);
+          }
+          state.fieldSize = 0;
+          state.fieldChunks = [];
+        }
+      }
+      state.partSize = 0;
+      state.state = State2.headers;
+      state.index = index;
+      state.headerSkip = 2;
+      if (chunk[0] === 45 && chunk[1] === 45) {
+        state.done = true;
+        return onDone();
+      }
+      state.parts++;
+      if (state.parts > maxParts) {
+        return stop(errMaxParts);
+      }
+    }
+    if ((state.partSize += chunk.length) > maxPartSize) {
+      return stop(errMaxPartSize);
+    }
+    if (state.state === State2.headers) {
+      const result = headerParser(chunk, state.headerSkip);
+      state.headerSkip = 0;
+      if (result._tag === "Continue") {
+        return;
+      } else if (result._tag === "Failure") {
+        skipBody();
+        return onError({
+          _tag: "BadHeaders",
+          error: result
+        });
+      }
+      const contentType = parse(result.headers["content-type"]);
+      const contentDisposition = parse(result.headers["content-disposition"], true);
+      if ("form-data" === contentDisposition.value && !("name" in contentDisposition.parameters)) {
+        skipBody();
+        return onError(errInvalidDisposition);
+      }
+      let encodedFilename;
+      if ("filename*" in contentDisposition.parameters) {
+        const parts = contentDisposition.parameters["filename*"].split("''");
+        if (parts.length === 2) {
+          try {
+            encodedFilename = decodeURIComponent(parts[1]);
+          } catch {
+            encodedFilename = parts[1];
+          }
+        }
+      }
+      state.info = {
+        name: contentDisposition.parameters.name ?? "",
+        filename: encodedFilename ?? contentDisposition.parameters.filename,
+        contentType: contentType.value === "" ? contentDisposition.parameters.filename !== void 0 ? "application/octet-stream" : "text/plain" : contentType.value,
+        contentTypeParameters: contentType.parameters,
+        contentDisposition: contentDisposition.value,
+        contentDispositionParameters: contentDisposition.parameters,
+        headers: result.headers
+      };
+      state.state = State2.body;
+      state.isFile = isFile(state.info);
+      if (state.isFile) {
+        state.onChunk = onPart(state.info);
+      }
+      if (result.endPosition < chunk.length) {
+        if (state.isFile) {
+          state.onChunk(chunk.subarray(result.endPosition));
+        } else {
+          const buf = chunk.subarray(result.endPosition);
+          if ((state.fieldSize += buf.length) > maxFieldSize) {
+            return stop(errMaxFieldSize);
+          }
+          state.fieldChunks.push(buf);
+        }
+      }
+    } else if (state.isFile) {
+      state.onChunk(chunk);
+    } else {
+      if ((state.fieldSize += chunk.length) > maxFieldSize) {
+        return stop(errMaxFieldSize);
+      }
+      state.fieldChunks.push(chunk);
+    }
+  }, constCR, 2);
+  return {
+    write(chunk) {
+      if (state.stopped) {
+        return;
+      }
+      if ((state.totalSize += chunk.length) > maxTotalSize) {
+        return stop(errMaxTotalSize);
+      }
+      return split.write(chunk);
+    },
+    end() {
+      split.end();
+      if (!state.done && !state.stopped) {
+        stop(errEndNotReached);
+      }
+      state.state = State2.headers;
+      state.index = 0;
+      state.parts = 0;
+      state.onChunk = noopOnChunk;
+      state.info = void 0;
+      state.totalSize = 0;
+      state.partSize = 0;
+      state.fieldChunks = [];
+      state.fieldSize = 0;
+      state.done = false;
+      state.stopped = false;
+    }
+  };
+}
+var utf8Decoder = /* @__PURE__ */ new TextDecoder("utf-8");
+function getDecoder(charset) {
+  if (charset === "utf-8" || charset === "utf8" || charset === "") {
+    return utf8Decoder;
+  }
+  try {
+    return new TextDecoder(charset);
+  } catch (error) {
+    return utf8Decoder;
+  }
+}
+function decodeField(info, value) {
+  return getDecoder(info.contentTypeParameters.charset ?? "utf-8").decode(value);
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/MultipartParser.js
+var make8 = make7;
+var defaultIsFile2 = defaultIsFile;
+var decodeField2 = decodeField;
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/Multipart.js
+var TypeId9 = "~effect/http/Multipart";
+var MultipartErrorTypeId = "~effect/http/Multipart/MultipartError";
+var toMultipartError = (cause) => hasProperty(cause, MultipartErrorTypeId) ? cause : MultipartError.fromReason("InternalError", cause);
+var MultipartErrorReason = class extends Error2 {
+};
+var responseStatusByReason = {
+  FileTooLarge: 413,
+  FieldTooLarge: 413,
+  BodyTooLarge: 413,
+  TooManyParts: 413,
+  InternalError: 500,
+  Parse: 400
+};
+var MultipartError = class _MultipartError extends (/* @__PURE__ */ TaggedError("MultipartError")) {
+  /**
+   * Creates a multipart error from a reason tag and optional cause.
+   *
+   * @since 4.0.0
+   */
+  static fromReason(reason, cause) {
+    return new _MultipartError({
+      reason: new MultipartErrorReason({
+        _tag: reason,
+        cause
+      })
+    });
+  }
+  /**
+   * Marks this value as a multipart error for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [MultipartErrorTypeId] = MultipartErrorTypeId;
+  [ignore] = true;
+  /**
+   * Converts the multipart error into an HTTP response based on its reason.
+   *
+   * **Details**
+   *
+   * Parse errors produce `400`, size and part-count limits produce `413`, and
+   * internal errors produce `500`.
+   *
+   * @since 4.0.0
+   */
+  [symbol]() {
+    return succeed2(empty9({
+      status: responseStatusByReason[this.reason._tag]
+    }));
+  }
+  /**
+   * Uses the concrete multipart error reason as the public message.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return this.reason._tag;
+  }
+};
+var schemaPersisted = (schema) => decodeUnknownEffect(schema);
+var schemaJson2 = (schema, options3) => {
+  const fromJson = fromJsonString(schema, options3);
+  return dual(2, (persisted, field) => map(decodeUnknownEffect(Struct({
+    [field]: fromJson
+  }))(persisted, options3), (_) => _[field]));
+};
+var makeConfig = (headers) => withFiber((fiber) => {
+  const mimeTypes = get(fiber.context, FieldMimeTypes);
+  return succeed2({
+    headers,
+    maxParts: fiber.getRef(MaxParts),
+    maxFieldSize: fiber.getRef(MaxFieldSize),
+    maxPartSize: fiber.getRef(MaxFileSize),
+    maxTotalSize: fiber.getRef(MaxBodySize),
+    isFile: mimeTypes.length === 0 ? void 0 : (info) => !mimeTypes.some((_) => info.contentType.includes(_)) && defaultIsFile2(info)
+  });
+});
+var makeChannel = (headers) => fromTransform((upstream) => map(makeConfig(headers), (config) => {
+  let partsBuffer = [];
+  let exit2 = none();
+  let ended = false;
+  const parser = make8({
+    ...config,
+    onField(info, value) {
+      partsBuffer.push(new FieldImpl(info.name, info.contentType, decodeField2(info, value)));
+    },
+    onFile(info) {
+      let chunks = [];
+      let finished = false;
+      const pullChunks = fromPull(succeed2(suspend(function loop() {
+        if (!isReadonlyArrayNonEmpty(chunks)) {
+          if (finished) {
+            return done();
+          }
+          if (isSome(exit2)) {
+            return exit2.value;
+          }
+          return flatMap(pump, loop);
+        }
+        const chunk = chunks;
+        chunks = [];
+        return succeed2(chunk);
+      })));
+      partsBuffer.push(new FileImpl(info, mapError2(pullChunks, toMultipartError)));
+      return function(chunk) {
+        if (chunk === null) {
+          finished = true;
+        } else {
+          chunks.push(chunk);
+        }
+      };
+    },
+    onError(error_) {
+      exit2 = some(fail2(convertError(error_)));
+    },
+    onDone() {
+      if (isNone(exit2)) {
+        exit2 = some(fail2(Done()));
+      }
+    }
+  });
+  const pump = upstream.pipe(flatMap((chunk) => {
+    for (let i = 0; i < chunk.length; i++) {
+      parser.write(chunk[i]);
+    }
+    return void_2;
+  }), catchCause((cause) => {
+    if (isDoneCause(cause)) {
+      if (!ended) {
+        ended = true;
+        parser.end();
+      }
+    } else {
+      exit2 = some(failCause(cause));
+    }
+    return void_2;
+  }));
+  return pump.pipe(flatMap(function loop() {
+    if (!isReadonlyArrayNonEmpty(partsBuffer)) {
+      if (isSome(exit2)) {
+        return exit2.value;
+      }
+      return flatMap(pump, loop);
+    }
+    const parts = partsBuffer;
+    partsBuffer = [];
+    return succeed2(parts);
+  }));
+}));
+function convertError(cause) {
+  switch (cause._tag) {
+    case "ReachedLimit": {
+      switch (cause.limit) {
+        case "MaxParts": {
+          return MultipartError.fromReason("TooManyParts", cause);
+        }
+        case "MaxFieldSize": {
+          return MultipartError.fromReason("FieldTooLarge", cause);
+        }
+        case "MaxPartSize": {
+          return MultipartError.fromReason("FileTooLarge", cause);
+        }
+        case "MaxTotalSize": {
+          return MultipartError.fromReason("BodyTooLarge", cause);
+        }
+      }
+    }
+    default: {
+      return MultipartError.fromReason("Parse", cause);
+    }
+  }
+}
+var PartBase = class extends Class {
+  [TypeId9];
+  constructor() {
+    super();
+    this[TypeId9] = TypeId9;
+  }
+};
+var FieldImpl = class extends PartBase {
+  _tag = "Field";
+  key;
+  contentType;
+  value;
+  constructor(key, contentType, value) {
+    super();
+    this.key = key;
+    this.contentType = contentType;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "Field",
+      key: this.key,
+      contentType: this.contentType,
+      value: this.value
+    };
+  }
+};
+var FileImpl = class extends PartBase {
+  _tag = "File";
+  key;
+  name;
+  contentType;
+  content;
+  contentEffect;
+  constructor(info, channel) {
+    super();
+    this.key = info.name;
+    this.name = info.filename ?? info.name;
+    this.contentType = info.contentType;
+    this.content = fromChannel(channel);
+    this.contentEffect = mkUint8Array(channel);
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    };
+  }
+};
+var defaultWriteFile = (path, file3) => flatMap(FileSystem, (fs) => mapError(run(file3.content, fs.sink(path)), toMultipartError));
+var toPersisted = (stream4, writeFile = defaultWriteFile) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path_ = yield* Path;
+  const dir = yield* fs.makeTempDirectoryScoped();
+  const persisted = /* @__PURE__ */ Object.create(null);
+  const usedPaths = /* @__PURE__ */ new Set();
+  let fileIndex = 0;
+  yield* runForEach(stream4, (part) => {
+    if (part._tag === "Field") {
+      if (!(part.key in persisted)) {
+        persisted[part.key] = part.value;
+      } else if (typeof persisted[part.key] === "string") {
+        persisted[part.key] = [persisted[part.key], part.value];
+      } else {
+        ;
+        persisted[part.key].push(part.value);
+      }
+      return void_2;
+    } else if (part.name === "") {
+      return void_2;
+    }
+    const file3 = part;
+    const fileName = path_.basename(file3.name).slice(-128);
+    let path = path_.join(dir, fileName);
+    while (usedPaths.has(path)) {
+      path = path_.join(dir, `${fileIndex++}-${fileName}`);
+    }
+    usedPaths.add(path);
+    const filePart = new PersistedFileImpl(file3.key, file3.name, file3.contentType, path);
+    if (Array.isArray(persisted[part.key])) {
+      ;
+      persisted[part.key].push(filePart);
+    } else {
+      persisted[part.key] = [filePart];
+    }
+    return writeFile(path, file3);
+  });
+  return persisted;
+}).pipe(catchTag("PlatformError", (cause) => fail3(MultipartError.fromReason("InternalError", cause))));
+var PersistedFileImpl = class extends PartBase {
+  _tag = "PersistedFile";
+  key;
+  name;
+  contentType;
+  path;
+  constructor(key, name, contentType, path) {
+    super();
+    this.key = key;
+    this.name = name;
+    this.contentType = contentType;
+    this.path = path;
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "PersistedFile",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType,
+      path: this.path
+    };
+  }
+};
+var MaxParts = /* @__PURE__ */ Reference("effect/http/Multipart/MaxParts", {
+  defaultValue: () => void 0
+});
+var MaxFieldSize = /* @__PURE__ */ Reference("effect/http/Multipart/MaxFieldSize", {
+  defaultValue: /* @__PURE__ */ constant(/* @__PURE__ */ mebibytes(10))
+});
+var MaxFileSize = /* @__PURE__ */ Reference("effect/http/Multipart/MaxFileSize", {
+  defaultValue: () => void 0
+});
+var FieldMimeTypes = /* @__PURE__ */ Reference("effect/http/Multipart/FieldMimeTypes", {
+  defaultValue: /* @__PURE__ */ constant(["application/json"])
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpServerRequest.js
+var HttpServerRequest_exports = {};
+__export(HttpServerRequest_exports, {
+  HttpServerRequest: () => HttpServerRequest,
+  MaxBodySize: () => MaxBodySize,
+  ParsedSearchParams: () => ParsedSearchParams,
+  TypeId: () => TypeId10,
+  fromClientRequest: () => fromClientRequest,
+  fromWeb: () => fromWeb4,
+  schemaBodyForm: () => schemaBodyForm,
+  schemaBodyFormJson: () => schemaBodyFormJson,
+  schemaBodyJson: () => schemaBodyJson3,
+  schemaBodyMultipart: () => schemaBodyMultipart,
+  schemaBodyUrlParams: () => schemaBodyUrlParams2,
+  schemaCookies: () => schemaCookies,
+  schemaHeaders: () => schemaHeaders,
+  schemaSearchParams: () => schemaSearchParams,
+  searchParamsFromURL: () => searchParamsFromURL,
+  toClientRequest: () => toClientRequest,
+  toURL: () => toURL,
+  toWeb: () => toWeb3,
+  toWebResult: () => toWebResult2,
+  upgradeChannel: () => upgradeChannel
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/socket/Socket.js
+var encoder2 = /* @__PURE__ */ new TextEncoder();
+var readerBytes = (self) => map(self.reader, ({
+  pull
+}) => map(pull, (chunk) => {
+  for (let i = 0; i < chunk.length; i++) {
+    if (typeof chunk[i] === "string") {
+      const out = new Array(chunk.length);
+      for (let j = 0; j < chunk.length; j++) {
+        const item = chunk[j];
+        out[j] = typeof item === "string" ? encoder2.encode(item) : item;
+      }
+      return out;
+    }
+  }
+  return chunk;
+}));
+var CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
+var CloseEvent = class {
+  /**
+   * Marks this value as a socket close event for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [CloseEventTypeId];
+  code;
+  reason;
+  constructor(code = 1e3, reason) {
+    this[CloseEventTypeId] = CloseEventTypeId;
+    this.code = code;
+    this.reason = reason;
+  }
+  /**
+   * Formats the close code and optional reason for display.
+   *
+   * @since 4.0.0
+   */
+  toString() {
+    return this.reason ? `${this.code}: ${this.reason}` : `${this.code}`;
+  }
+};
+var isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
+var SocketErrorTypeId = "~effect/socket/Socket/SocketError";
+var isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
+var SocketReadError = class extends (/* @__PURE__ */ Error3("effect/socket/Socket/SocketReadError")({
+  _tag: /* @__PURE__ */ tag("SocketReadError"),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  /**
+   * Default message used for socket read failures.
+   *
+   * @since 4.0.0
+   */
+  message = `An error occurred during Read`;
+};
+var SocketWriteError = class extends (/* @__PURE__ */ Error3("effect/socket/Socket/SocketWriteError")({
+  _tag: /* @__PURE__ */ tag("SocketWriteError"),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  /**
+   * Default message used for socket write failures.
+   *
+   * @since 4.0.0
+   */
+  message = `An error occurred during Write`;
+};
+var SocketOpenError = class extends (/* @__PURE__ */ Error3("effect/socket/Socket/SocketOpenError")({
+  _tag: /* @__PURE__ */ tag("SocketOpenError"),
+  kind: /* @__PURE__ */ Literals(["Unknown", "Timeout"]),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  /**
+   * Formats timeout and unknown open failures for display.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
+  }
+};
+var SocketUpgradeError = class _SocketUpgradeError extends (/* @__PURE__ */ Error3("effect/socket/Socket/SocketUpgradeError")({
+  _tag: /* @__PURE__ */ tag("SocketUpgradeError"),
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
+})) {
+  /**
+   * An upgrade implementation for transports that cannot wrap the connection
+   * with TLS.
+   *
+   * @since 4.0.0
+   */
+  static unsupported = () => fail3(new SocketError({
+    reason: new _SocketUpgradeError({})
+  }));
+  get message() {
+    return this.cause === void 0 ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
+  }
+};
+var SocketCloseError = class extends (/* @__PURE__ */ Error3("effect/socket/Socket/SocketCloseError")({
+  _tag: /* @__PURE__ */ tag("SocketCloseError"),
+  code: Int,
+  closeReason: /* @__PURE__ */ optional(String2)
+})) {
+  get message() {
+    if (this.closeReason) {
+      return `${this.code}: ${this.closeReason}`;
+    }
+    return `${this.code}`;
+  }
+};
+var SocketErrorReason = /* @__PURE__ */ Union([SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError]);
+var SocketError = class extends (/* @__PURE__ */ TaggedError2(SocketErrorTypeId)("SocketError", {
+  _tag: /* @__PURE__ */ tag("SocketError"),
+  reason: SocketErrorReason
+})) {
+  // @effect-diagnostics-next-line overriddenSchemaConstructor:off
+  constructor(props) {
+    if ("cause" in props.reason) {
+      super({
+        ...props,
+        cause: props.reason.cause
+      });
+    } else {
+      super(props);
+    }
+  }
+  /**
+   * Marks this value as a socket error wrapper for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [SocketErrorTypeId] = SocketErrorTypeId;
+  /**
+   * Returns `true` when the value is a `SocketError`.
+   *
+   * @since 4.0.0
+   */
+  static is(u) {
+    return isSocketError(u);
+  }
+  message = this.reason.message;
+};
+var writeChunk = (writer, chunk) => {
+  for (let i = 0; i < chunk.length; i++) {
+    if (isCloseEvent(chunk[i])) {
+      return gen(function* () {
+        for (let index = 0; index <= i; index++) {
+          yield* writer.write(chunk[index]);
+        }
+      });
+    }
+  }
+  return writer.writeAll(chunk);
+};
+var toChannelWithReader = (self, reader) => fromTransform(fnUntraced(function* (upstream, scope2) {
+  const readScope = yield* fork(scope2);
+  const pull = yield* provide(reader, readScope);
+  const writeScope = yield* fork(scope2);
+  const writer = yield* provide(self.writer, writeScope);
+  let writeFailure;
+  yield* upstream.pipe(flatMap((chunk) => writeChunk(writer, chunk)), forever({
+    disableYield: true
+  }), catchCauseFilter(filterNoDone, (cause) => suspend(() => {
+    writeFailure = cause;
+    return close(readScope, void_);
+  })), ensuring(close(writeScope, void_)), forkIn(scope2));
+  return catchCause(suspend(() => writeFailure !== void 0 ? failCause2(writeFailure) : pull), (cause) => failCause2(writeFailure ?? cause));
+}));
+var toChannel = (self) => toChannelWithReader(self, readerBytes(self));
+var toChannelWith = () => (self) => toChannel(self);
+var defaultHighWaterMark = 64 * 1024;
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpServerRequest.js
+var TypeId10 = "~effect/http/HttpServerRequest";
+var HttpServerRequest = /* @__PURE__ */ Service("effect/http/HttpServerRequest");
+var ParsedSearchParams = class extends (/* @__PURE__ */ Service()("effect/http/ParsedSearchParams")) {
+};
+var searchParamsFromURL = (url) => {
+  const out = {};
+  for (const [key, value] of url.searchParams.entries()) {
+    if (Object.hasOwn(out, key)) {
+      const entry = out[key];
+      if (Array.isArray(entry)) {
+        entry.push(value);
+      } else {
+        assignProperty(out, key, [entry, value]);
+      }
+    } else {
+      assignProperty(out, key, value);
+    }
+  }
+  return out;
+};
+var upgradeChannel = () => HttpServerRequest.pipe(flatMap((_) => _.upgrade), map(toChannelWith()), unwrap);
+var schemaCookies = (schema, options3) => {
+  const parse2 = decodeUnknownEffect(schema);
+  return flatMap(HttpServerRequest, (req) => parse2(req.cookies, options3));
+};
+var schemaHeaders = (schema, options3) => {
+  const parse2 = decodeUnknownEffect(schema);
+  return flatMap(HttpServerRequest, (req) => parse2(req.headers, options3));
+};
+var schemaSearchParams = (schema, options3) => {
+  const parse2 = decodeUnknownEffect(schema);
+  return flatMap(ParsedSearchParams, (params) => parse2(params, options3));
+};
+var schemaBodyJson3 = (schema, options3) => {
+  const parse2 = schemaBodyJson2(schema, options3);
+  return flatMap(HttpServerRequest, parse2);
+};
+var isMultipart = (request) => request.headers["content-type"]?.toLowerCase().includes("multipart/form-data") === true || getFormDataBody(request) !== void 0;
+var schemaBodyForm = (schema, options3) => {
+  const parseMultipart = schemaPersisted(schema);
+  const parseUrlParams = schemaBodyUrlParams(schema, options3);
+  return flatMap(HttpServerRequest, (request) => {
+    if (isMultipart(request)) {
+      return flatMap(request.multipart, (_) => parseMultipart(_, options3));
+    }
+    return parseUrlParams(request);
+  });
+};
+var schemaBodyUrlParams2 = (schema, options3) => {
+  const parse2 = schemaBodyUrlParams(schema, options3);
+  return flatMap(HttpServerRequest, parse2);
+};
+var schemaBodyMultipart = (schema, options3) => {
+  const parse2 = schemaPersisted(schema);
+  return HttpServerRequest.pipe(flatMap((_) => _.multipart), flatMap((_) => parse2(_, options3)));
+};
+var schemaBodyFormJson = (schema, options3) => {
+  const parseMultipart = schemaJson2(schema, options3);
+  return (field) => {
+    const parseUrlParams = JsonFromUrlParamsField(field, options3).pipe(decodeTo(schema), decodeEffect);
+    return flatMap(HttpServerRequest, (request) => {
+      if (isMultipart(request)) {
+        return flatMap(mapError(request.multipart, (cause) => new HttpServerError({
+          reason: new RequestParseError({
+            request,
+            cause
+          })
+        })), parseMultipart(field));
+      }
+      return flatMap(request.urlParamsBody, (_) => parseUrlParams(_, options3));
+    });
+  };
+};
+var fromClientRequest = (request) => {
+  const url = match(toUrl(request), {
+    onNone: () => request.url,
+    onSome: (url2) => url2.toString()
+  });
+  return new ClientRequestImpl(request, url);
+};
+var fromWeb4 = (request) => new ServerRequestImpl(request, removeHost(request.url));
+var toClientRequest = (request) => {
+  const body = toClientBody(request);
+  const headers = body._tag !== "Empty" && body.contentLength === void 0 ? remove2(request.headers, "content-length") : request.headers;
+  return setUrl(makeWith(request.method, "", empty5, none(), headers, body), getOrElse(toURL(request), () => request.url));
+};
+var toClientBody = (request) => {
+  if (!hasBody(request.method)) {
+    return empty7;
+  }
+  const formData3 = getFormDataBody(request);
+  return formData3 === void 0 ? stream(request.stream, request.headers["content-type"], parseContentLength(request.headers["content-length"])) : formData(formData3);
+};
+var removeHost = (url) => {
+  if (url[0] === "/") {
+    return url;
+  }
+  const index = url.indexOf("/", url.indexOf("//") + 2);
+  return index === -1 ? "/" : url.slice(index);
+};
+var ServerRequestImpl = class _ServerRequestImpl extends Class {
+  [TypeId10];
+  [TypeId4];
+  source;
+  url;
+  headersOverride;
+  remoteAddressOverride;
+  constructor(source, url, headersOverride, remoteAddressOverride) {
+    super();
+    this[TypeId10] = TypeId10;
+    this[TypeId4] = TypeId4;
+    this.source = source;
+    this.url = url;
+    this.headersOverride = headersOverride;
+    this.remoteAddressOverride = remoteAddressOverride;
+  }
+  toJSON() {
+    return inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    });
+  }
+  modify(options3) {
+    return new _ServerRequestImpl(this.source, options3.url ?? this.url, options3.headers ?? this.headersOverride, "remoteAddress" in options3 ? options3.remoteAddress : this.remoteAddressOverride);
+  }
+  get method() {
+    return this.source.method.toUpperCase();
+  }
+  get originalUrl() {
+    return this.source.url;
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ?? none();
+  }
+  get headers() {
+    this.headersOverride ??= fromInput2(this.source.headers);
+    return this.headersOverride;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = parseHeader(this.headers.cookie ?? "");
+  }
+  get stream() {
+    return this.source.body ? fromReadableStream({
+      evaluate: () => this.source.body,
+      onError: (cause) => new HttpServerError({
+        reason: new RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    }) : fail4(new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        description: "can not create stream from empty body"
+      })
+    }));
+  }
+  textEffect;
+  get text() {
+    if (this.textEffect) {
+      return this.textEffect;
+    }
+    this.textEffect = runSync(cached(tryPromise({
+      try: () => this.source.text(),
+      catch: (cause) => new HttpServerError({
+        reason: new RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    })));
+    return this.textEffect;
+  }
+  get json() {
+    return flatMap(this.text, (text3) => try_2({
+      try: () => JSON.parse(text3),
+      catch: (cause) => new HttpServerError({
+        reason: new RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    }));
+  }
+  get urlParamsBody() {
+    return flatMap(this.text, (_) => try_2({
+      try: () => fromInput3(new URLSearchParams(_)),
+      catch: (cause) => new HttpServerError({
+        reason: new RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    }));
+  }
+  multipartEffect;
+  get multipart() {
+    if (this.multipartEffect) {
+      return this.multipartEffect;
+    }
+    this.multipartEffect = runSync(cached(toPersisted(this.multipartStream)));
+    return this.multipartEffect;
+  }
+  get multipartStream() {
+    return pipeThroughChannel(mapError3(this.stream, (cause) => MultipartError.fromReason("InternalError", cause)), makeChannel(this.headers));
+  }
+  arrayBufferEffect;
+  get arrayBuffer() {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect;
+    }
+    this.arrayBufferEffect = runSync(cached(tryPromise({
+      try: () => this.source.arrayBuffer(),
+      catch: (cause) => new HttpServerError({
+        reason: new RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    })));
+    return this.arrayBufferEffect;
+  }
+  get upgrade() {
+    return fail3(new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        description: "Not an upgradeable ServerRequest"
+      })
+    }));
+  }
+};
+var ClientRequestImpl = class _ClientRequestImpl extends Class {
+  [TypeId10];
+  [TypeId4];
+  source;
+  originalUrl;
+  headersOverride;
+  remoteAddressOverride;
+  urlOverride;
+  constructor(source, originalUrl, urlOverride, headersOverride, remoteAddressOverride) {
+    super();
+    this[TypeId10] = TypeId10;
+    this[TypeId4] = TypeId4;
+    this.source = source;
+    this.originalUrl = originalUrl;
+    this.urlOverride = urlOverride;
+    this.headersOverride = headersOverride;
+    this.remoteAddressOverride = remoteAddressOverride;
+  }
+  toJSON() {
+    return inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    });
+  }
+  modify(options3) {
+    return new _ClientRequestImpl(this.source, this.originalUrl, options3.url ?? this.url, options3.headers ?? this.headersOverride, "remoteAddress" in options3 ? options3.remoteAddress : this.remoteAddressOverride);
+  }
+  get method() {
+    return this.source.method;
+  }
+  get url() {
+    return this.urlOverride ?? removeHost(this.originalUrl);
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ?? none();
+  }
+  get headers() {
+    return this.headersOverride ??= this.source.headers;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = parseHeader(this.headers.cookie ?? "");
+  }
+  get stream() {
+    const body = this.source.body;
+    switch (body._tag) {
+      case "Empty": {
+        return empty6;
+      }
+      case "Uint8Array": {
+        return succeed3(body.body);
+      }
+      case "Stream": {
+        return mapError3(body.stream, (cause) => requestParseError(this, void 0, cause));
+      }
+      case "FormData": {
+        return streamFromReadable(this, new Response(body.formData).body);
+      }
+      case "Raw": {
+        return rawBodyStream(this, body.body);
+      }
+    }
+  }
+  bytesEffect;
+  get bytes() {
+    if (this.bytesEffect) {
+      return this.bytesEffect;
+    }
+    const body = this.source.body;
+    let effect2;
+    switch (body._tag) {
+      case "Empty": {
+        effect2 = succeed2(new Uint8Array(0));
+        break;
+      }
+      case "Uint8Array": {
+        effect2 = succeed2(body.body);
+        break;
+      }
+      case "FormData": {
+        effect2 = bytesFromBodyInit(this, body.formData);
+        break;
+      }
+      case "Stream": {
+        effect2 = mkUint8Array2(this.stream);
+        break;
+      }
+      case "Raw": {
+        effect2 = rawBodyBytes(this, body.body);
+        break;
+      }
+    }
+    this.bytesEffect = runSync(cached(effect2));
+    return this.bytesEffect;
+  }
+  get text() {
+    return map(this.bytes, (bytes) => textDecoder2.decode(bytes));
+  }
+  get json() {
+    return flatMap(this.text, (text3) => try_2({
+      try: () => text3 === "" ? null : JSON.parse(text3),
+      catch: (cause) => requestParseError(this, void 0, cause)
+    }));
+  }
+  get urlParamsBody() {
+    return flatMap(this.text, (_) => try_2({
+      try: () => fromInput3(new URLSearchParams(_)),
+      catch: (cause) => requestParseError(this, void 0, cause)
+    }));
+  }
+  multipartEffect;
+  get multipart() {
+    if (this.multipartEffect) {
+      return this.multipartEffect;
+    }
+    this.multipartEffect = runSync(cached(toPersisted(this.multipartStream)));
+    return this.multipartEffect;
+  }
+  get multipartStream() {
+    const formData3 = this.source.body._tag === "FormData" && this.source.body.formData;
+    if (formData3) {
+      return fromIterable2(formDataToParts(formData3));
+    }
+    return pipeThroughChannel(mapError3(this.stream, (cause) => MultipartError.fromReason("InternalError", cause)), makeChannel(this.headers));
+  }
+  get arrayBuffer() {
+    return map(
+      this.bytes,
+      // Copy this view because Buffer views may share a larger ArrayBuffer.
+      (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+    );
+  }
+  get upgrade() {
+    return fail3(requestParseError(this, "Not an upgradeable ServerRequest"));
+  }
+};
+var getFormDataBody = (request) => {
+  if (!isHttpClientRequest(request.source)) {
+    return void 0;
+  }
+  const body = request.source.body;
+  if (body._tag === "FormData") {
+    return body.formData;
+  }
+  if (body._tag === "Raw" && isFormData(body.body)) {
+    return body.body;
+  }
+  return void 0;
+};
+var rawBodyStream = (request, body) => {
+  if (body instanceof Request) {
+    return streamFromReadable(request, body.body);
+  }
+  if (isReadableStream3(body)) {
+    return streamFromReadable(request, body);
+  }
+  if (isBodyInit(body)) {
+    return streamFromReadable(request, new Response(body).body);
+  }
+  return fail4(requestParseError(request, "Unsupported body type"));
+};
+var rawBodyBytes = (request, body) => {
+  if (body instanceof Request) {
+    return tryPromise({
+      try: () => body.arrayBuffer().then((buffer2) => new Uint8Array(buffer2)),
+      catch: (cause) => requestParseError(request, void 0, cause)
+    });
+  }
+  if (isBodyInit(body)) {
+    return bytesFromBodyInit(request, body);
+  }
+  return fail3(requestParseError(request, "Unsupported body type"));
+};
+var bytesFromBodyInit = (request, body) => tryPromise({
+  try: () => new Response(body).arrayBuffer().then((buffer2) => new Uint8Array(buffer2)),
+  catch: (cause) => requestParseError(request, void 0, cause)
+});
+var streamFromReadable = (request, body) => body ? fromReadableStream({
+  evaluate: () => body,
+  onError: (cause) => requestParseError(request, void 0, cause)
+}) : empty6;
+var requestParseError = (request, description, cause) => new HttpServerError({
+  reason: new RequestParseError({
+    request,
+    ...description === void 0 ? void 0 : {
+      description
+    },
+    ...cause === void 0 ? void 0 : {
+      cause
+    }
+  })
+});
+var formDataToParts = (formData3) => {
+  const parts = [];
+  for (const [key, value] of formData3.entries()) {
+    parts.push(typeof value === "string" ? new MultipartFieldPart(key, value) : new MultipartFilePart(key, value));
+  }
+  return parts;
+};
+var MultipartFieldPart = class extends Class {
+  [TypeId9];
+  _tag = "Field";
+  contentType = "text/plain";
+  key;
+  value;
+  constructor(key, value) {
+    super();
+    this[TypeId9] = TypeId9;
+    this.key = key;
+    this.value = value;
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "Field",
+      key: this.key,
+      contentType: this.contentType,
+      value: this.value
+    };
+  }
+};
+var MultipartFilePart = class extends Class {
+  [TypeId9];
+  _tag = "File";
+  key;
+  name;
+  contentType;
+  content;
+  contentEffect;
+  constructor(key, file3) {
+    super();
+    this[TypeId9] = TypeId9;
+    this.key = key;
+    this.name = file3.name;
+    this.contentType = file3.type;
+    this.content = fromReadableStream({
+      evaluate: () => file3.stream(),
+      onError: (cause) => MultipartError.fromReason("InternalError", cause)
+    });
+    this.contentEffect = tryPromise({
+      try: () => file3.arrayBuffer().then((buffer2) => new Uint8Array(buffer2)),
+      catch: (cause) => MultipartError.fromReason("InternalError", cause)
+    });
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    };
+  }
+};
+var isReadableStream3 = (u) => typeof ReadableStream !== "undefined" && u instanceof ReadableStream;
+var isFormData = (u) => typeof FormData !== "undefined" && u instanceof FormData;
+var isBodyInit = (u) => typeof u === "string" || typeof ArrayBuffer !== "undefined" && (u instanceof ArrayBuffer || ArrayBuffer.isView(u)) || typeof Blob !== "undefined" && u instanceof Blob || isFormData(u) || typeof URLSearchParams !== "undefined" && u instanceof URLSearchParams || isReadableStream3(u);
+var textDecoder2 = /* @__PURE__ */ new TextDecoder();
+var toURL = (self) => {
+  const host = self.headers.host ?? "localhost";
+  const protocol = self.headers["x-forwarded-proto"] === "https" ? "https" : "http";
+  try {
+    return some(new URL(self.url, `${protocol}://${host}`));
+  } catch {
+    return none();
+  }
+};
+var toWebResult2 = (self, options3) => {
+  if (self.source instanceof Request) {
+    return succeed(self.source);
+  }
+  const url = toURL(self);
+  if (isNone(url)) {
+    return fail(new RequestParseError({
+      request: self,
+      description: "Invalid URL"
+    }));
+  }
+  const requestInit = {
+    method: self.method,
+    headers: self.headers
+  };
+  if (options3?.signal) {
+    requestInit.signal = options3.signal;
+  }
+  if (hasBody(self.method)) {
+    requestInit.body = toReadableStreamWith(self.stream, options3?.context ?? empty2());
+    requestInit.duplex = "half";
+  }
+  return succeed(new Request(url.value, requestInit));
+};
+var toWeb3 = (self, options3) => contextWith((context2) => fromResult(toWebResult2(self, {
+  context: context2,
+  signal: options3?.signal
+})));
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpMiddleware.js
+var loggerDisabledRequests = /* @__PURE__ */ new WeakSet();
+var withLoggerDisabled = (self) => withFiber((fiber) => {
+  const request = getUnsafe(fiber.context, HttpServerRequest);
+  loggerDisabledRequests.add(request.source);
+  return self;
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpRouter.js
+var HttpRouter = /* @__PURE__ */ Service("effect/http/HttpRouter");
+var removeTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var prefixPath = /* @__PURE__ */ dual(2, (self, prefix) => {
+  prefix = removeTrailingSlash(prefix);
+  if (self === "*") return `${prefix}/*`;
+  else if (self === "/") return prefix;
+  return prefix + self;
+});
+var MiddlewareTypeId = "~effect/http/HttpRouter/Middleware";
+var middleware = function() {
+  if (arguments.length === 0) {
+    return makeMiddleware;
+  }
+  return makeMiddleware(arguments[0], arguments[1]);
+};
+var makeMiddleware = (middleware2, options3) => options3?.global ? effectDiscard(gen(function* () {
+  const router = yield* HttpRouter;
+  const fn = isEffect(middleware2) ? yield* middleware2 : middleware2;
+  yield* router.addGlobalMiddleware(fn);
+})) : new MiddlewareImpl(isEffect(middleware2) ? effectContext(map(middleware2, (fn) => makeUnsafe(/* @__PURE__ */ new Map([[fnContextKey, fn]])))) : succeedContext(makeUnsafe(/* @__PURE__ */ new Map([[fnContextKey, middleware2]]))));
+var middlewareId = 0;
+var fnContextKey = "effect/http/HttpRouter/MiddlewareFn";
+var MiddlewareImpl = class _MiddlewareImpl {
+  [MiddlewareTypeId] = {};
+  layerFn;
+  dependencies;
+  constructor(layerFn, dependencies) {
+    this.layerFn = layerFn;
+    this.dependencies = dependencies;
+    const contextKey = `effect/http/HttpRouter/Middleware-${++middlewareId}`;
+    this.layer = effectContext(gen({
+      self: this
+    }, function* () {
+      const context2 = yield* context();
+      const stack = [getOrUndefinedUnsafe(context2, fnContextKey)];
+      if (this.dependencies) {
+        const memoMap = yield* CurrentMemoMap;
+        const scope2 = get(context2, Scope);
+        const depsContext = yield* buildWithMemoMap(this.dependencies, memoMap, scope2);
+        stack.push(...getMiddleware(depsContext));
+      }
+      return makeUnsafe(/* @__PURE__ */ new Map([[contextKey, stack]]));
+    })).pipe(provide2(this.layerFn));
+  }
+  layer;
+  combine(other) {
+    return new _MiddlewareImpl(this.layerFn, this.dependencies ? provideMerge(this.dependencies, other.layer) : other.layer);
+  }
+};
+var middlewareCache = /* @__PURE__ */ new WeakMap();
+var getMiddleware = (context2) => {
+  let arr = middlewareCache.get(context2);
+  if (arr) return arr;
+  const topLevel = empty();
+  let maxLength = 0;
+  for (const [key, value] of context2.mapUnsafe) {
+    if (key.startsWith("effect/http/HttpRouter/Middleware-")) {
+      topLevel.push(value);
+      if (value.length > maxLength) {
+        maxLength = value.length;
+      }
+    }
+  }
+  if (topLevel.length === 0) {
+    arr = [];
+  } else {
+    const middleware2 = /* @__PURE__ */ new Set();
+    for (let i = maxLength - 1; i >= 0; i--) {
+      for (const arr2 of topLevel) {
+        if (i < arr2.length) {
+          middleware2.add(arr2[i]);
+        }
+      }
+    }
+    arr = fromIterable(middleware2).reverse();
+  }
+  middlewareCache.set(context2, arr);
+  return arr;
+};
+var disableLogger = middleware(withLoggerDisabled).layer;
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/HttpStatus.js
+var codeByLiteral = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+  OK: 200,
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableEntity: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HttpVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511
+};
+var fromLiteral = (literal) => codeByLiteral[literal];
+
+export {
+  isHttpBody,
+  uint8Array,
+  text,
+  jsonUnsafe,
+  urlParams,
+  HttpBody_exports,
+  isHttpClientError,
+  HttpClientError,
+  TransportError,
+  StatusCodeError,
+  DecodeError,
+  HttpClientError_exports,
+  hasBody,
+  make2 as make,
+  get4 as get,
+  post,
+  setHeaders,
+  setUrl,
+  prependUrl,
+  appendUrlParams,
+  setBody,
+  bodyFormData,
+  HttpClientRequest_exports,
+  fromWeb2 as fromWeb,
+  HttpTraceContext_exports,
+  HttpClient,
+  transformResponse,
+  filterStatusOk2 as filterStatusOk,
+  make3 as make2,
+  mapRequest,
+  retryTransient,
+  TracerPropagationEnabled,
+  layerMergedContext,
+  HttpClient_exports,
+  HttpServerResponse_exports,
+  HttpServerRequest_exports,
+  prefixPath,
+  fromLiteral
+};