ff-effect 0.0.10 → 0.0.11

package/dist/for/inngest/index.js

@@ -0,0 +1,2987 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Cookies.js
+import * as Duration from "effect/Duration";
+import * as Either from "effect/Either";
+import { dual, identity } from "effect/Function";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Predicate2 from "effect/Predicate";
+import * as Record from "effect/Record";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Error.js
+import * as Data from "effect/Data";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+var TypeId = /* @__PURE__ */ Symbol.for("@effect/platform/Error");
+var TypeIdError = (typeId, tag2) => {
+  class Base extends Data.Error {
+    _tag = tag2;
+  }
+  ;
+  Base.prototype[typeId] = typeId;
+  Base.prototype.name = tag2;
+  return Base;
+};
+var Module = /* @__PURE__ */ Schema.Literal("Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal");
+var BadArgument = class extends (/* @__PURE__ */ Schema.TaggedError("@effect/platform/Error/BadArgument")("BadArgument", {
+  module: Module,
+  method: Schema.String,
+  description: /* @__PURE__ */ Schema.optional(Schema.String),
+  cause: /* @__PURE__ */ Schema.optional(Schema.Defect)
+})) {
+  /**
+   * @since 1.0.0
+   */
+  [TypeId] = TypeId;
+  /**
+   * @since 1.0.0
+   */
+  get message() {
+    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+  }
+};
+var SystemErrorReason = /* @__PURE__ */ Schema.Literal("AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero");
+var SystemError = class extends (/* @__PURE__ */ Schema.TaggedError("@effect/platform/Error/SystemError")("SystemError", {
+  reason: SystemErrorReason,
+  module: Module,
+  method: Schema.String,
+  description: /* @__PURE__ */ Schema.optional(Schema.String),
+  syscall: /* @__PURE__ */ Schema.optional(Schema.String),
+  pathOrDescriptor: /* @__PURE__ */ Schema.optional(/* @__PURE__ */ Schema.Union(Schema.String, Schema.Number)),
+  cause: /* @__PURE__ */ Schema.optional(Schema.Defect)
+})) {
+  /**
+   * @since 1.0.0
+   */
+  [TypeId] = TypeId;
+  /**
+   * @since 1.0.0
+   */
+  get message() {
+    return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== void 0 ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+  }
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Cookies.js
+var TypeId2 = /* @__PURE__ */ Symbol.for("@effect/platform/Cookies");
+var CookieTypeId = /* @__PURE__ */ Symbol.for("@effect/platform/Cookies/Cookie");
+var Proto = {
+  [TypeId2]: TypeId2,
+  ...Inspectable.BaseProto,
+  toJSON() {
+    return {
+      _id: "@effect/platform/Cookies",
+      cookies: Record.map(this.cookies, (cookie) => cookie.toJSON())
+    };
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var fromReadonlyRecord = (cookies) => {
+  const self = Object.create(Proto);
+  self.cookies = cookies;
+  return self;
+};
+var fromIterable = (cookies) => {
+  const record = {};
+  for (const cookie of cookies) {
+    record[cookie.name] = cookie;
+  }
+  return fromReadonlyRecord(record);
+};
+var fromSetCookie = (headers) => {
+  const arrayHeaders = typeof headers === "string" ? [headers] : headers;
+  const cookies = [];
+  for (const header of arrayHeaders) {
+    const cookie = parseSetCookie(header.trim());
+    if (Option.isSome(cookie)) {
+      cookies.push(cookie.value);
+    }
+  }
+  return fromIterable(cookies);
+};
+function parseSetCookie(header) {
+  const parts = header.split(";").map((_) => _.trim()).filter((_) => _ !== "");
+  if (parts.length === 0) {
+    return Option.none();
+  }
+  const firstEqual = parts[0].indexOf("=");
+  if (firstEqual === -1) {
+    return Option.none();
+  }
+  const name = parts[0].slice(0, firstEqual);
+  if (!fieldContentRegExp.test(name)) {
+    return Option.none();
+  }
+  const valueEncoded = parts[0].slice(firstEqual + 1);
+  const value = tryDecodeURIComponent(valueEncoded);
+  if (parts.length === 1) {
+    return Option.some(Object.assign(Object.create(CookieProto), {
+      name,
+      value,
+      valueEncoded
+    }));
+  }
+  const options = {};
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    const equalIndex = part.indexOf("=");
+    const key = equalIndex === -1 ? part : part.slice(0, equalIndex).trim();
+    const value2 = equalIndex === -1 ? void 0 : part.slice(equalIndex + 1).trim();
+    switch (key.toLowerCase()) {
+      case "domain": {
+        if (value2 === void 0) {
+          break;
+        }
+        const domain = value2.trim().replace(/^\./, "");
+        if (domain) {
+          options.domain = domain;
+        }
+        break;
+      }
+      case "expires": {
+        if (value2 === void 0) {
+          break;
+        }
+        const date = new Date(value2);
+        if (!isNaN(date.getTime())) {
+          options.expires = date;
+        }
+        break;
+      }
+      case "max-age": {
+        if (value2 === void 0) {
+          break;
+        }
+        const maxAge = parseInt(value2, 10);
+        if (!isNaN(maxAge)) {
+          options.maxAge = Duration.seconds(maxAge);
+        }
+        break;
+      }
+      case "path": {
+        if (value2 === void 0) {
+          break;
+        }
+        if (value2[0] === "/") {
+          options.path = value2;
+        }
+        break;
+      }
+      case "priority": {
+        if (value2 === void 0) {
+          break;
+        }
+        switch (value2.toLowerCase()) {
+          case "low":
+            options.priority = "low";
+            break;
+          case "medium":
+            options.priority = "medium";
+            break;
+          case "high":
+            options.priority = "high";
+            break;
+        }
+        break;
+      }
+      case "httponly": {
+        options.httpOnly = true;
+        break;
+      }
+      case "secure": {
+        options.secure = true;
+        break;
+      }
+      case "partitioned": {
+        options.partitioned = true;
+        break;
+      }
+      case "samesite": {
+        if (value2 === void 0) {
+          break;
+        }
+        switch (value2.toLowerCase()) {
+          case "lax":
+            options.sameSite = "lax";
+            break;
+          case "strict":
+            options.sameSite = "strict";
+            break;
+          case "none":
+            options.sameSite = "none";
+            break;
+        }
+        break;
+      }
+    }
+  }
+  return Option.some(Object.assign(Object.create(CookieProto), {
+    name,
+    value,
+    valueEncoded,
+    options: Object.keys(options).length > 0 ? options : void 0
+  }));
+}
+var empty = /* @__PURE__ */ fromIterable([]);
+var isEmpty = (self) => Record.isEmptyRecord(self.cookies);
+var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+var CookieProto = {
+  [CookieTypeId]: CookieTypeId,
+  ...Inspectable.BaseProto,
+  toJSON() {
+    return {
+      _id: "@effect/platform/Cookies/Cookie",
+      name: this.name,
+      value: this.value,
+      options: this.options
+    };
+  }
+};
+function serializeCookie(self) {
+  let str = self.name + "=" + self.valueEncoded;
+  if (self.options === void 0) {
+    return str;
+  }
+  const options = self.options;
+  if (options.maxAge !== void 0) {
+    const maxAge = Duration.toSeconds(options.maxAge);
+    str += "; Max-Age=" + Math.trunc(maxAge);
+  }
+  if (options.domain !== void 0) {
+    str += "; Domain=" + options.domain;
+  }
+  if (options.path !== void 0) {
+    str += "; Path=" + options.path;
+  }
+  if (options.priority !== void 0) {
+    switch (options.priority) {
+      case "low":
+        str += "; Priority=Low";
+        break;
+      case "medium":
+        str += "; Priority=Medium";
+        break;
+      case "high":
+        str += "; Priority=High";
+        break;
+    }
+  }
+  if (options.expires !== void 0) {
+    str += "; Expires=" + options.expires.toUTCString();
+  }
+  if (options.httpOnly) {
+    str += "; HttpOnly";
+  }
+  if (options.secure) {
+    str += "; Secure";
+  }
+  if (options.partitioned) {
+    str += "; Partitioned";
+  }
+  if (options.sameSite !== void 0) {
+    switch (options.sameSite) {
+      case "lax":
+        str += "; SameSite=Lax";
+        break;
+      case "strict":
+        str += "; SameSite=Strict";
+        break;
+      case "none":
+        str += "; SameSite=None";
+        break;
+    }
+  }
+  return str;
+}
+var toSetCookieHeaders = (self) => Object.values(self.cookies).map(serializeCookie);
+function parseHeader(header) {
+  const result = {};
+  const strLen = header.length;
+  let pos = 0;
+  let terminatorPos = 0;
+  while (true) {
+    if (terminatorPos === strLen) break;
+    terminatorPos = header.indexOf(";", pos);
+    if (terminatorPos === -1) terminatorPos = strLen;
+    let eqIdx = header.indexOf("=", pos);
+    if (eqIdx === -1) break;
+    if (eqIdx > terminatorPos) {
+      pos = terminatorPos + 1;
+      continue;
+    }
+    const key = header.substring(pos, eqIdx++).trim();
+    if (result[key] === void 0) {
+      const val = header.charCodeAt(eqIdx) === 34 ? header.substring(eqIdx + 1, terminatorPos - 1).trim() : header.substring(eqIdx, terminatorPos).trim();
+      result[key] = !(val.indexOf("%") === -1) ? tryDecodeURIComponent(val) : val;
+    }
+    pos = terminatorPos + 1;
+  }
+  return result;
+}
+var tryDecodeURIComponent = (str) => {
+  try {
+    return decodeURIComponent(str);
+  } catch {
+    return str;
+  }
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Headers.js
+import * as FiberRef from "effect/FiberRef";
+import * as FiberRefs from "effect/FiberRefs";
+import { dual as dual2, identity as identity2 } from "effect/Function";
+import { globalValue } from "effect/GlobalValue";
+import { symbolRedactable } from "effect/Inspectable";
+import * as Predicate3 from "effect/Predicate";
+import * as Record2 from "effect/Record";
+import * as Redacted from "effect/Redacted";
+import * as Schema2 from "effect/Schema";
+import * as String4 from "effect/String";
+var HeadersTypeId = /* @__PURE__ */ Symbol.for("@effect/platform/Headers");
+var Proto2 = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
+  [HeadersTypeId]: HeadersTypeId,
+  [symbolRedactable](fiberRefs) {
+    return redact(this, FiberRefs.getOrDefault(fiberRefs, currentRedactedNames));
+  }
+});
+var make2 = (input) => Object.assign(Object.create(Proto2), input);
+var empty2 = /* @__PURE__ */ Object.create(Proto2);
+var fromInput = (input) => {
+  if (input === void 0) {
+    return empty2;
+  } else if (Symbol.iterator in input) {
+    const out2 = Object.create(Proto2);
+    for (const [k, v] of input) {
+      out2[k.toLowerCase()] = v;
+    }
+    return out2;
+  }
+  const out = Object.create(Proto2);
+  for (const [k, v] of Object.entries(input)) {
+    if (Array.isArray(v)) {
+      out[k.toLowerCase()] = v.join(", ");
+    } else if (v !== void 0) {
+      out[k.toLowerCase()] = v;
+    }
+  }
+  return out;
+};
+var remove2 = /* @__PURE__ */ dual2(2, (self, key) => {
+  const out = make2(self);
+  const modify = (key2) => {
+    if (typeof key2 === "string") {
+      const k = key2.toLowerCase();
+      if (k in self) {
+        delete out[k];
+      }
+    } else {
+      for (const name in self) {
+        if (key2.test(name)) {
+          delete out[name];
+        }
+      }
+    }
+  };
+  if (Array.isArray(key)) {
+    for (let i = 0; i < key.length; i++) {
+      modify(key[i]);
+    }
+  } else {
+    modify(key);
+  }
+  return out;
+});
+var redact = /* @__PURE__ */ dual2(2, (self, key) => {
+  const out = {
+    ...self
+  };
+  const modify = (key2) => {
+    if (typeof key2 === "string") {
+      const k = key2.toLowerCase();
+      if (k in self) {
+        out[k] = Redacted.make(self[k]);
+      }
+    } else {
+      for (const name in self) {
+        if (key2.test(name)) {
+          out[name] = Redacted.make(self[name]);
+        }
+      }
+    }
+  };
+  if (Array.isArray(key)) {
+    for (let i = 0; i < key.length; i++) {
+      modify(key[i]);
+    }
+  } else {
+    modify(key);
+  }
+  return out;
+});
+var currentRedactedNames = /* @__PURE__ */ globalValue("@effect/platform/Headers/currentRedactedNames", () => FiberRef.unsafeMake(["authorization", "cookie", "set-cookie", "x-api-key"]));
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpIncomingMessage.js
+import * as Context2 from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import { dual as dual4 } from "effect/Function";
+import * as Inspectable2 from "effect/Inspectable";
+import * as Option4 from "effect/Option";
+import * as Schema4 from "effect/Schema";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/FileSystem.js
+import * as Brand from "effect/Brand";
+import * as Context from "effect/Context";
+import * as Data2 from "effect/Data";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/fileSystem.js
+import * as Channel from "effect/Channel";
+import * as Chunk from "effect/Chunk";
+import { GenericTag } from "effect/Context";
+import * as Effect from "effect/Effect";
+import { identity as identity3, pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option2 from "effect/Option";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+var tag = /* @__PURE__ */ GenericTag("@effect/platform/FileSystem");
+var Size = (bytes) => typeof bytes === "bigint" ? bytes : BigInt(bytes);
+var bigint1024 = /* @__PURE__ */ BigInt(1024);
+var bigintPiB = bigint1024 * bigint1024 * bigint1024 * bigint1024 * bigint1024;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/FileSystem.js
+var Size2 = Size;
+var FileSystem = tag;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/UrlParams.js
+import * as Arr from "effect/Array";
+import * as Either2 from "effect/Either";
+import { dual as dual3 } from "effect/Function";
+import * as Option3 from "effect/Option";
+import * as Schema3 from "effect/Schema";
+var fromInput2 = (input) => {
+  const parsed = fromInputNested(input);
+  const out = [];
+  for (let i = 0; i < parsed.length; i++) {
+    if (Array.isArray(parsed[i][0])) {
+      const [keys, value] = parsed[i];
+      out.push([`${keys[0]}[${keys.slice(1).join("][")}]`, value]);
+    } else {
+      out.push(parsed[i]);
+    }
+  }
+  return out;
+};
+var fromInputNested = (input) => {
+  const entries = Symbol.iterator in input ? Arr.fromIterable(input) : Object.entries(input);
+  const out = [];
+  for (const [key, value] of entries) {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (value[i] !== void 0) {
+          out.push([key, String(value[i])]);
+        }
+      }
+    } else if (typeof value === "object") {
+      const nested = fromInputNested(value);
+      for (const [k, v] of nested) {
+        out.push([[key, ...typeof k === "string" ? [k] : k], v]);
+      }
+    } else if (value !== void 0) {
+      out.push([key, String(value)]);
+    }
+  }
+  return out;
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpIncomingMessage.js
+var TypeId3 = /* @__PURE__ */ Symbol.for("@effect/platform/HttpIncomingMessage");
+var MaxBodySize = class extends (/* @__PURE__ */ Context2.Reference()("@effect/platform/HttpIncomingMessage/MaxBodySize", {
+  defaultValue: Option4.none
+})) {
+};
+var inspect = (self, that) => {
+  const contentType = self.headers["content-type"] ?? "";
+  let body;
+  if (contentType.includes("application/json")) {
+    try {
+      body = Effect2.runSync(self.json);
+    } catch {
+    }
+  } else if (contentType.includes("text/") || contentType.includes("urlencoded")) {
+    try {
+      body = Effect2.runSync(self.text);
+    } catch {
+    }
+  }
+  const obj = {
+    ...that,
+    headers: Inspectable2.redact(self.headers),
+    remoteAddress: self.remoteAddress.toJSON()
+  };
+  if (body !== void 0) {
+    obj.body = body;
+  }
+  return obj;
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpTraceContext.js
+import * as Option5 from "effect/Option";
+import * as Tracer from "effect/Tracer";
+var fromHeaders = (headers) => {
+  let span = w3c(headers);
+  if (span._tag === "Some") {
+    return span;
+  }
+  span = b3(headers);
+  if (span._tag === "Some") {
+    return span;
+  }
+  return xb3(headers);
+};
+var b3 = (headers) => {
+  if (!("b3" in headers)) {
+    return Option5.none();
+  }
+  const parts = headers["b3"].split("-");
+  if (parts.length < 2) {
+    return Option5.none();
+  }
+  return Option5.some(Tracer.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 Option5.none();
+  }
+  return Option5.some(Tracer.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 Option5.none();
+  }
+  const parts = headers["traceparent"].split("-");
+  if (parts.length !== 4) {
+    return Option5.none();
+  }
+  const [version, traceId, spanId, flags] = parts;
+  switch (version) {
+    case "00": {
+      if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false) {
+        return Option5.none();
+      }
+      return Option5.some(Tracer.externalSpan({
+        traceId,
+        spanId,
+        sampled: (parseInt(flags, 16) & 1) === 1
+      }));
+    }
+    default: {
+      return Option5.none();
+    }
+  }
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpBody.js
+import * as Data3 from "effect/Data";
+import * as Effect3 from "effect/Effect";
+import { identity as identity4 } from "effect/Function";
+import * as Inspectable3 from "effect/Inspectable";
+import * as Schema5 from "effect/Schema";
+import * as Stream_ from "effect/Stream";
+var TypeId4 = /* @__PURE__ */ Symbol.for("@effect/platform/HttpBody");
+var BodyBase = class {
+  [TypeId4];
+  constructor() {
+    this[TypeId4] = TypeId4;
+  }
+  [Inspectable3.NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  toString() {
+    return Inspectable3.format(this);
+  }
+};
+var EmptyImpl = class extends BodyBase {
+  _tag = "Empty";
+  toJSON() {
+    return {
+      _id: "@effect/platform/HttpBody",
+      _tag: "Empty"
+    };
+  }
+};
+var empty3 = /* @__PURE__ */ new EmptyImpl();
+var StreamImpl = class extends BodyBase {
+  stream;
+  contentType;
+  contentLength;
+  _tag = "Stream";
+  constructor(stream4, contentType, contentLength) {
+    super();
+    this.stream = stream4;
+    this.contentType = contentType;
+    this.contentLength = contentLength;
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/HttpBody",
+      _tag: "Stream",
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    };
+  }
+};
+var stream = (body, contentType, contentLength) => new StreamImpl(body, contentType ?? "application/octet-stream", contentLength);
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpApp.js
+var HttpApp_exports = {};
+__export(HttpApp_exports, {
+  appendPreResponseHandler: () => appendPreResponseHandler2,
+  currentPreResponseHandlers: () => currentPreResponseHandlers2,
+  ejectDefaultScopeClose: () => ejectDefaultScopeClose,
+  fromWebHandler: () => fromWebHandler,
+  toHandled: () => toHandled,
+  toWebHandler: () => toWebHandler,
+  toWebHandlerLayer: () => toWebHandlerLayer,
+  toWebHandlerLayerWith: () => toWebHandlerLayerWith,
+  toWebHandlerRuntime: () => toWebHandlerRuntime,
+  unsafeEjectStreamScope: () => unsafeEjectStreamScope,
+  withPreResponseHandler: () => withPreResponseHandler2
+});
+import * as Cause3 from "effect/Cause";
+import * as Context7 from "effect/Context";
+import * as Effect13 from "effect/Effect";
+import * as Exit2 from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Layer4 from "effect/Layer";
+import * as Option12 from "effect/Option";
+import * as Runtime3 from "effect/Runtime";
+import * as Scope from "effect/Scope";
+import * as Stream7 from "effect/Stream";
+import { unify } from "effect/Unify";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpBody.js
+import * as Predicate4 from "effect/Predicate";
+var stream2 = stream;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerRespondable.js
+import * as Cause from "effect/Cause";
+import * as Effect5 from "effect/Effect";
+import * as ParseResult from "effect/ParseResult";
+import { hasProperty as hasProperty5 } from "effect/Predicate";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerResponse.js
+import * as Stream3 from "effect/Stream";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpServerResponse.js
+import * as Context3 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import * as Effectable from "effect/Effectable";
+import { dual as dual5 } from "effect/Function";
+import * as Inspectable4 from "effect/Inspectable";
+import * as Runtime from "effect/Runtime";
+import * as Stream2 from "effect/Stream";
+var TypeId5 = /* @__PURE__ */ Symbol.for("@effect/platform/HttpServerResponse");
+var respondableSymbol = /* @__PURE__ */ Symbol.for("@effect/platform/HttpServerRespondable");
+var ServerResponseImpl = class extends Effectable.StructuralClass {
+  status;
+  statusText;
+  cookies;
+  body;
+  [TypeId5];
+  headers;
+  constructor(status, statusText, headers, cookies, body) {
+    super();
+    this.status = status;
+    this.statusText = statusText;
+    this.cookies = cookies;
+    this.body = body;
+    this[TypeId5] = TypeId5;
+    if (body.contentType || body.contentLength) {
+      const newHeaders = {
+        ...headers
+      };
+      if (body.contentType) {
+        newHeaders["content-type"] = body.contentType;
+      }
+      if (body.contentLength) {
+        newHeaders["content-length"] = body.contentLength.toString();
+      }
+      this.headers = newHeaders;
+    } else {
+      this.headers = headers;
+    }
+  }
+  commit() {
+    return Effect4.succeed(this);
+  }
+  [respondableSymbol]() {
+    return Effect4.succeed(this);
+  }
+  [Inspectable4.NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  toString() {
+    return Inspectable4.format(this);
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/HttpServerResponse",
+      status: this.status,
+      statusText: this.statusText,
+      headers: Inspectable4.redact(this.headers),
+      cookies: this.cookies.toJSON(),
+      body: this.body.toJSON()
+    };
+  }
+};
+var isServerResponse = (u) => typeof u === "object" && u !== null && TypeId5 in u;
+var empty4 = (options) => new ServerResponseImpl(options?.status ?? 204, options?.statusText, options?.headers ? fromInput(options.headers) : empty2, options?.cookies ?? empty, empty3);
+var setBody = /* @__PURE__ */ dual5(2, (self, body) => {
+  let headers = self.headers;
+  if (body._tag === "Empty") {
+    headers = remove2(remove2(headers, "Content-Type"), "Content-length");
+  }
+  return new ServerResponseImpl(self.status, self.statusText, headers, self.cookies, body);
+});
+var toWeb = (response, options) => {
+  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);
+    }
+  }
+  if (options?.withoutBody) {
+    return new Response(void 0, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  const body = response.body;
+  switch (body._tag) {
+    case "Empty": {
+      return new Response(void 0, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    case "Uint8Array":
+    case "Raw": {
+      if (body.body instanceof Response) {
+        for (const [key, value] of headers) {
+          body.body.headers.set(key, value);
+        }
+        return body.body;
+      }
+      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(Stream2.toReadableStreamRuntime(body.stream, options?.runtime ?? Runtime.defaultRuntime), {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+  }
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerResponse.js
+var isServerResponse2 = isServerResponse;
+var empty5 = empty4;
+var setBody2 = setBody;
+var toWeb2 = toWeb;
+var fromWeb = (response) => {
+  const headers = new globalThis.Headers(response.headers);
+  const setCookieHeaders = headers.getSetCookie();
+  headers.delete("set-cookie");
+  let self = empty5({
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+    cookies: fromSetCookie(setCookieHeaders)
+  });
+  if (response.body) {
+    const contentType = headers.get("content-type");
+    self = setBody2(self, stream2(Stream3.fromReadableStream({
+      evaluate: () => response.body,
+      onError: (e) => e
+    }), contentType ?? void 0));
+  }
+  return self;
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerRespondable.js
+var symbol = /* @__PURE__ */ Symbol.for("@effect/platform/HttpServerRespondable");
+var isRespondable = (u) => hasProperty5(u, symbol);
+var badRequest = /* @__PURE__ */ empty5({
+  status: 400
+});
+var notFound = /* @__PURE__ */ empty5({
+  status: 404
+});
+var toResponseOrElse = (u, orElse) => {
+  if (isServerResponse2(u)) {
+    return Effect5.succeed(u);
+  } else if (isRespondable(u)) {
+    return Effect5.catchAllCause(u[symbol](), () => Effect5.succeed(orElse));
+  } else if (ParseResult.isParseError(u)) {
+    return Effect5.succeed(badRequest);
+  } else if (Cause.isNoSuchElementException(u)) {
+    return Effect5.succeed(notFound);
+  }
+  return Effect5.succeed(orElse);
+};
+var toResponseOrElseDefect = (u, orElse) => {
+  if (isServerResponse2(u)) {
+    return Effect5.succeed(u);
+  } else if (isRespondable(u)) {
+    return Effect5.catchAllCause(u[symbol](), () => Effect5.succeed(orElse));
+  }
+  return Effect5.succeed(orElse);
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpServerError.js
+import * as Cause2 from "effect/Cause";
+import * as Effect6 from "effect/Effect";
+import * as FiberId from "effect/FiberId";
+import { globalValue as globalValue2 } from "effect/GlobalValue";
+import * as Option6 from "effect/Option";
+import * as Predicate5 from "effect/Predicate";
+var TypeId6 = /* @__PURE__ */ Symbol.for("@effect/platform/HttpServerError");
+var clientAbortFiberId = /* @__PURE__ */ globalValue2("@effect/platform/HttpServerError/clientAbortFiberId", () => FiberId.runtime(-499, 0));
+var causeResponse = (cause) => {
+  const [effect, stripped] = Cause2.reduce(cause, [Effect6.succeed(internalServerError), Cause2.empty], (acc, cause2) => {
+    const withoutInterrupt = Cause2.isInterruptType(acc[1]) ? Cause2.empty : acc[1];
+    switch (cause2._tag) {
+      case "Fail": {
+        return Option6.some([toResponseOrElse(cause2.error, internalServerError), combineCauses(withoutInterrupt, cause2)]);
+      }
+      case "Die": {
+        const isResponse = isServerResponse(cause2.defect);
+        return Option6.some([toResponseOrElseDefect(cause2.defect, internalServerError), isResponse ? withoutInterrupt : combineCauses(withoutInterrupt, cause2)]);
+      }
+      case "Interrupt": {
+        if (acc[1]._tag !== "Empty") {
+          return Option6.none();
+        }
+        const response = cause2.fiberId === clientAbortFiberId ? clientAbortError : serverAbortError;
+        return Option6.some([Effect6.succeed(response), cause2]);
+      }
+      default: {
+        return Option6.none();
+      }
+    }
+  });
+  return Effect6.map(effect, (response) => {
+    if (Cause2.isEmptyType(stripped)) {
+      return [response, Cause2.empty];
+    }
+    return [response, Cause2.sequential(stripped, Cause2.die(response))];
+  });
+};
+var combineCauses = (left4, right4) => {
+  if (Cause2.isEmptyType(left4)) {
+    return right4;
+  } else if (Cause2.isEmptyType(right4)) {
+    return left4;
+  }
+  return Cause2.sequential(left4, right4);
+};
+var causeResponseStripped = (cause) => {
+  let response;
+  const stripped = Cause2.stripSomeDefects(cause, (defect) => {
+    if (isServerResponse(defect)) {
+      response = defect;
+      return Option6.some(Cause2.empty);
+    }
+    return Option6.none();
+  });
+  return [response ?? internalServerError, stripped];
+};
+var internalServerError = /* @__PURE__ */ empty4({
+  status: 500
+});
+var clientAbortError = /* @__PURE__ */ empty4({
+  status: 499
+});
+var serverAbortError = /* @__PURE__ */ empty4({
+  status: 503
+});
+var exitResponse = (exit2) => {
+  if (exit2._tag === "Success") {
+    return exit2.value;
+  }
+  return causeResponseStripped(exit2.cause)[0];
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerError.js
+var TypeId7 = TypeId6;
+var RequestError = class extends (/* @__PURE__ */ TypeIdError(TypeId7, "RequestError")) {
+  /**
+   * @since 1.0.0
+   */
+  [symbol]() {
+    return empty5({
+      status: 400
+    });
+  }
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    return this.description ? `${this.reason}: ${this.description} (${this.methodAndUrl})` : `${this.reason} error (${this.methodAndUrl})`;
+  }
+};
+var RouteNotFound = class extends (/* @__PURE__ */ TypeIdError(TypeId7, "RouteNotFound")) {
+  constructor(options) {
+    super(options);
+    this.stack = `${this.name}: ${this.message}`;
+  }
+  /**
+   * @since 1.0.0
+   */
+  [symbol]() {
+    return empty5({
+      status: 404
+    });
+  }
+  get message() {
+    return `${this.request.method} ${this.request.url} not found`;
+  }
+};
+var ResponseError = class extends (/* @__PURE__ */ TypeIdError(TypeId7, "ResponseError")) {
+  /**
+   * @since 1.0.0
+   */
+  [symbol]() {
+    return empty5({
+      status: 500
+    });
+  }
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return this.description ? `${this.description} (${info})` : `${this.reason} error (${info})`;
+  }
+};
+var clientAbortFiberId2 = clientAbortFiberId;
+var causeResponse2 = causeResponse;
+var exitResponse2 = exitResponse;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerRequest.js
+import * as Effect10 from "effect/Effect";
+import * as Either3 from "effect/Either";
+import * as Option9 from "effect/Option";
+import * as Runtime2 from "effect/Runtime";
+import * as Stream6 from "effect/Stream";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpMethod.js
+var hasBody = (method) => method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpServerRequest.js
+import * as Channel3 from "effect/Channel";
+import * as Context5 from "effect/Context";
+import * as Effect9 from "effect/Effect";
+import * as Inspectable6 from "effect/Inspectable";
+import * as Option8 from "effect/Option";
+import * as Schema7 from "effect/Schema";
+import * as Stream5 from "effect/Stream";
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Multipart.js
+import * as Channel2 from "effect/Channel";
+import * as Chunk2 from "effect/Chunk";
+import * as Context4 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { constant, dual as dual6 } from "effect/Function";
+import * as Inspectable5 from "effect/Inspectable";
+import * as Mailbox from "effect/Mailbox";
+import * as Option7 from "effect/Option";
+import * as Predicate6 from "effect/Predicate";
+import * as Schema6 from "effect/Schema";
+import * as Stream4 from "effect/Stream";
+
+// ../../node_modules/.bun/multipasta@0.2.7/node_modules/multipasta/dist/esm/internal/contentType.js
+var paramRE = /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\v\u0020-\u00ff])*"|[!#$%&'*+.^\w`|~-]+) */gu;
+var quotedPairRE = /\\([\v\u0020-\u00ff])/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 match3;
+  let value;
+  paramRE.lastIndex = index;
+  while (match3 = paramRE.exec(header)) {
+    if (match3.index !== index) {
+      return defaultContentType;
+    }
+    index += match3[0].length;
+    key = match3[1].toLowerCase();
+    value = match3[2];
+    if (value[0] === '"') {
+      value = value.slice(1, value.length - 1);
+      !withoutSlash && quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1"));
+    }
+    result.parameters[key] = value;
+  }
+  if (index !== header.length) {
+    return defaultContentType;
+  }
+  return result;
+}
+
+// ../../node_modules/.bun/multipasta@0.2.7/node_modules/multipasta/dist/esm/internal/headers.js
+var constMaxPairs = 100;
+var constMaxSize = 16 * 1024;
+var State;
+(function(State3) {
+  State3[State3["key"] = 0] = "key";
+  State3[State3["whitespace"] = 1] = "whitespace";
+  State3[State3["value"] = 2] = "value";
+})(State || (State = {}));
+var constContinue = {
+  _tag: "Continue"
+};
+var constNameChars = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1];
+var constValueChars = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+function make4() {
+  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 write3(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/multipasta@0.2.7/node_modules/multipasta/dist/esm/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 make5(needle, callback, seed) {
+  const state = makeState(needle);
+  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 write3(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;
+    }
+    if (chunkLength < state.needleLength) {
+      state.previousChunk = chunk;
+      state.previousChunkLength = chunkLength;
+      return;
+    }
+    let pos = 0;
+    while (pos < chunkLength) {
+      const match3 = indexOf(chunk, state.needle, pos);
+      if (match3 > -1) {
+        if (match3 > pos) {
+          callback(state.matchIndex, chunk.subarray(pos, match3));
+        }
+        state.matchIndex += 1;
+        pos = match3 + 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) {
+            callback(state.matchIndex, chunk);
+          } else {
+            callback(state.matchIndex, chunk.subarray(pos));
+          }
+        } else {
+          if (chunkLength - 1 - earliestIndex > pos) {
+            callback(state.matchIndex, chunk.subarray(pos, chunkLength - 1 - earliestIndex));
+          }
+          state.previousChunk = chunk.subarray(chunkLength - 1 - earliestIndex);
+          state.previousChunkLength = earliestIndex + 1;
+        }
+      } else if (pos === 0) {
+        callback(state.matchIndex, chunk);
+      } else {
+        callback(state.matchIndex, chunk.subarray(pos));
+      }
+      break;
+    }
+  }
+  function end() {
+    if (state.previousChunk !== void 0 && state.previousChunk !== seed) {
+      callback(state.matchIndex, state.previousChunk);
+    }
+    state.previousChunk = seed;
+    state.previousChunkLength = seed?.length ?? 0;
+    state.matchIndex = 0;
+  }
+  return {
+    write: write3,
+    end
+  };
+}
+
+// ../../node_modules/.bun/multipasta@0.2.7/node_modules/multipasta/dist/esm/internal/multipart.js
+var State2;
+(function(State3) {
+  State3[State3["headers"] = 0] = "headers";
+  State3[State3["body"] = 1] = "body";
+})(State2 || (State2 = {}));
+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) {
+}
+function make6({
+  headers,
+  onFile: onPart,
+  onField,
+  onError,
+  onDone,
+  isFile = defaultIsFile,
+  maxParts = Infinity,
+  maxTotalSize = Infinity,
+  maxPartSize = Infinity,
+  maxFieldSize = 1024 * 1024
+}) {
+  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
+  };
+  function skipBody() {
+    state.state = State2.body;
+    state.isFile = true;
+    state.onChunk = noopOnChunk;
+  }
+  const headerParser = make4();
+  const split = make5(`\r
+--${boundary}`, function(index, chunk) {
+    if (index === 0) {
+      skipBody();
+      return;
+    } else if (index !== state.index) {
+      if (state.index > 0) {
+        if (state.isFile) {
+          state.onChunk(null);
+          state.partSize = 0;
+        } 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.state = State2.headers;
+      state.index = index;
+      state.headerSkip = 2;
+      if (chunk[0] === 45 && chunk[1] === 45) {
+        return onDone();
+      }
+      state.parts++;
+      if (state.parts > maxParts) {
+        onError(errMaxParts);
+      }
+    }
+    if ((state.partSize += chunk.length) > maxPartSize) {
+      onError(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) {
+          encodedFilename = decodeURIComponent(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) {
+            onError(errMaxFieldSize);
+          }
+          state.fieldChunks.push(buf);
+        }
+      }
+    } else if (state.isFile) {
+      state.onChunk(chunk);
+    } else {
+      if ((state.fieldSize += chunk.length) > maxFieldSize) {
+        onError(errMaxFieldSize);
+      }
+      state.fieldChunks.push(chunk);
+    }
+  }, constCR);
+  return {
+    write(chunk) {
+      if ((state.totalSize += chunk.length) > maxTotalSize) {
+        return onError(errMaxTotalSize);
+      }
+      return split.write(chunk);
+    },
+    end() {
+      split.end();
+      if (state.state === State2.body) {
+        onError(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;
+    }
+  };
+}
+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/multipasta@0.2.7/node_modules/multipasta/dist/esm/index.js
+var make7 = make6;
+var defaultIsFile2 = defaultIsFile;
+var decodeField2 = decodeField;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/path.js
+import { GenericTag as GenericTag3 } from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import { identity as identity5 } from "effect/Function";
+import * as Layer2 from "effect/Layer";
+var TypeId8 = /* @__PURE__ */ Symbol.for("@effect/platform/Path");
+var Path = /* @__PURE__ */ GenericTag3("@effect/platform/Path");
+function normalizeStringPosix(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === 47) {
+      break;
+    } else {
+      code = 47;
+    }
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = "";
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += "/" + path.slice(lastSlash + 1, i);
+        } else {
+          res = path.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  const dir = pathObject.dir || pathObject.root;
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+function fromFileUrl(url) {
+  if (url.protocol !== "file:") {
+    return Effect7.fail(new BadArgument({
+      module: "Path",
+      method: "fromFileUrl",
+      description: "URL must be of scheme file"
+    }));
+  } else if (url.hostname !== "") {
+    return Effect7.fail(new BadArgument({
+      module: "Path",
+      method: "fromFileUrl",
+      description: "Invalid file URL host"
+    }));
+  }
+  const pathname = url.pathname;
+  for (let n = 0; n < pathname.length; n++) {
+    if (pathname[n] === "%") {
+      const third = pathname.codePointAt(n + 2) | 32;
+      if (pathname[n + 1] === "2" && third === 102) {
+        return Effect7.fail(new BadArgument({
+          module: "Path",
+          method: "fromFileUrl",
+          description: "must not include encoded / characters"
+        }));
+      }
+    }
+  }
+  return Effect7.succeed(decodeURIComponent(pathname));
+}
+var resolve = function resolve2() {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  let cwd = void 0;
+  for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path;
+    if (i >= 0) {
+      path = arguments[i];
+    } else {
+      const process = globalThis.process;
+      if (cwd === void 0 && "process" in globalThis && typeof process === "object" && process !== null && typeof process.cwd === "function") {
+        cwd = process.cwd();
+      }
+      path = cwd;
+    }
+    if (path.length === 0) {
+      continue;
+    }
+    resolvedPath = path + "/" + resolvedPath;
+    resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0) {
+      return "/" + resolvedPath;
+    } else {
+      return "/";
+    }
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  } else {
+    return ".";
+  }
+};
+var CHAR_FORWARD_SLASH = 47;
+function toFileUrl(filepath) {
+  const outURL = new URL("file://");
+  let resolved = resolve(filepath);
+  const filePathLast = filepath.charCodeAt(filepath.length - 1);
+  if (filePathLast === CHAR_FORWARD_SLASH && resolved[resolved.length - 1] !== "/") {
+    resolved += "/";
+  }
+  outURL.pathname = encodePathChars(resolved);
+  return Effect7.succeed(outURL);
+}
+var percentRegEx = /%/g;
+var backslashRegEx = /\\/g;
+var newlineRegEx = /\n/g;
+var carriageReturnRegEx = /\r/g;
+var tabRegEx = /\t/g;
+function encodePathChars(filepath) {
+  if (filepath.includes("%")) {
+    filepath = filepath.replace(percentRegEx, "%25");
+  }
+  if (filepath.includes("\\")) {
+    filepath = filepath.replace(backslashRegEx, "%5C");
+  }
+  if (filepath.includes("\n")) {
+    filepath = filepath.replace(newlineRegEx, "%0A");
+  }
+  if (filepath.includes("\r")) {
+    filepath = filepath.replace(carriageReturnRegEx, "%0D");
+  }
+  if (filepath.includes("	")) {
+    filepath = filepath.replace(tabRegEx, "%09");
+  }
+  return filepath;
+}
+var posixImpl = /* @__PURE__ */ Path.of({
+  [TypeId8]: TypeId8,
+  resolve,
+  normalize(path) {
+    if (path.length === 0) return ".";
+    const isAbsolute = path.charCodeAt(0) === 47;
+    const trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+    path = normalizeStringPosix(path, !isAbsolute);
+    if (path.length === 0 && !isAbsolute) path = ".";
+    if (path.length > 0 && trailingSeparator) path += "/";
+    if (isAbsolute) return "/" + path;
+    return path;
+  },
+  isAbsolute(path) {
+    return path.length > 0 && path.charCodeAt(0) === 47;
+  },
+  join() {
+    if (arguments.length === 0) {
+      return ".";
+    }
+    let joined;
+    for (let i = 0; i < arguments.length; ++i) {
+      const arg = arguments[i];
+      if (arg.length > 0) {
+        if (joined === void 0) {
+          joined = arg;
+        } else {
+          joined += "/" + arg;
+        }
+      }
+    }
+    if (joined === void 0) {
+      return ".";
+    }
+    return posixImpl.normalize(joined);
+  },
+  relative(from, to) {
+    if (from === to) return "";
+    from = posixImpl.resolve(from);
+    to = posixImpl.resolve(to);
+    if (from === to) return "";
+    let fromStart = 1;
+    for (; fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47) {
+        break;
+      }
+    }
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    let toStart = 1;
+    for (; toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47) {
+        break;
+      }
+    }
+    const toEnd = to.length;
+    const toLen = toEnd - toStart;
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47) {
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47) {
+            lastCommonSep = i;
+          } else if (i === 0) {
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      const fromCode = from.charCodeAt(fromStart + i);
+      const toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode) {
+        break;
+      } else if (fromCode === 47) {
+        lastCommonSep = i;
+      }
+    }
+    let out = "";
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47) {
+        if (out.length === 0) {
+          out += "..";
+        } else {
+          out += "/..";
+        }
+      }
+    }
+    if (out.length > 0) {
+      return out + to.slice(toStart + lastCommonSep);
+    } else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47) {
+        ++toStart;
+      }
+      return to.slice(toStart);
+    }
+  },
+  dirname(path) {
+    if (path.length === 0) return ".";
+    let code = path.charCodeAt(0);
+    const hasRoot = code === 47;
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          end = i;
+          break;
+        }
+      } else {
+        matchedSlash = false;
+      }
+    }
+    if (end === -1) return hasRoot ? "/" : ".";
+    if (hasRoot && end === 1) return "//";
+    return path.slice(0, end);
+  },
+  basename(path, ext) {
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i;
+    if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path) return "";
+      let extIdx = ext.length - 1;
+      let firstNonSlashEnd = -1;
+      for (i = path.length - 1; i >= 0; --i) {
+        const code = path.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else {
+          if (firstNonSlashEnd === -1) {
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                end = i;
+              }
+            } else {
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+      if (start === end) end = firstNonSlashEnd;
+      else if (end === -1) end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1; i >= 0; --i) {
+        if (path.charCodeAt(i) === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+      if (end === -1) return "";
+      return path.slice(start, end);
+    }
+  },
+  extname(path) {
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let preDotState = 0;
+    for (let i = path.length - 1; i >= 0; --i) {
+      const code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46) {
+        if (startDot === -1) {
+          startDot = i;
+        } else if (preDotState !== 1) {
+          preDotState = 1;
+        }
+      } else if (startDot !== -1) {
+        preDotState = -1;
+      }
+    }
+    if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+    preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return "";
+    }
+    return path.slice(startDot, end);
+  },
+  format: function format3(pathObject) {
+    if (pathObject === null || typeof pathObject !== "object") {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format("/", pathObject);
+  },
+  parse(path) {
+    const ret = {
+      root: "",
+      dir: "",
+      base: "",
+      ext: "",
+      name: ""
+    };
+    if (path.length === 0) return ret;
+    let code = path.charCodeAt(0);
+    const isAbsolute = code === 47;
+    let start;
+    if (isAbsolute) {
+      ret.root = "/";
+      start = 1;
+    } else {
+      start = 0;
+    }
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+    let preDotState = 0;
+    for (; i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46) {
+        if (startDot === -1) startDot = i;
+        else if (preDotState !== 1) preDotState = 1;
+      } else if (startDot !== -1) {
+        preDotState = -1;
+      }
+    }
+    if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+    preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
+        else ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+    else if (isAbsolute) ret.dir = "/";
+    return ret;
+  },
+  sep: "/",
+  fromFileUrl,
+  toFileUrl,
+  toNamespacedPath: identity5
+});
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Path.js
+var Path2 = Path;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/Multipart.js
+var TypeId9 = /* @__PURE__ */ Symbol.for("@effect/platform/Multipart");
+var ErrorTypeId2 = /* @__PURE__ */ Symbol.for("@effect/platform/Multipart/MultipartError");
+var MultipartError = class extends (/* @__PURE__ */ Schema6.TaggedError()("MultipartError", {
+  reason: /* @__PURE__ */ Schema6.Literal("FileTooLarge", "FieldTooLarge", "BodyTooLarge", "TooManyParts", "InternalError", "Parse"),
+  cause: Schema6.Defect
+})) {
+  /**
+   * @since 1.0.0
+   */
+  [ErrorTypeId2] = ErrorTypeId2;
+  /**
+   * @since 1.0.0
+   */
+  get message() {
+    return this.reason;
+  }
+};
+var makeConfig = (headers) => Effect8.withFiberRuntime((fiber) => {
+  const mimeTypes = Context4.get(fiber.currentContext, FieldMimeTypes);
+  return Effect8.succeed({
+    headers,
+    maxParts: Option7.getOrUndefined(Context4.get(fiber.currentContext, MaxParts)),
+    maxFieldSize: Number(Context4.get(fiber.currentContext, MaxFieldSize)),
+    maxPartSize: Context4.get(fiber.currentContext, MaxFileSize).pipe(Option7.map(Number), Option7.getOrUndefined),
+    maxTotalSize: Context4.get(fiber.currentContext, MaxBodySize).pipe(Option7.map(Number), Option7.getOrUndefined),
+    isFile: mimeTypes.length === 0 ? void 0 : (info) => !Chunk2.some(mimeTypes, (_) => info.contentType.includes(_)) && defaultIsFile2(info)
+  });
+});
+var makeChannel = (headers, bufferSize = 16) => Channel2.acquireUseRelease(Effect8.all([makeConfig(headers), Mailbox.make(bufferSize)]), ([config, mailbox]) => {
+  let partsBuffer = [];
+  let exit2 = Option7.none();
+  const input = {
+    awaitRead: () => Effect8.void,
+    emit(element) {
+      return mailbox.offer(element);
+    },
+    error(cause) {
+      exit2 = Option7.some(Exit.failCause(cause));
+      return mailbox.end;
+    },
+    done(_value) {
+      return mailbox.end;
+    }
+  };
+  const parser = make7({
+    ...config,
+    onField(info, value) {
+      partsBuffer.push(new FieldImpl(info.name, info.contentType, decodeField2(info, value)));
+    },
+    onFile(info) {
+      let chunks = [];
+      let finished = false;
+      const take = Channel2.suspend(() => {
+        if (chunks.length === 0) {
+          return finished ? Channel2.void : Channel2.zipRight(pump, take);
+        }
+        const chunk = Chunk2.unsafeFromArray(chunks);
+        chunks = [];
+        return finished ? Channel2.write(chunk) : Channel2.zipRight(Channel2.write(chunk), Channel2.zipRight(pump, take));
+      });
+      partsBuffer.push(new FileImpl(info, take));
+      return function(chunk) {
+        if (chunk === null) {
+          finished = true;
+        } else {
+          chunks.push(chunk);
+        }
+      };
+    },
+    onError(error_) {
+      exit2 = Option7.some(Exit.fail(convertError(error_)));
+    },
+    onDone() {
+      exit2 = Option7.some(Exit.void);
+    }
+  });
+  const pump = Channel2.flatMap(mailbox.takeAll, ([chunks, done]) => Channel2.sync(() => {
+    Chunk2.forEach(chunks, Chunk2.forEach(parser.write));
+    if (done) {
+      parser.end();
+    }
+  }));
+  const partsChannel = Channel2.flatMap(pump, () => {
+    if (partsBuffer.length === 0) {
+      return exit2._tag === "None" ? partsChannel : writeExit(exit2.value);
+    }
+    const chunk = Chunk2.unsafeFromArray(partsBuffer);
+    partsBuffer = [];
+    return Channel2.zipRight(Channel2.write(chunk), exit2._tag === "None" ? partsChannel : writeExit(exit2.value));
+  });
+  return Channel2.embedInput(partsChannel, input);
+}, ([, mailbox]) => mailbox.shutdown);
+var writeExit = (self) => self._tag === "Success" ? Channel2.void : Channel2.failCause(self.cause);
+function convertError(cause) {
+  switch (cause._tag) {
+    case "ReachedLimit": {
+      switch (cause.limit) {
+        case "MaxParts": {
+          return new MultipartError({
+            reason: "TooManyParts",
+            cause
+          });
+        }
+        case "MaxFieldSize": {
+          return new MultipartError({
+            reason: "FieldTooLarge",
+            cause
+          });
+        }
+        case "MaxPartSize": {
+          return new MultipartError({
+            reason: "FileTooLarge",
+            cause
+          });
+        }
+        case "MaxTotalSize": {
+          return new MultipartError({
+            reason: "BodyTooLarge",
+            cause
+          });
+        }
+      }
+    }
+    default: {
+      return new MultipartError({
+        reason: "Parse",
+        cause
+      });
+    }
+  }
+}
+var PartBase = class extends Inspectable5.Class {
+  [TypeId9];
+  constructor() {
+    super();
+    this[TypeId9] = TypeId9;
+  }
+};
+var FieldImpl = class extends PartBase {
+  key;
+  contentType;
+  value;
+  _tag = "Field";
+  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 = Stream4.fromChannel(channel);
+    this.contentEffect = channel.pipe(Channel2.pipeTo(collectUint8Array), Channel2.run, Effect8.mapError((cause) => new MultipartError({
+      reason: "InternalError",
+      cause
+    })));
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    };
+  }
+};
+var defaultWriteFile = (path, file3) => Effect8.flatMap(FileSystem, (fs) => Effect8.mapError(Stream4.run(file3.content, fs.sink(path)), (cause) => new MultipartError({
+  reason: "InternalError",
+  cause
+})));
+var collectUint8Array = /* @__PURE__ */ Channel2.suspend(() => {
+  let accumulator = new Uint8Array(0);
+  const loop = Channel2.readWithCause({
+    onInput(chunk) {
+      for (const element of chunk) {
+        const newAccumulator = new Uint8Array(accumulator.length + element.length);
+        newAccumulator.set(accumulator, 0);
+        newAccumulator.set(element, accumulator.length);
+        accumulator = newAccumulator;
+      }
+      return loop;
+    },
+    onFailure: (cause) => Channel2.failCause(cause),
+    onDone: () => Channel2.succeed(accumulator)
+  });
+  return loop;
+});
+var toPersisted = (stream4, writeFile = defaultWriteFile) => Effect8.gen(function* () {
+  const fs = yield* FileSystem;
+  const path_ = yield* Path2;
+  const dir = yield* fs.makeTempDirectoryScoped();
+  const persisted = /* @__PURE__ */ Object.create(null);
+  yield* Stream4.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 Effect8.void;
+    } else if (part.name === "") {
+      return Effect8.void;
+    }
+    const file3 = part;
+    const path = path_.join(dir, path_.basename(file3.name).slice(-128));
+    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(Effect8.catchTags({
+  SystemError: (cause) => Effect8.fail(new MultipartError({
+    reason: "InternalError",
+    cause
+  })),
+  BadArgument: (cause) => Effect8.fail(new MultipartError({
+    reason: "InternalError",
+    cause
+  }))
+}));
+var PersistedFileImpl = class extends PartBase {
+  key;
+  name;
+  contentType;
+  path;
+  _tag = "PersistedFile";
+  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 = class extends (/* @__PURE__ */ Context4.Reference()("@effect/platform/Multipart/MaxParts", {
+  defaultValue: Option7.none
+})) {
+};
+var MaxFieldSize = class extends (/* @__PURE__ */ Context4.Reference()("@effect/platform/Multipart/MaxFieldSize", {
+  defaultValue: /* @__PURE__ */ constant(/* @__PURE__ */ Size2(10 * 1024 * 1024))
+})) {
+};
+var MaxFileSize = class extends (/* @__PURE__ */ Context4.Reference()("@effect/platform/Multipart/MaxFileSize", {
+  defaultValue: Option7.none
+})) {
+};
+var FieldMimeTypes = class extends (/* @__PURE__ */ Context4.Reference()("@effect/platform/Multipart/FieldMimeTypes", {
+  defaultValue: /* @__PURE__ */ constant(/* @__PURE__ */ Chunk2.make("application/json"))
+})) {
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpServerRequest.js
+var TypeId10 = /* @__PURE__ */ Symbol.for("@effect/platform/HttpServerRequest");
+var serverRequestTag = /* @__PURE__ */ Context5.GenericTag("@effect/platform/HttpServerRequest");
+var fromWeb2 = (request) => new ServerRequestImpl(request, removeHost(request.url));
+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 Inspectable6.Class {
+  source;
+  url;
+  headersOverride;
+  remoteAddressOverride;
+  [TypeId10];
+  [TypeId3];
+  constructor(source, url, headersOverride, remoteAddressOverride) {
+    super();
+    this.source = source;
+    this.url = url;
+    this.headersOverride = headersOverride;
+    this.remoteAddressOverride = remoteAddressOverride;
+    this[TypeId10] = TypeId10;
+    this[TypeId3] = TypeId3;
+  }
+  toJSON() {
+    return inspect(this, {
+      _id: "@effect/platform/HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    });
+  }
+  modify(options) {
+    return new _ServerRequestImpl(this.source, options.url ?? this.url, options.headers ?? this.headersOverride, options.remoteAddress ?? this.remoteAddressOverride);
+  }
+  get method() {
+    return this.source.method.toUpperCase();
+  }
+  get originalUrl() {
+    return this.source.url;
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ? Option8.some(this.remoteAddressOverride) : Option8.none();
+  }
+  get headers() {
+    this.headersOverride ??= fromInput(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 ? Stream5.fromReadableStream(() => this.source.body, (cause) => new RequestError({
+      request: this,
+      reason: "Decode",
+      cause
+    })) : Stream5.fail(new RequestError({
+      request: this,
+      reason: "Decode",
+      description: "can not create stream from empty body"
+    }));
+  }
+  textEffect;
+  get text() {
+    if (this.textEffect) {
+      return this.textEffect;
+    }
+    this.textEffect = Effect9.runSync(Effect9.cached(Effect9.tryPromise({
+      try: () => this.source.text(),
+      catch: (cause) => new RequestError({
+        request: this,
+        reason: "Decode",
+        cause
+      })
+    })));
+    return this.textEffect;
+  }
+  get json() {
+    return Effect9.tryMap(this.text, {
+      try: (_) => JSON.parse(_),
+      catch: (cause) => new RequestError({
+        request: this,
+        reason: "Decode",
+        cause
+      })
+    });
+  }
+  get urlParamsBody() {
+    return Effect9.flatMap(this.text, (_) => Effect9.try({
+      try: () => fromInput2(new URLSearchParams(_)),
+      catch: (cause) => new RequestError({
+        request: this,
+        reason: "Decode",
+        cause
+      })
+    }));
+  }
+  multipartEffect;
+  get multipart() {
+    if (this.multipartEffect) {
+      return this.multipartEffect;
+    }
+    this.multipartEffect = Effect9.runSync(Effect9.cached(toPersisted(this.multipartStream)));
+    return this.multipartEffect;
+  }
+  get multipartStream() {
+    return Stream5.pipeThroughChannel(Stream5.mapError(this.stream, (cause) => new MultipartError({
+      reason: "InternalError",
+      cause
+    })), makeChannel(this.headers));
+  }
+  arrayBufferEffect;
+  get arrayBuffer() {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect;
+    }
+    this.arrayBufferEffect = Effect9.runSync(Effect9.cached(Effect9.tryPromise({
+      try: () => this.source.arrayBuffer(),
+      catch: (cause) => new RequestError({
+        request: this,
+        reason: "Decode",
+        cause
+      })
+    })));
+    return this.arrayBufferEffect;
+  }
+  get upgrade() {
+    return Effect9.fail(new RequestError({
+      request: this,
+      reason: "Decode",
+      description: "Not an upgradeable ServerRequest"
+    }));
+  }
+};
+var toURL = (self) => {
+  const host = self.headers.host ?? "localhost";
+  const protocol = self.headers["x-forwarded-proto"] === "https" ? "https" : "http";
+  try {
+    return Option8.some(new URL(self.url, `${protocol}://${host}`));
+  } catch {
+    return Option8.none();
+  }
+};
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpServerRequest.js
+var HttpServerRequest = serverRequestTag;
+var fromWeb3 = fromWeb2;
+var toWebEither = (self, options) => {
+  if (self.source instanceof Request) {
+    return Either3.right(self.source);
+  }
+  const ourl = toURL2(self);
+  if (Option9.isNone(ourl)) {
+    return Either3.left(new RequestError({
+      request: self,
+      reason: "Decode",
+      description: "Invalid URL"
+    }));
+  }
+  const requestInit = {
+    method: self.method,
+    headers: self.headers,
+    signal: options?.signal
+  };
+  if (hasBody(self.method)) {
+    requestInit.body = Stream6.toReadableStreamRuntime(self.stream, options?.runtime ?? Runtime2.defaultRuntime);
+    requestInit.duplex = "half";
+  }
+  return Either3.right(new Request(ourl.value, requestInit));
+};
+var toURL2 = toURL;
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpApp.js
+import * as Effect11 from "effect/Effect";
+import * as FiberRef2 from "effect/FiberRef";
+import { dual as dual7 } from "effect/Function";
+import { globalValue as globalValue3 } from "effect/GlobalValue";
+import * as Option10 from "effect/Option";
+var currentPreResponseHandlers = /* @__PURE__ */ globalValue3(/* @__PURE__ */ Symbol.for("@effect/platform/HttpApp/preResponseHandlers"), () => FiberRef2.unsafeMake(Option10.none()));
+var appendPreResponseHandler = (handler) => FiberRef2.update(currentPreResponseHandlers, Option10.match({
+  onNone: () => Option10.some(handler),
+  onSome: (prev) => Option10.some((request, response) => Effect11.flatMap(prev(request, response), (response2) => handler(request, response2)))
+}));
+var withPreResponseHandler = /* @__PURE__ */ dual7(2, (self, handler) => Effect11.locallyWith(self, currentPreResponseHandlers, Option10.match({
+  onNone: () => Option10.some(handler),
+  onSome: (prev) => Option10.some((request, response) => Effect11.flatMap(prev(request, response), (response2) => handler(request, response2)))
+})));
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/internal/httpMiddleware.js
+import * as Context6 from "effect/Context";
+import * as Effect12 from "effect/Effect";
+import * as FiberRef3 from "effect/FiberRef";
+import { constFalse, dual as dual8 } from "effect/Function";
+import * as Function from "effect/Function";
+import { globalValue as globalValue4 } from "effect/GlobalValue";
+import * as Layer3 from "effect/Layer";
+import * as Option11 from "effect/Option";
+var make10 = (middleware) => middleware;
+var currentTracerDisabledWhen = /* @__PURE__ */ globalValue4(/* @__PURE__ */ Symbol.for("@effect/platform/HttpMiddleware/tracerDisabledWhen"), () => FiberRef3.unsafeMake(constFalse));
+var SpanNameGenerator = /* @__PURE__ */ Context6.Reference()("@effect/platform/HttpMiddleware/SpanNameGenerator", {
+  defaultValue: () => (request) => `http.server ${request.method}`
+});
+var tracer = /* @__PURE__ */ make10((httpApp) => Effect12.withFiberRuntime((fiber) => {
+  const request = Context6.unsafeGet(fiber.currentContext, HttpServerRequest);
+  const disabled = fiber.getFiberRef(currentTracerDisabledWhen)(request);
+  if (disabled) {
+    return httpApp;
+  }
+  const url = Option11.getOrUndefined(toURL2(request));
+  if (url !== void 0 && (url.username !== "" || url.password !== "")) {
+    url.username = "REDACTED";
+    url.password = "REDACTED";
+  }
+  const redactedHeaderNames = fiber.getFiberRef(currentRedactedNames);
+  const redactedHeaders = redact(request.headers, redactedHeaderNames);
+  const nameGenerator = Context6.get(fiber.currentContext, SpanNameGenerator);
+  return Effect12.useSpan(nameGenerator(request), {
+    parent: Option11.getOrUndefined(fromHeaders(request.headers)),
+    kind: "server",
+    captureStackTrace: false
+  }, (span) => {
+    span.attribute("http.request.method", request.method);
+    if (url !== void 0) {
+      span.attribute("url.full", url.toString());
+      span.attribute("url.path", url.pathname);
+      const query = url.search.slice(1);
+      if (query !== "") {
+        span.attribute("url.query", url.search.slice(1));
+      }
+      span.attribute("url.scheme", url.protocol.slice(0, -1));
+    }
+    if (request.headers["user-agent"] !== void 0) {
+      span.attribute("user_agent.original", request.headers["user-agent"]);
+    }
+    for (const name in redactedHeaders) {
+      span.attribute(`http.request.header.${name}`, String(redactedHeaders[name]));
+    }
+    if (request.remoteAddress._tag === "Some") {
+      span.attribute("client.address", request.remoteAddress.value);
+    }
+    return Effect12.flatMap(Effect12.exit(Effect12.withParentSpan(httpApp, span)), (exit2) => {
+      const response = exitResponse2(exit2);
+      span.attribute("http.response.status_code", response.status);
+      const redactedHeaders2 = redact(response.headers, redactedHeaderNames);
+      for (const name in redactedHeaders2) {
+        span.attribute(`http.response.header.${name}`, String(redactedHeaders2[name]));
+      }
+      return exit2;
+    });
+  });
+}));
+
+// ../../node_modules/.bun/@effect+platform@0.94.2+8cc8b89dc7ad56db/node_modules/@effect/platform/dist/esm/HttpApp.js
+var handledSymbol = /* @__PURE__ */ Symbol.for("@effect/platform/HttpApp/handled");
+var toHandled = (self, handleResponse, middleware) => {
+  const responded = Effect13.withFiberRuntime((fiber) => Effect13.flatMap(self, (response) => {
+    const request = Context7.unsafeGet(fiber.currentContext, HttpServerRequest);
+    const handler = fiber.getFiberRef(currentPreResponseHandlers2);
+    if (handler._tag === "None") {
+      ;
+      request[handledSymbol] = true;
+      return Effect13.as(handleResponse(request, response), response);
+    }
+    return Effect13.tap(handler.value(request, response), (response2) => {
+      ;
+      request[handledSymbol] = true;
+      return handleResponse(request, response2);
+    });
+  }));
+  const withErrorHandling = Effect13.catchAllCause(responded, (cause) => Effect13.withFiberRuntime((fiber) => Effect13.flatMap(causeResponse2(cause), ([response, cause2]) => {
+    const request = Context7.unsafeGet(fiber.currentContext, HttpServerRequest);
+    const handler = fiber.getFiberRef(currentPreResponseHandlers2);
+    if (handler._tag === "None") {
+      ;
+      request[handledSymbol] = true;
+      return Effect13.zipRight(handleResponse(request, response), Cause3.isEmptyType(cause2) ? Effect13.succeed(response) : Effect13.failCause(cause2));
+    }
+    return Effect13.zipRight(Effect13.tap(handler.value(request, response), (response2) => {
+      ;
+      request[handledSymbol] = true;
+      return handleResponse(request, response2);
+    }), Cause3.isEmptyType(cause2) ? Effect13.succeed(response) : Effect13.failCause(cause2));
+  })));
+  const withMiddleware = unify(middleware === void 0 ? tracer(withErrorHandling) : Effect13.matchCauseEffect(tracer(middleware(withErrorHandling)), {
+    onFailure: (cause) => Effect13.withFiberRuntime((fiber) => {
+      const request = Context7.unsafeGet(fiber.currentContext, HttpServerRequest);
+      if (handledSymbol in request) {
+        return Effect13.void;
+      }
+      return Effect13.matchCauseEffect(causeResponse2(cause), {
+        onFailure: (_cause) => handleResponse(request, empty5({
+          status: 500
+        })),
+        onSuccess: ([response]) => handleResponse(request, response)
+      });
+    }),
+    onSuccess: (response) => Effect13.withFiberRuntime((fiber) => {
+      const request = Context7.unsafeGet(fiber.currentContext, HttpServerRequest);
+      return handledSymbol in request ? Effect13.void : handleResponse(request, response);
+    })
+  }));
+  return Effect13.uninterruptible(scoped(withMiddleware));
+};
+var ejectDefaultScopeClose = (scope) => {
+  ejectedScopes.add(scope);
+};
+var unsafeEjectStreamScope = (response) => {
+  if (response.body._tag !== "Stream") {
+    return response;
+  }
+  const fiber = Option12.getOrThrow(Fiber.getCurrentFiber());
+  const scope = Context7.unsafeGet(fiber.currentContext, Scope.Scope);
+  ejectDefaultScopeClose(scope);
+  return setBody2(response, stream2(Stream7.ensuring(response.body.stream, Scope.close(scope, Exit2.void)), response.body.contentType, response.body.contentLength));
+};
+var ejectedScopes = /* @__PURE__ */ GlobalValue.globalValue("@effect/platform/HttpApp/ejectedScopes", () => /* @__PURE__ */ new WeakSet());
+var scoped = (effect) => Effect13.flatMap(Scope.make(), (scope) => Effect13.onExit(Scope.extend(effect, scope), (exit2) => {
+  if (ejectedScopes.has(scope)) {
+    return Effect13.void;
+  }
+  return Scope.close(scope, exit2);
+}));
+var currentPreResponseHandlers2 = currentPreResponseHandlers;
+var appendPreResponseHandler2 = appendPreResponseHandler;
+var withPreResponseHandler2 = withPreResponseHandler;
+var toWebHandlerRuntime = (runtime3) => {
+  const httpRuntime = Runtime3.make(runtime3);
+  const run3 = Runtime3.runFork(httpRuntime);
+  return (self, middleware) => {
+    const resolveSymbol = /* @__PURE__ */ Symbol.for("@effect/platform/HttpApp/resolve");
+    const httpApp = toHandled(self, (request, response) => {
+      response = unsafeEjectStreamScope(response);
+      request[resolveSymbol](toWeb2(response, {
+        withoutBody: request.method === "HEAD",
+        runtime: runtime3
+      }));
+      return Effect13.void;
+    }, middleware);
+    return (request, context2) => new Promise((resolve3) => {
+      const contextMap = new Map(runtime3.context.unsafeMap);
+      if (Context7.isContext(context2)) {
+        for (const [key, value] of context2.unsafeMap) {
+          contextMap.set(key, value);
+        }
+      }
+      const httpServerRequest = fromWeb3(request);
+      contextMap.set(HttpServerRequest.key, httpServerRequest);
+      httpServerRequest[resolveSymbol] = resolve3;
+      httpRuntime.context = Context7.unsafeMake(contextMap);
+      const fiber = run3(httpApp);
+      request.signal?.addEventListener("abort", () => {
+        fiber.unsafeInterruptAsFork(clientAbortFiberId2);
+      }, {
+        once: true
+      });
+    });
+  };
+};
+var toWebHandler = /* @__PURE__ */ toWebHandlerRuntime(Runtime3.defaultRuntime);
+var toWebHandlerLayerWith = (layer2, options) => {
+  const scope = Effect13.runSync(Scope.make());
+  const dispose = () => Effect13.runPromise(Scope.close(scope, Exit2.void));
+  let handlerCache;
+  let handlerPromise;
+  function handler(request, context2) {
+    if (handlerCache) {
+      return handlerCache(request, context2);
+    }
+    handlerPromise ??= Effect13.gen(function* () {
+      const runtime3 = yield* options.memoMap ? Layer4.toRuntimeWithMemoMap(layer2, options.memoMap) : Layer4.toRuntime(layer2);
+      return handlerCache = toWebHandlerRuntime(runtime3)(yield* options.toHandler(runtime3), options.middleware);
+    }).pipe(Scope.extend(scope), Effect13.runPromise);
+    return handlerPromise.then((f) => f(request, context2));
+  }
+  return {
+    dispose,
+    handler
+  };
+};
+var toWebHandlerLayer = (self, layer2, options) => toWebHandlerLayerWith(layer2, {
+  ...options,
+  toHandler: () => Effect13.succeed(self)
+});
+var fromWebHandler = (handler) => Effect13.async((resume, signal) => {
+  const fiber = Option12.getOrThrow(Fiber.getCurrentFiber());
+  const request = Context7.unsafeGet(fiber.currentContext, HttpServerRequest);
+  const requestResult = toWebEither(request, {
+    signal,
+    runtime: Runtime3.make({
+      context: fiber.currentContext,
+      fiberRefs: fiber.getFiberRefs(),
+      runtimeFlags: Runtime3.defaultRuntimeFlags
+    })
+  });
+  if (requestResult._tag === "Left") {
+    return resume(Effect13.fail(requestResult.left));
+  }
+  handler(requestResult.right).then((response) => resume(Effect13.succeed(fromWeb(response))), (cause) => resume(Effect13.fail(new RequestError({
+    cause,
+    request,
+    reason: "Transport",
+    description: "HttpApp.fromWebHandler: Error in handler"
+  }))));
+});
+
+// src/for/inngest/index.ts
+import { Data as Data4, Effect as Effect17, FiberSet, Layer as Layer5 } from "effect";
+import * as Context9 from "effect/Context";
+import * as Inspectable7 from "effect/Inspectable";
+import { serve } from "inngest/bun";
+
+// src/extract.ts
+import { Context as Context8, Effect as Effect14, pipe as pipe2 } from "effect";
+function extract(effect, options) {
+  return Effect14.gen(function* () {
+    const runtime3 = yield* Effect14.runtime();
+    const context2 = runtime3.context.pipe(
+      options?.exclude ? Context8.omit(...options.exclude) : (e) => e
+    );
+    return (...params) => pipe2(effect(...params), Effect14.provide(context2));
+  });
+}
+
+// src/for/inngest/cron.ts
+import { Option as Option13 } from "effect";
+function fieldToString(field, max) {
+  if (field.size === 0 || field.size === max) return "*";
+  return Array.from(field).sort((a, b) => a - b).join(",");
+}
+function cronToString(cron) {
+  const minutes = fieldToString(cron.minutes, 60);
+  const hours = fieldToString(cron.hours, 24);
+  const days = fieldToString(cron.days, 31);
+  const months = fieldToString(cron.months, 12);
+  const weekdays = fieldToString(cron.weekdays, 7);
+  const expr = `${minutes} ${hours} ${days} ${months} ${weekdays}`;
+  if (Option13.isSome(cron.tz)) return `TZ=${cron.tz.value} ${expr}`;
+  return expr;
+}
+
+// src/for/inngest/step.ts
+import { Duration as Duration2, Effect as Effect16 } from "effect";
+
+// src/run-promise-unwrapped.ts
+import { Cause as Cause4, Effect as Effect15, Exit as Exit3 } from "effect";
+async function runPromiseUnwrapped(effect) {
+  const exit2 = await Effect15.runPromiseExit(effect);
+  return Exit3.match(exit2, {
+    onSuccess: (value) => value,
+    onFailure: (cause) => {
+      throw Cause4.isFailType(cause) ? cause.error : cause;
+    }
+  });
+}
+
+// src/for/inngest/step.ts
+function wrapStep(step) {
+  const s = step;
+  return {
+    run: (id, fn) => Effect16.tryPromise({
+      try: () => s.run(id, () => runPromiseUnwrapped(fn())),
+      catch: (cause) => new InngestError({ message: `Step "${id}" failed`, cause })
+    }),
+    sleep: (id, duration) => Effect16.tryPromise({
+      try: () => s.sleep(id, Duration2.toMillis(Duration2.decode(duration))),
+      catch: (cause) => new InngestError({
+        message: `Step sleep "${id}" failed`,
+        cause
+      })
+    }),
+    sleepUntil: (id, time) => Effect16.tryPromise({
+      try: () => s.sleepUntil(id, time),
+      catch: (cause) => new InngestError({
+        message: `Step sleepUntil "${id}" failed`,
+        cause
+      })
+    }),
+    invoke: (id, opts) => Effect16.tryPromise({
+      try: () => s.invoke(id, opts),
+      catch: (cause) => new InngestError({
+        message: `Step invoke "${id}" failed`,
+        cause
+      })
+    }),
+    waitForEvent: (id, opts) => Effect16.tryPromise({
+      try: () => s.waitForEvent(id, opts),
+      catch: (cause) => new InngestError({
+        message: `Step waitForEvent "${id}" failed`,
+        cause
+      })
+    }),
+    sendEvent: (id, payload) => Effect16.tryPromise({
+      try: () => s.sendEvent(id, payload),
+      catch: (cause) => new InngestError({
+        message: `Step sendEvent "${id}" failed`,
+        cause
+      })
+    })
+  };
+}
+
+// src/for/inngest/index.ts
+var TagTypeId2 = Context9.TagTypeId;
+var NodeInspectSymbol4 = Inspectable7.NodeInspectSymbol;
+var InngestError = class extends Data4.TaggedError("ff-effect/InngestError") {
+};
+function isCronTrigger(trigger) {
+  return typeof trigger === "object" && trigger !== null && "cron" in trigger && typeof trigger.cron === "object" && trigger.cron !== null && "minutes" in trigger.cron;
+}
+function resolveTrigger(trigger) {
+  if (Array.isArray(trigger)) {
+    return trigger.map(
+      (t) => resolveTrigger(t)
+    );
+  }
+  if (isCronTrigger(trigger)) {
+    return { cron: cronToString(trigger.cron) };
+  }
+  return trigger;
+}
+var defaultPrefix = "@ff-effect/Inngest";
+function createInngest(createClient, opts) {
+  const tagId = opts?.tagId ?? defaultPrefix;
+  const Tag3 = Context9.Tag(tagId)();
+  const send = (payload) => Effect17.gen(function* () {
+    const c = yield* Tag3;
+    return yield* Effect17.tryPromise({
+      // @ts-expect-error inngest generic variance issue between constrained and inferred client types
+      try: () => c.send(payload),
+      catch: (cause) => new InngestError({ message: "Failed to send event", cause })
+    });
+  });
+  const createFunction = (config, trigger, handler) => Effect17.gen(function* () {
+    const c = yield* Tag3;
+    const ext_handler = yield* extract(handler);
+    const resolvedTrigger = resolveTrigger(trigger);
+    const runPromise2 = yield* FiberSet.makeRuntimePromise();
+    return c.createFunction(
+      config,
+      resolvedTrigger,
+      // biome-ignore lint/suspicious/noExplicitAny: inngest middleware produces unresolvable context type
+      async (ctx) => {
+        const effectStep = wrapStep(ctx.step);
+        return runPromise2(
+          ext_handler({
+            ...ctx,
+            step: effectStep
+          })
+        );
+      }
+    );
+  });
+  function buildServe(client, httpOpts) {
+    return serve({
+      client,
+      functions: httpOpts.functions,
+      ...httpOpts.servePath != null && { servePath: httpOpts.servePath },
+      ...httpOpts.signingKey != null && {
+        signingKey: httpOpts.signingKey
+      },
+      ...httpOpts.signingKeyFallback != null && {
+        signingKeyFallback: httpOpts.signingKeyFallback
+      },
+      ...httpOpts.logLevel != null && { logLevel: httpOpts.logLevel },
+      ...httpOpts.streaming != null && { streaming: httpOpts.streaming }
+    });
+  }
+  const fetchHandler = (httpOpts) => Effect17.gen(function* () {
+    const c = yield* Tag3;
+    return buildServe(c, httpOpts);
+  });
+  const httpHandler = (httpOpts) => Effect17.gen(function* () {
+    const c = yield* Tag3;
+    return HttpApp_exports.fromWebHandler(buildServe(c, httpOpts));
+  });
+  return {
+    Tag: Tag3,
+    layer: Layer5.effect(Tag3, createClient),
+    createFunction,
+    send,
+    fetchHandler,
+    httpHandler
+  };
+}
+export {
+  InngestError,
+  NodeInspectSymbol4 as NodeInspectSymbol,
+  TagTypeId2 as TagTypeId,
+  createInngest
+};
+//# sourceMappingURL=index.js.map