apps 0.0.1-beta.0

package/js/chunk-3ANFZFCV.js

@@ -0,0 +1,1799 @@
+import {
+  DecodeError,
+  HttpClient,
+  HttpClientError,
+  StatusCodeError,
+  appendUrlParams,
+  bodyFormData,
+  fromLiteral,
+  get,
+  hasBody,
+  isHttpBody,
+  make as make2,
+  mapRequest,
+  prefixPath,
+  prependUrl,
+  setBody,
+  setHeaders,
+  setUrl,
+  text,
+  uint8Array,
+  urlParams
+} from "./chunk-W7Q5EOTS.js";
+import {
+  JsonValue
+} from "./chunk-36DNRFZQ.js";
+import {
+  Cause,
+  Defect,
+  Forbidden,
+  InvalidValue,
+  Literal,
+  Never,
+  RecordFromUrlParams,
+  Schema_exports,
+  Service,
+  String as String2,
+  Struct,
+  TaggedClass,
+  TaggedError,
+  Uint8Array as Uint8Array2,
+  Undefined,
+  UndefinedOr,
+  Union,
+  Unknown,
+  UnknownFromJsonString,
+  Void,
+  add,
+  as,
+  assignProperty,
+  brand,
+  catchCause,
+  combine2 as combine,
+  constVoid,
+  context,
+  declare,
+  decode2 as decode,
+  decodeEffect,
+  decodeText,
+  decodeTo,
+  decodeUnknownEffect2 as decodeUnknownEffect,
+  empty2 as empty,
+  empty6 as empty2,
+  encodeSync,
+  encodeUnknownEffect2 as encodeUnknownEffect,
+  ensure,
+  fail,
+  fail2,
+  fail4 as fail3,
+  failCause2 as failCause,
+  flatMap2 as flatMap,
+  fnUntraced,
+  fromInput3 as fromInput,
+  fromJsonString,
+  fromTransform,
+  gen,
+  getLastEncoding,
+  getOrUndefined2 as getOrUndefined,
+  hasProperty,
+  identity,
+  instanceOf,
+  isArrayNonEmpty,
+  isCause,
+  isLiteral,
+  isNull,
+  isObject,
+  isObjects,
+  isSchema,
+  isStream,
+  isSuspend,
+  isUnion,
+  isVoid,
+  make6 as make,
+  map2 as map,
+  map3 as map2,
+  map4 as map3,
+  map6 as map4,
+  memoize,
+  merge,
+  millis,
+  optional,
+  pipeArguments,
+  pipeThroughChannel,
+  pipeTo,
+  provideContext2 as provideContext,
+  resolveAt,
+  succeed,
+  succeed4 as succeed2,
+  suspend,
+  sync2 as sync,
+  tag,
+  toCodecJson,
+  toCodecStringTree,
+  toEncoded,
+  toEncoded2,
+  toString,
+  toType,
+  transform,
+  transformEffect,
+  transformPull,
+  void_2 as void_
+} from "./chunk-2OTCEKL2.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApi.js
+var HttpApi_exports = {};
+__export(HttpApi_exports, {
+  AdditionalSchemas: () => AdditionalSchemas,
+  ParseOptions: () => ParseOptions,
+  isHttpApi: () => isHttpApi,
+  make: () => make4,
+  reflect: () => reflect
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApiEndpoint.js
+var HttpApiEndpoint_exports = {};
+__export(HttpApiEndpoint_exports, {
+  delete: () => del,
+  get: () => get2,
+  getErrorSchemas: () => getErrorSchemas,
+  getPayloadSchemas: () => getPayloadSchemas,
+  getSuccessSchemas: () => getSuccessSchemas,
+  head: () => head,
+  isHttpApiEndpoint: () => isHttpApiEndpoint,
+  make: () => make3,
+  options: () => options,
+  patch: () => patch,
+  post: () => post,
+  put: () => put,
+  query: () => query
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApiSchema.js
+var HttpApiSchema_exports = {};
+__export(HttpApiSchema_exports, {
+  Accepted: () => Accepted,
+  Created: () => Created,
+  Empty: () => Empty,
+  MultipartStreamTypeId: () => MultipartStreamTypeId,
+  MultipartTypeId: () => MultipartTypeId,
+  NoContent: () => NoContent,
+  StreamSse: () => StreamSse,
+  StreamUint8Array: () => StreamUint8Array,
+  WithHeaders: () => WithHeaders,
+  WithHeadersTypeId: () => WithHeadersTypeId,
+  WithHeadersValueTypeId: () => WithHeadersValueTypeId,
+  asFormUrlEncoded: () => asFormUrlEncoded,
+  asJson: () => asJson,
+  asMultipart: () => asMultipart,
+  asMultipartStream: () => asMultipartStream,
+  asNoContent: () => asNoContent,
+  asText: () => asText,
+  asUint8Array: () => asUint8Array,
+  encodeToWithHeaders: () => encodeToWithHeaders,
+  getPayloadEncoding: () => getPayloadEncoding,
+  getResponseEncoding: () => getResponseEncoding,
+  getResponseEncodingSchema: () => getResponseEncodingSchema,
+  getStatusError: () => getStatusError,
+  getStatusErrorSchema: () => getStatusErrorSchema,
+  getStatusSuccess: () => getStatusSuccess,
+  getStatusSuccessSchema: () => getStatusSuccessSchema,
+  getWithHeadersAnnotation: () => getWithHeadersAnnotation,
+  isNoContent: () => isNoContent,
+  isStreamSchema: () => isStreamSchema,
+  isStreamSse: () => isStreamSse,
+  isStreamUint8Array: () => isStreamUint8Array,
+  isWithHeaders: () => isWithHeaders,
+  isWithHeadersValue: () => isWithHeadersValue,
+  rebuildWithHeaders: () => rebuildWithHeaders,
+  status: () => status,
+  withHeaders: () => withHeaders
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/encoding/Sse.js
+var SseErrorTypeId = "~effect/encoding/Sse/SseError";
+var EventTooLarge = class extends (/* @__PURE__ */ TaggedError("EventTooLarge")) {
+  get message() {
+    return `Pending SSE event exceeded the maximum size of ${this.maxEventSize}`;
+  }
+};
+var SseError = class extends (/* @__PURE__ */ TaggedError("SseError")) {
+  /**
+   * Marks this value as an SSE decoding error.
+   *
+   * @since 4.0.0
+   */
+  [SseErrorTypeId] = SseErrorTypeId;
+  /**
+   * Delegates the public message to the underlying SSE error reason.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return this.reason.message;
+  }
+};
+var defaultMaxEventSize = 10 * 1024 * 1024;
+var decode2 = (options2) => fromTransform((upstream, _scope) => sync(() => {
+  let buffer = [];
+  let retry;
+  const parser = makeParser((event) => {
+    if (event._tag === "Retry") {
+      retry = event;
+    } else {
+      buffer.push(event);
+    }
+  }, options2);
+  const pump = flatMap(upstream, (arr) => {
+    for (let i = 0; i < arr.length; i++) {
+      const error = parser.feed(arr[i]);
+      if (error !== void 0) {
+        return fail3(error);
+      }
+    }
+    return void_;
+  });
+  return suspend(function loop() {
+    if (isArrayNonEmpty(buffer)) {
+      const out = buffer;
+      buffer = [];
+      return succeed2(out);
+    } else if (retry) {
+      return fail3(retry);
+    }
+    return flatMap(pump, loop);
+  });
+}));
+var decodeSchema = (schema, options2, parseOptions) => pipeTo(decode2(options2), decode(Event.pipe(decodeTo(schema, transformEvent)), parseOptions)());
+function makeParser(onParse, options2) {
+  const maxEventSize = options2?.maxEventSize ?? defaultMaxEventSize;
+  let isFirstChunk;
+  let buffer;
+  let startingPosition;
+  let startingFieldLength;
+  let discardTrailingNewline;
+  let lastEventId;
+  let eventName;
+  let data;
+  reset();
+  return {
+    feed,
+    reset
+  };
+  function reset() {
+    isFirstChunk = true;
+    buffer = "";
+    startingPosition = 0;
+    startingFieldLength = -1;
+    discardTrailingNewline = false;
+    lastEventId = void 0;
+    eventName = void 0;
+    data = "";
+  }
+  function feed(chunk) {
+    buffer = buffer ? buffer + chunk : chunk;
+    if (isFirstChunk && buffer.startsWith(BOM)) {
+      buffer = buffer.slice(BOM.length);
+    }
+    isFirstChunk = false;
+    const length = buffer.length;
+    let position = 0;
+    while (position < length) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === "\n") {
+          ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineLength = -1;
+      let fieldLength = startingFieldLength;
+      let character;
+      for (let index = position + startingPosition; lineLength < 0 && index < length; ++index) {
+        character = buffer[index];
+        if (character === ":" && fieldLength < 0) {
+          fieldLength = index - position;
+        } else if (character === "\r") {
+          discardTrailingNewline = true;
+          lineLength = index - position;
+        } else if (character === "\n") {
+          lineLength = index - position;
+        }
+      }
+      if (lineLength < 0) {
+        startingPosition = length - position;
+        startingFieldLength = fieldLength;
+        break;
+      } else {
+        startingPosition = 0;
+        startingFieldLength = -1;
+      }
+      parseEventStreamLine(buffer, position, fieldLength, lineLength);
+      position += lineLength + 1;
+    }
+    if (position === length) {
+      buffer = "";
+    } else if (position > 0) {
+      buffer = buffer.slice(position);
+    }
+    if (buffer.length + data.length > maxEventSize) {
+      const error = new SseError({
+        reason: new EventTooLarge({
+          maxEventSize
+        })
+      });
+      reset();
+      return error;
+    }
+  }
+  function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {
+    if (lineLength === 0) {
+      if (data.length > 0) {
+        onParse({
+          _tag: "Event",
+          id: lastEventId,
+          event: eventName || "message",
+          data: data.slice(0, -1)
+          // remove trailing newline
+        });
+        data = "";
+      }
+      eventName = void 0;
+      return;
+    }
+    const noValue = fieldLength < 0;
+    const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+    let step = 0;
+    if (noValue) {
+      step = lineLength;
+    } else if (lineBuffer[index + fieldLength + 1] === " ") {
+      step = fieldLength + 2;
+    } else {
+      step = fieldLength + 1;
+    }
+    const position = index + step;
+    const valueLength = lineLength - step;
+    const value = lineBuffer.slice(position, position + valueLength).toString();
+    if (field === "data") {
+      data += value ? `${value}
+` : "\n";
+    } else if (field === "event") {
+      eventName = value;
+    } else if (field === "id" && !value.includes("\0")) {
+      lastEventId = value;
+    } else if (field === "retry" && /^\d+$/.test(value)) {
+      const retry = parseInt(value, 10);
+      onParse(new Retry({
+        duration: millis(retry),
+        lastEventId
+      }));
+    }
+  }
+}
+var BOM = "\uFEFF";
+var EventEncoded = /* @__PURE__ */ Struct({
+  id: /* @__PURE__ */ optional(String2),
+  event: String2,
+  data: String2
+});
+var Event = /* @__PURE__ */ Struct({
+  _tag: /* @__PURE__ */ tag("Event"),
+  id: /* @__PURE__ */ UndefinedOr(String2),
+  event: String2,
+  data: String2
+});
+var transformEvent = /* @__PURE__ */ transform({
+  decode: (event) => event.id === void 0 ? {
+    event: event.event,
+    data: event.data
+  } : {
+    id: event.id,
+    event: event.event,
+    data: event.data
+  },
+  encode: (event) => ({
+    _tag: "Event",
+    id: event.id,
+    event: event.event ?? "message",
+    data: event.data
+  })
+});
+var RetryTypeId = "~effect/encoding/Sse/Retry";
+var Retry = class _Retry extends (/* @__PURE__ */ TaggedClass("Retry")) {
+  /**
+   * Marks this value as an SSE retry directive for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [RetryTypeId] = RetryTypeId;
+  /**
+   * Returns `true` when the value is an SSE retry directive.
+   *
+   * @since 4.0.0
+   */
+  static is(u) {
+    return hasProperty(u, RetryTypeId);
+  }
+  /**
+   * Separates SSE retry directives from regular event values.
+   *
+   * @since 4.0.0
+   */
+  static filter(u) {
+    return _Retry.is(u) ? succeed(u) : fail(u);
+  }
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApiSchema.js
+var StreamSchemaTypeId = "~effect/httpapi/HttpApiSchema/Stream";
+function status(code) {
+  const statusCode = typeof code === "string" ? fromLiteral(code) : code;
+  return (self) => self.annotate({
+    httpApiStatus: statusCode
+  });
+}
+var Empty = (code) => Void.pipe(status(code));
+var NoContent = /* @__PURE__ */ Empty(204);
+var Created = /* @__PURE__ */ Empty(201);
+var Accepted = /* @__PURE__ */ Empty(202);
+function asNoContent(options2) {
+  return (self) => {
+    return Void.pipe(decodeTo(toType(self), transform({
+      decode: options2.decode,
+      encode: constVoid
+    })));
+  };
+}
+var streamSchema = /* @__PURE__ */ declare(isStream);
+var StreamSse = (options2) => {
+  const events = options2.events ?? (options2.data === void 0 ? void 0 : Struct({
+    ...EventEncoded.fields,
+    data: fromJsonString(options2.data)
+  }));
+  if (events === void 0) {
+    throw new Error("StreamSse requires either an events schema or a data schema");
+  }
+  return make(streamSchema.ast, {
+    [StreamSchemaTypeId]: StreamSchemaTypeId,
+    _tag: "StreamSse",
+    mode: "sse",
+    sseMode: options2.events === void 0 ? "data" : "events",
+    contentType: options2.contentType ?? defaultStreamContentType("sse"),
+    events,
+    error: options2.error ?? Never
+  });
+};
+var StreamUint8Array = (options2) => make(streamSchema.ast, {
+  [StreamSchemaTypeId]: StreamSchemaTypeId,
+  _tag: "StreamUint8Array",
+  mode: "uint8array",
+  contentType: options2?.contentType ?? defaultStreamContentType("uint8array")
+});
+var isStreamSchema = (u) => isSchema(u) && hasProperty(u, StreamSchemaTypeId);
+var isStreamSse = (u) => isStreamSchema(u) && u._tag === "StreamSse";
+var isStreamUint8Array = (u) => isStreamSchema(u) && u._tag === "StreamUint8Array";
+function defaultStreamContentType(mode) {
+  switch (mode) {
+    case "sse":
+      return "text/event-stream";
+    case "uint8array":
+      return "application/octet-stream";
+  }
+}
+var WithHeadersTypeId = "~effect/httpapi/HttpApiSchema/WithHeaders";
+var WithHeadersValueTypeId = "~effect/httpapi/HttpApiSchema/WithHeadersValue";
+var isWithHeadersValue = (u) => hasProperty(u, WithHeadersValueTypeId);
+var withHeadersValueSchema = /* @__PURE__ */ declare(isWithHeadersValue);
+function WithHeaders(schema, headers) {
+  if (isWithHeaders(schema)) {
+    throw new Error("WithHeaders schemas cannot be nested");
+  }
+  return make(withHeadersValueSchema.ast, {
+    [WithHeadersTypeId]: WithHeadersTypeId,
+    schema,
+    headers: isSchema(headers) ? headers : Struct(headers)
+  });
+}
+var withHeaders = (options2) => ({
+  [WithHeadersValueTypeId]: WithHeadersValueTypeId,
+  body: options2.body,
+  headers: options2.headers
+});
+var isWithHeaders = (u) => isSchema(u) && hasProperty(u, WithHeadersTypeId);
+function rebuildWithHeaders(self, schema, headers) {
+  return make(self.ast, {
+    [WithHeadersTypeId]: WithHeadersTypeId,
+    schema,
+    headers
+  });
+}
+function encodeToWithHeaders(options2, transformation) {
+  return (self) => {
+    const body = options2.body;
+    const headers = Struct(options2.headers);
+    const status2 = resolveHttpApiStatus(body.ast);
+    const encoding = resolveHttpApiEncoding(body.ast);
+    return Struct({
+      body,
+      headers
+    }).pipe(decodeTo(toType(self), transform(transformation))).annotate({
+      "~httpApiWithHeaders": {
+        body,
+        headers,
+        headersCodec: toEncoded2(headers)
+      },
+      httpApiStatus: status2,
+      "~httpApiEncoding": encoding
+    });
+  };
+}
+var MultipartTypeId = "~effect/httpapi/HttpApiSchema/Multipart";
+function asMultipart(options2) {
+  return (self) => self.pipe(brand(MultipartTypeId)).annotate({
+    "~httpApiEncoding": {
+      _tag: "Multipart",
+      mode: "buffered",
+      contentType: defaultContentType("Multipart"),
+      limits: options2
+    }
+  });
+}
+var MultipartStreamTypeId = "~effect/httpapi/HttpApiSchema/MultipartStream";
+function asMultipartStream(options2) {
+  return (self) => self.pipe(brand(MultipartStreamTypeId)).annotate({
+    "~httpApiEncoding": {
+      _tag: "Multipart",
+      mode: "stream",
+      contentType: defaultContentType("Multipart"),
+      limits: options2
+    }
+  });
+}
+function asNonMultipartEncoding(self, options2) {
+  return self.annotate({
+    "~httpApiEncoding": {
+      _tag: options2._tag,
+      contentType: options2.contentType ?? defaultContentType(options2._tag)
+    }
+  });
+}
+function defaultContentType(_tag) {
+  switch (_tag) {
+    case "Multipart":
+      return "multipart/form-data";
+    case "Json":
+      return "application/json";
+    case "FormUrlEncoded":
+      return "application/x-www-form-urlencoded";
+    case "Uint8Array":
+      return "application/octet-stream";
+    case "Text":
+      return "text/plain";
+  }
+}
+function asJson(options2) {
+  return (self) => asNonMultipartEncoding(self, {
+    _tag: "Json",
+    ...options2
+  });
+}
+function asFormUrlEncoded(options2) {
+  return (self) => asNonMultipartEncoding(self, {
+    _tag: "FormUrlEncoded",
+    ...options2
+  });
+}
+function asText(options2) {
+  return (self) => asNonMultipartEncoding(self, {
+    _tag: "Text",
+    ...options2
+  });
+}
+function asUint8Array(options2) {
+  return (self) => asNonMultipartEncoding(self, {
+    _tag: "Uint8Array",
+    ...options2
+  });
+}
+var isNoContent = (ast) => {
+  if (isVoid(ast)) return true;
+  const encoded = toEncoded(ast);
+  if (isVoid(encoded)) return true;
+  const target = ast.encoding?.[0].to;
+  if (target === void 0) return false;
+  return isVoid(target);
+};
+var resolveHttpApiEncoding = /* @__PURE__ */ resolveAt("~httpApiEncoding");
+var getWithHeadersAnnotation = /* @__PURE__ */ resolveAt("~httpApiWithHeaders");
+var resolveHttpApiStatus = /* @__PURE__ */ resolveAt("httpApiStatus");
+var defaultJsonEncoding = {
+  _tag: "Json",
+  contentType: "application/json"
+};
+var defaultUrlEncodedEncoding = {
+  _tag: "FormUrlEncoded",
+  contentType: "application/x-www-form-urlencoded"
+};
+function getEncoding(ast) {
+  return resolveHttpApiEncoding(ast) ?? defaultJsonEncoding;
+}
+function getPayloadEncoding(ast, method) {
+  const encoding = resolveHttpApiEncoding(ast);
+  if (encoding) return encoding;
+  return hasBody(method) ? defaultJsonEncoding : defaultUrlEncodedEncoding;
+}
+function getResponseEncoding(ast) {
+  const out = getEncoding(ast);
+  if (out._tag === "Multipart") {
+    throw new Error("Multipart is not supported in response");
+  }
+  return out;
+}
+function getStatusSuccess(self) {
+  return resolveHttpApiStatus(self) ?? 200;
+}
+function getStatusSuccessSchema(schema) {
+  if (isWithHeaders(schema)) {
+    return resolveHttpApiStatus(schema.ast) ?? getStatusSuccess(schema.schema.ast);
+  }
+  return getStatusSuccess(schema.ast);
+}
+function getResponseEncodingSchema(schema) {
+  if (isWithHeaders(schema) && resolveHttpApiEncoding(schema.ast) === void 0) {
+    return getResponseEncoding(schema.schema.ast);
+  }
+  return getResponseEncoding(schema.ast);
+}
+function getStatusError(self) {
+  return resolveHttpApiStatus(self) ?? 500;
+}
+function getStatusErrorSchema(schema) {
+  if (isWithHeaders(schema)) {
+    return resolveHttpApiStatus(schema.ast) ?? getStatusError(schema.schema.ast);
+  }
+  return getStatusError(schema.ast);
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/internal/mediaType.js
+function normalize(contentType) {
+  const normalized = contentType.toLowerCase().trim();
+  const index = normalized.indexOf(";");
+  return index === -1 ? normalized : normalized.slice(0, index).trim();
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApiEndpoint.js
+var TypeId = "~effect/httpapi/HttpApiEndpoint";
+var isHttpApiEndpoint = (u) => hasProperty(u, TypeId);
+function getPayloadSchemas(endpoint2) {
+  const result = [];
+  for (const {
+    schemas
+  } of endpoint2.payload.values()) {
+    result.push(...schemas);
+  }
+  return result;
+}
+function getSuccessSchemas(endpoint2) {
+  const schemas = Array.from(endpoint2.success);
+  return isArrayNonEmpty(schemas) ? schemas : [NoContent];
+}
+function getErrorSchemas(endpoint2) {
+  const schemas = new Set(endpoint2.error);
+  const transform2 = endpoint2.disableCodecs ? identity : transformResponseSchema;
+  for (const middleware of endpoint2.middlewares) {
+    const key = middleware;
+    for (const schema of key.error) {
+      schemas.add(transform2(schema));
+    }
+  }
+  return Array.from(schemas);
+}
+var Proto = {
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  prefix(prefix) {
+    return makeProto({
+      ...optionsFromEndpoint(this),
+      path: prefixPath(this.path, prefix)
+    });
+  },
+  middleware(middleware) {
+    return makeProto({
+      ...optionsFromEndpoint(this),
+      middlewares: /* @__PURE__ */ new Set([...this.middlewares, middleware])
+    });
+  },
+  annotate(key, value) {
+    return makeProto({
+      ...optionsFromEndpoint(this),
+      annotations: add(this.annotations, key, value)
+    });
+  },
+  annotateMerge(annotations) {
+    return makeProto({
+      ...optionsFromEndpoint(this),
+      annotations: merge(this.annotations, annotations)
+    });
+  }
+};
+var optionsFromEndpoint = (endpoint2) => ({
+  identifier: endpoint2.identifier,
+  path: endpoint2.path,
+  method: endpoint2.method,
+  params: endpoint2.params,
+  query: endpoint2.query,
+  headers: endpoint2.headers,
+  payload: endpoint2.payload,
+  success: endpoint2.success,
+  error: endpoint2.error,
+  annotations: endpoint2.annotations,
+  middlewares: endpoint2.middlewares,
+  disableCodecs: endpoint2.disableCodecs
+});
+function makeProto(options2) {
+  function HttpApiEndpoint() {
+  }
+  Object.setPrototypeOf(HttpApiEndpoint, Proto);
+  return Object.assign(HttpApiEndpoint, options2);
+}
+var make3 = (method) => (identifier, path, options2) => {
+  const disableCodecs = options2?.disableCodecs ?? false;
+  const transformStringTree = disableCodecs ? identity : toCodecStringTree;
+  return makeProto({
+    identifier,
+    path,
+    method,
+    params: ensureStruct(options2?.params, transformStringTree),
+    query: ensureStruct(options2?.query, transformStringTree),
+    headers: ensureStruct(options2?.headers, transformStringTree),
+    payload: getPayload(options2?.payload, method, disableCodecs),
+    success: getSuccessResponse(options2?.success, method, disableCodecs),
+    error: getErrorResponse(options2?.error, disableCodecs),
+    annotations: empty(),
+    middlewares: /* @__PURE__ */ new Set(),
+    disableCodecs
+  });
+};
+function ensureStruct(params, transform2) {
+  if (params === void 0) return void 0;
+  if (isSchema(params)) return transform2(params);
+  return transform2(Struct(params));
+}
+function getPayload(payload, method, disableCodecs) {
+  const result = /* @__PURE__ */ new Map();
+  if (payload === void 0) return result;
+  const schemas = Array.isArray(payload) ? payload : isSchema(payload) ? [payload] : [Struct(payload).pipe(asFormUrlEncoded())];
+  const transform2 = disableCodecs ? identity : transformPayload;
+  for (const schema of schemas) {
+    const encoding = getPayloadEncoding(schema.ast, method);
+    const contentType = normalize(encoding.contentType);
+    const existing = result.get(contentType);
+    if (existing) {
+      if (existing.encoding._tag !== encoding._tag) {
+        throw new Error(`Multiple payload encodings for content-type: ${encoding.contentType}`);
+      }
+      if (existing.encoding._tag === "Multipart") {
+        throw new Error(`Multiple multipart payloads for content-type: ${encoding.contentType}`);
+      }
+      existing.schemas.push(transform2(schema, method));
+    } else {
+      result.set(contentType, {
+        encoding,
+        schemas: [transform2(schema, method)]
+      });
+    }
+  }
+  return result;
+}
+var reservedStreamFailureEvent = "effect/httpapi/stream/failure";
+function getSuccessResponse(success, method, disableCodecs) {
+  if (success === void 0) return /* @__PURE__ */ new Set();
+  const schemas = ensure(success);
+  validateSuccessResponse(schemas, method);
+  return new Set(disableCodecs ? schemas : schemas.map(transformResponseSchema));
+}
+var transformResponseSchema = /* @__PURE__ */ memoize((schema) => {
+  if (isStreamSchema(schema)) return schema;
+  if (isWithHeaders(schema)) {
+    const inner = isStreamSchema(schema.schema) ? schema.schema : applyResponseEncoding(schema.schema, getResponseEncodingSchema(schema));
+    return rebuildWithHeaders(schema, inner, toCodecStringTree(schema.headers));
+  }
+  return transformResponse(schema);
+});
+function getErrorResponse(error, disableCodecs) {
+  if (error === void 0) return /* @__PURE__ */ new Set();
+  const schemas = ensure(error);
+  for (const schema of schemas) {
+    const body = isWithHeaders(schema) ? schema.schema : schema;
+    if (isStreamSchema(body)) {
+      throw new Error("Streaming schemas are not supported in error responses");
+    }
+  }
+  validateResponseExclusivity(schemas, getStatusErrorSchema);
+  return new Set(disableCodecs ? schemas : schemas.map(transformResponseSchema));
+}
+function validateSuccessResponse(schemas, method) {
+  let hasStream = false;
+  const statuses = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const inner = isWithHeaders(schema) ? schema.schema : schema;
+    const status2 = getStatusSuccessSchema(schema);
+    if (isStreamSchema(inner)) {
+      validateStreamSuccess(inner, method);
+      if (hasStream) {
+        throw new Error("Multiple streaming success responses are not supported");
+      }
+      hasStream = true;
+      const entry = getStatusEntry(statuses, status2);
+      if (entry.noContent) {
+        throw new Error(`Cannot combine no-content and streaming success responses for status: ${status2}`);
+      }
+      if (entry.bufferedContentTypes.has(normalize(inner.contentType))) {
+        throw new Error(`Cannot combine buffered and streaming success responses for status ${status2} and content-type: ${inner.contentType}`);
+      }
+      statuses.set(status2, {
+        ...entry,
+        stream: inner
+      });
+    } else {
+      const entry = getStatusEntry(statuses, status2);
+      const noContent = isNoContent(inner.ast);
+      if (entry.stream !== void 0) {
+        if (noContent) {
+          throw new Error(`Cannot combine no-content and streaming success responses for status: ${status2}`);
+        }
+        const encoding = getResponseEncodingSchema(schema);
+        if (normalize(encoding.contentType) === normalize(entry.stream.contentType)) {
+          throw new Error(`Cannot combine buffered and streaming success responses for status ${status2} and content-type: ${encoding.contentType}`);
+        }
+      }
+      if (!noContent) {
+        entry.bufferedContentTypes.add(normalize(getResponseEncodingSchema(schema).contentType));
+      }
+      entry.noContent = entry.noContent || noContent;
+    }
+  }
+  validateResponseExclusivity(schemas, getStatusSuccessSchema);
+}
+function getStatusEntry(statuses, status2) {
+  let entry = statuses.get(status2);
+  if (entry === void 0) {
+    entry = {
+      bufferedContentTypes: /* @__PURE__ */ new Set(),
+      noContent: false
+    };
+    statuses.set(status2, entry);
+  }
+  return entry;
+}
+function validateResponseExclusivity(schemas, getStatus) {
+  const statuses = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const status2 = getStatus(schema);
+    const withHeadersAnnotation = getWithHeadersAnnotation(schema.ast);
+    const body = isWithHeaders(schema) ? schema.schema : withHeadersAnnotation?.body ?? schema;
+    const contentType = isNoContent(body.ast) ? "" : normalize(isStreamSchema(body) ? body.contentType : getResponseEncodingSchema(schema).contentType);
+    let entry = statuses.get(status2);
+    if (entry === void 0) {
+      entry = {
+        headerContentType: void 0,
+        plainContentTypes: /* @__PURE__ */ new Set()
+      };
+      statuses.set(status2, entry);
+    }
+    const combineError = () => new Error(`Cannot combine a response with headers with another response for status ${status2} and content-type: ${contentType || "<no content>"}`);
+    if (isWithHeaders(schema) || withHeadersAnnotation !== void 0) {
+      if (entry.headerContentType !== void 0) {
+        throw new Error(`Cannot declare multiple responses with headers for status ${status2}`);
+      }
+      if (entry.plainContentTypes.has(contentType)) throw combineError();
+      entry.headerContentType = contentType;
+    } else {
+      if (entry.headerContentType === contentType) throw combineError();
+      entry.plainContentTypes.add(contentType);
+    }
+  }
+}
+function validateStreamSuccess(schema, method) {
+  if (method === "HEAD") {
+    throw new Error("HEAD endpoints cannot declare streaming success responses");
+  }
+  if (isStreamSse(schema) && hasReservedSseEventName(schema.events.ast)) {
+    throw new Error(`SSE event name is reserved: ${reservedStreamFailureEvent}`);
+  }
+}
+function hasReservedSseEventName(ast) {
+  return hasReservedEventName(toEncoded(ast), /* @__PURE__ */ new Set());
+}
+function hasReservedEventName(ast, seen) {
+  if (seen.has(ast)) return false;
+  seen.add(ast);
+  if (isUnion(ast)) {
+    return ast.types.some((type) => hasReservedEventName(type, seen));
+  }
+  if (isSuspend(ast)) {
+    return hasReservedEventName(ast.thunk(), seen);
+  }
+  if (!isObjects(ast)) return false;
+  const event = ast.propertySignatures.find((ps) => ps.name === "event");
+  return event !== void 0 && hasReservedEventLiteral(event.type, seen);
+}
+function hasReservedEventLiteral(ast, seen) {
+  if (seen.has(ast)) return false;
+  seen.add(ast);
+  const encoded = toEncoded(ast);
+  if (encoded !== ast) {
+    return hasReservedEventLiteral(encoded, seen);
+  }
+  if (isLiteral(ast)) {
+    return ast.literal === reservedStreamFailureEvent;
+  }
+  if (isUnion(ast)) {
+    return ast.types.some((type) => hasReservedEventLiteral(type, seen));
+  }
+  if (isSuspend(ast)) {
+    return hasReservedEventLiteral(ast.thunk(), seen);
+  }
+  return false;
+}
+function transformResponse(schema) {
+  const encoding = getResponseEncoding(schema.ast);
+  const withHeaders2 = getWithHeadersAnnotation(schema.ast);
+  if (withHeaders2 === void 0) {
+    return applyResponseEncoding(schema, encoding);
+  }
+  const headers = toEncoded2(withHeaders2.headers);
+  return Struct({
+    body: applyResponseEncoding(toEncoded2(withHeaders2.body), encoding),
+    headers
+  }).pipe(decodeTo(schema)).annotate({
+    "~httpApiWithHeaders": {
+      ...withHeaders2,
+      headersCodec: toCodecStringTree(headers)
+    }
+  });
+}
+function applyResponseEncoding(schema, encoding) {
+  switch (encoding._tag) {
+    case "Json":
+      return toCodecJson(schema);
+    case "FormUrlEncoded":
+      return toCodecStringTree(schema);
+    case "Text":
+    case "Uint8Array":
+      return schema;
+  }
+}
+function transformPayload(schema, method) {
+  const encoding = getPayloadEncoding(schema.ast, method);
+  switch (encoding._tag) {
+    case "Json":
+      return toCodecJson(schema);
+    case "FormUrlEncoded":
+      return toCodecStringTree(schema);
+    case "Text":
+    case "Uint8Array":
+    case "Multipart":
+      return schema;
+  }
+}
+var get2 = /* @__PURE__ */ make3("GET");
+var query = /* @__PURE__ */ make3("QUERY");
+var post = /* @__PURE__ */ make3("POST");
+var put = /* @__PURE__ */ make3("PUT");
+var patch = /* @__PURE__ */ make3("PATCH");
+var del = /* @__PURE__ */ make3("DELETE");
+var head = /* @__PURE__ */ make3("HEAD");
+var options = /* @__PURE__ */ make3("OPTIONS");
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApi.js
+var TypeId2 = "~effect/httpapi/HttpApi";
+var isHttpApi = (u) => hasProperty(u, TypeId2);
+var Proto2 = {
+  [TypeId2]: TypeId2,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  add(...toAdd) {
+    const groups = {
+      ...this.groups
+    };
+    for (const group2 of toAdd) {
+      assignProperty(groups, group2.identifier, group2);
+    }
+    return makeProto2({
+      ...optionsFromApi(this),
+      groups
+    });
+  },
+  addHttpApi(api) {
+    const newGroups = {
+      ...this.groups
+    };
+    for (const key of Object.keys(api.groups)) {
+      const group2 = api.groups[key];
+      assignProperty(newGroups, key, group2.annotateMerge(merge(api.annotations, group2.annotations)));
+    }
+    return makeProto2({
+      ...optionsFromApi(this),
+      groups: newGroups
+    });
+  },
+  prefix(prefix) {
+    return makeProto2({
+      ...optionsFromApi(this),
+      groups: map(this.groups, (group2) => group2.prefix(prefix))
+    });
+  },
+  middleware(tag2) {
+    return makeProto2({
+      ...optionsFromApi(this),
+      groups: map(this.groups, (group2) => group2.middleware(tag2))
+    });
+  },
+  annotate(key, value) {
+    return makeProto2({
+      ...optionsFromApi(this),
+      annotations: add(this.annotations, key, value)
+    });
+  },
+  annotateMerge(annotations) {
+    return makeProto2({
+      ...optionsFromApi(this),
+      annotations: merge(this.annotations, annotations)
+    });
+  }
+};
+var optionsFromApi = (api) => ({
+  identifier: api.identifier,
+  groups: api.groups,
+  annotations: api.annotations
+});
+var makeProto2 = (options2) => {
+  function HttpApi() {
+  }
+  Object.setPrototypeOf(HttpApi, Proto2);
+  return Object.assign(HttpApi, options2);
+};
+var make4 = (identifier) => makeProto2({
+  identifier,
+  groups: {},
+  annotations: empty()
+});
+var reflect = (self, options2) => {
+  const groups = Object.values(self.groups);
+  for (const group2 of groups) {
+    const groupAnnotations = merge(self.annotations, group2.annotations);
+    options2.onGroup({
+      group: group2,
+      mergedAnnotations: groupAnnotations
+    });
+    const endpoints = Object.values(group2.endpoints);
+    for (const endpoint2 of endpoints) {
+      if (options2.predicate && !options2.predicate({
+        endpoint: endpoint2,
+        group: group2
+      })) continue;
+      options2.onEndpoint({
+        group: group2,
+        endpoint: endpoint2,
+        middleware: endpoint2.middlewares,
+        mergedAnnotations: merge(groupAnnotations, endpoint2.annotations),
+        successes: extractResponseContent(getSuccessSchemas(endpoint2), getStatusSuccessSchema),
+        errors: extractResponseContent(getErrorSchemas(endpoint2), getStatusErrorSchema)
+      });
+    }
+  }
+};
+var extractResponseContent = (schemas, getStatus) => {
+  const map7 = /* @__PURE__ */ new Map();
+  schemas.forEach(add2);
+  return map7;
+  function add2(schema) {
+    const body = isWithHeaders(schema) ? schema.schema : schema;
+    if (isStreamSchema(body)) return;
+    const status2 = getStatus(schema);
+    const schemas2 = map7.get(status2);
+    if (schemas2 === void 0) {
+      map7.set(status2, [schema]);
+    } else {
+      schemas2.push(schema);
+    }
+  }
+};
+var AdditionalSchemas = class extends (/* @__PURE__ */ Service()("effect/httpapi/HttpApi/AdditionalSchemas")) {
+};
+var ParseOptions = class extends (/* @__PURE__ */ Service()("effect/httpapi/HttpApi/ParseOptions")) {
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/internal/path.js
+var emptyParamNames = /* @__PURE__ */ new Set();
+function getParamNames(schema) {
+  if (schema === void 0) return emptyParamNames;
+  const ast = getLastEncoding(schema.ast);
+  return isObjects(ast) && ast.indexSignatures.length === 0 ? new Set(ast.propertySignatures.map((ps) => String(ps.name))) : void 0;
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApiClient.js
+var HttpApiClient_exports = {};
+__export(HttpApiClient_exports, {
+  endpoint: () => endpoint,
+  group: () => group,
+  make: () => make5,
+  makeClient: () => makeClient,
+  makeWith: () => makeWith,
+  urlBuilder: () => urlBuilder
+});
+var makeClient = (api, options2) => gen(function* () {
+  const services = yield* context();
+  const httpClient = options2.httpClient.pipe(options2?.baseUrl === void 0 ? identity : mapRequest(prependUrl(options2.baseUrl.toString())));
+  function executeMiddleware(group2, endpoint2, request, middlewareKeys, index) {
+    if (index === -1) {
+      return httpClient.execute(request);
+    }
+    const middleware = services.mapUnsafe.get(middlewareKeys[index]);
+    if (middleware === void 0) {
+      return executeMiddleware(group2, endpoint2, request, middlewareKeys, index - 1);
+    }
+    return middleware({
+      endpoint: endpoint2,
+      group: group2,
+      request,
+      next(request2) {
+        return executeMiddleware(group2, endpoint2, request2, middlewareKeys, index - 1);
+      }
+    });
+  }
+  reflect(api, {
+    predicate: options2?.predicate,
+    onGroup(onGroupOptions) {
+      options2.onGroup?.(onGroupOptions);
+    },
+    onEndpoint(onEndpointOptions) {
+      const {
+        group: group2,
+        endpoint: endpoint2,
+        errors: errors2,
+        successes,
+        mergedAnnotations
+      } = onEndpointOptions;
+      const parseOptions = getOrUndefined(mergedAnnotations, ParseOptions);
+      const makeUrl = compilePath(endpoint2.path, endpoint2.params);
+      const decodeMap = {
+        orElse: statusOrElse
+      };
+      const errorAlternatives = /* @__PURE__ */ new Map();
+      for (const [status2, schemas] of errors2.entries()) {
+        const grouped = groupSchemasByContentType(schemas);
+        for (const [contentType, schemas2] of grouped.entries()) {
+          addResponseAlternative(errorAlternatives, status2, contentType, schemasToResponse(schemas2, parseOptions));
+        }
+      }
+      for (const [status2, alternatives] of errorAlternatives.entries()) {
+        const decode3 = makeResponseDecoder(alternatives);
+        decodeMap[status2] = (response) => flatMap(catchCause(decode3(response), (cause) => failCause(combine(fail2(new HttpClientError({
+          reason: new StatusCodeError({
+            request: response.request,
+            response
+          })
+        })), cause))), fail3);
+      }
+      const successAlternatives = /* @__PURE__ */ new Map();
+      for (const [status2, schemas] of successes.entries()) {
+        const grouped = groupSchemasByContentType(schemas);
+        for (const [contentType, schemas2] of grouped.entries()) {
+          addResponseAlternative(successAlternatives, status2, contentType, schemasToResponse(schemas2, parseOptions));
+        }
+      }
+      for (const streamSuccess of getStreamSuccessSchemas(endpoint2)) {
+        const streamSchema2 = isWithHeadersStreamSuccess(streamSuccess) ? streamSuccess.schema : streamSuccess;
+        addResponseAlternative(successAlternatives, getStatusSuccessSchema(streamSuccess), streamSchema2.contentType, streamToResponse(streamSuccess, parseOptions));
+      }
+      for (const [status2, alternatives] of successAlternatives.entries()) {
+        decodeMap[status2] = makeResponseDecoder(alternatives);
+      }
+      const encodeUnknownEffect2 = (schema) => encodeUnknownEffect(schema, parseOptions);
+      const encodeParams = map4(endpoint2.params, encodeUnknownEffect2);
+      const payloadSchemas = getPayloadSchemas(endpoint2);
+      const encodePayload = isArrayNonEmpty(payloadSchemas) ? hasBody(endpoint2.method) ? encodeUnknownEffect2(getEncodePayloadSchema(payloadSchemas, endpoint2.method)) : encodeUnknownEffect2(Union(payloadSchemas)) : void 0;
+      const encodeHeaders = map4(endpoint2.headers, encodeUnknownEffect2);
+      const encodeQuery = map4(endpoint2.query, encodeUnknownEffect2);
+      const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag2) => `${tag2.key}/Client`);
+      const endpointFn = fnUntraced(function* (request) {
+        let httpRequest = make2(endpoint2.method)(endpoint2.path);
+        if (request !== void 0) {
+          if (encodeParams !== void 0) {
+            const params = yield* encodeParams(request.params);
+            httpRequest = setUrl(httpRequest, makeUrl(params));
+          }
+          if (encodePayload !== void 0) {
+            if (hasBody(endpoint2.method)) {
+              if (request.payload instanceof FormData) {
+                httpRequest = bodyFormData(httpRequest, request.payload);
+              } else {
+                const body = yield* encodePayload(request.payload);
+                httpRequest = setBody(httpRequest, body);
+              }
+            } else {
+              const urlParams2 = yield* encodePayload(request.payload);
+              httpRequest = appendUrlParams(httpRequest, urlParams2);
+            }
+          }
+          if (encodeHeaders !== void 0) {
+            const headers = yield* encodeHeaders(request.headers);
+            httpRequest = setHeaders(httpRequest, headers);
+          }
+          if (encodeQuery !== void 0) {
+            const query2 = yield* encodeQuery(request.query);
+            httpRequest = appendUrlParams(httpRequest, query2);
+          }
+        }
+        const response = yield* executeMiddleware(group2, endpoint2, httpRequest, middlewareKeys, middlewareKeys.length - 1);
+        if (request?.responseMode === "response-only") {
+          return response;
+        }
+        const decoded = (decodeMap[response.status] ?? decodeMap.orElse)(response, request?.sseOptions);
+        const value = yield* options2.transformResponse === void 0 ? decoded : options2.transformResponse(decoded);
+        return request?.responseMode === "decoded-and-response" ? [value, response] : value;
+      });
+      options2.onEndpoint({
+        ...onEndpointOptions,
+        endpointFn
+      });
+    }
+  });
+});
+var make5 = (api, options2) => flatMap(HttpClient, (httpClient) => makeWith(api, {
+  ...options2,
+  httpClient: options2?.transformClient ? options2.transformClient(httpClient) : httpClient
+}));
+var makeWith = (api, options2) => {
+  const client = {};
+  return makeClient(api, {
+    ...options2,
+    onGroup({
+      group: group2
+    }) {
+      if (group2.topLevel) return;
+      assignProperty(client, group2.identifier, {});
+    },
+    onEndpoint({
+      endpoint: endpoint2,
+      endpointFn,
+      group: group2
+    }) {
+      assignProperty(group2.topLevel ? client : client[group2.identifier], endpoint2.identifier, endpointFn);
+    }
+  }).pipe(as(client));
+};
+var group = (api, options2) => {
+  const client = {};
+  return makeClient(api, {
+    ...options2,
+    predicate: ({
+      group: group2
+    }) => group2.identifier === options2.group,
+    onEndpoint({
+      endpoint: endpoint2,
+      endpointFn
+    }) {
+      assignProperty(client, endpoint2.identifier, endpointFn);
+    }
+  }).pipe(map2(() => client));
+};
+var endpoint = (api, options2) => {
+  let client = void 0;
+  return makeClient(api, {
+    ...options2,
+    httpClient: options2.transformClient ? options2.transformClient(options2.httpClient) : options2.httpClient,
+    predicate: ({
+      endpoint: endpoint2,
+      group: group2
+    }) => group2.identifier === options2.group && endpoint2.identifier === options2.endpoint,
+    onEndpoint({
+      endpointFn
+    }) {
+      client = endpointFn;
+    }
+  }).pipe(map2(() => client));
+};
+var urlBuilder = (api, options2) => {
+  const builder = {};
+  reflect(api, {
+    onGroup({
+      group: group2
+    }) {
+      if (group2.topLevel) return;
+      assignProperty(builder, group2.identifier, {});
+    },
+    onEndpoint({
+      group: group2,
+      endpoint: endpoint2,
+      mergedAnnotations
+    }) {
+      const parseOptions = getOrUndefined(mergedAnnotations, ParseOptions);
+      const makeUrl = compilePath(endpoint2.path, endpoint2.params);
+      const encodeParams = endpoint2.params === void 0 ? void 0 : encodeSync(endpoint2.params, parseOptions);
+      const encodeQuery = endpoint2.query === void 0 ? void 0 : encodeSync(endpoint2.query, parseOptions);
+      const endpointBuilder = (request) => {
+        const params = request?.params;
+        const path = params === void 0 ? endpoint2.path : makeUrl(encodeParams === void 0 ? params : encodeParams(params));
+        const queryInput = request?.query === void 0 ? void 0 : encodeQuery === void 0 ? request.query : encodeQuery(request.query);
+        const urlParams2 = queryInput === void 0 ? empty2 : fromInput(queryInput);
+        if (options2?.baseUrl === void 0) {
+          const query2 = toString(urlParams2);
+          return query2 === "" ? path : `${path}?${query2}`;
+        }
+        const url = new URL(prependUrl(get(path), options2.baseUrl.toString()).url);
+        for (const [key, value] of urlParams2.params) {
+          if (value !== void 0) {
+            url.searchParams.append(key, value);
+          }
+        }
+        return url.toString();
+      };
+      assignProperty(group2.topLevel ? builder : builder[group2.identifier], endpoint2.identifier, endpointBuilder);
+    }
+  });
+  return builder;
+};
+var paramsRegExp = /(\/?):(\w+)(\?)?/g;
+var compilePath = (path, schema) => {
+  if (schema === void 0 || !path.includes(":")) {
+    return (_) => path;
+  }
+  const paramNames = getParamNames(schema);
+  return (params) => {
+    return path.replace(paramsRegExp, (match, slash, key, optional2) => {
+      if (paramNames !== void 0 && !paramNames.has(key)) {
+        return match;
+      }
+      const value = params[key];
+      if (value === void 0) {
+        if (optional2 !== void 0) {
+          return "";
+        }
+        throw new Error(`Missing path parameter: ${key}`);
+      }
+      return `${slash}${encodeURIComponent(value)}`;
+    });
+  };
+};
+function schemasToResponse(schemas, options2) {
+  const hasWithHeaders = schemas.some((schema) => isWithHeaders(schema) || getWithHeadersAnnotation(schema.ast) !== void 0);
+  const codec = hasWithHeaders ? Union(schemas.map(toCodecArrayBufferWithHeaders)) : toCodecArrayBuffer(schemas);
+  const decode3 = decodeEffect(codec, options2);
+  return (response) => flatMap(response.arrayBuffer, hasWithHeaders ? (body) => decode3({
+    body,
+    headers: response.headers
+  }) : decode3);
+}
+function toCodecArrayBufferWithHeaders(schema) {
+  const isWithHeaders2 = isWithHeaders(schema);
+  const annotation = getWithHeadersAnnotation(schema.ast);
+  if (annotation !== void 0) {
+    return Struct({
+      body: fromArrayBuffer(annotation.body),
+      headers: annotation.headersCodec
+    }).pipe(decodeTo(schema));
+  }
+  const body = isWithHeaders2 ? schema.schema : schema;
+  return Struct({
+    body: fromArrayBuffer(body).pipe(decodeTo(body)),
+    headers: isWithHeaders2 ? schema.headers : Unknown
+  }).pipe(decodeTo(isWithHeaders2 ? schema : toType(schema), transform({
+    decode: (value) => isWithHeaders2 ? withHeaders(value) : value.body,
+    encode: (value) => isWithHeaders2 ? value : {
+      body: value,
+      headers: void 0
+    }
+  })));
+}
+function addResponseAlternative(map7, status2, contentType, decode3) {
+  const normalizedContentType = normalize(contentType);
+  const alternatives = map7.get(status2);
+  if (alternatives === void 0) {
+    map7.set(status2, [{
+      contentType: normalizedContentType,
+      decode: decode3
+    }]);
+  } else {
+    alternatives.push({
+      contentType: normalizedContentType,
+      decode: decode3
+    });
+  }
+}
+function makeResponseDecoder(alternatives) {
+  const first = alternatives[0];
+  if (alternatives.length === 1 && first !== void 0) {
+    return first.decode;
+  }
+  return (response, sseOptions) => {
+    const contentType = normalize(response.headers["content-type"] ?? "");
+    const alternative = alternatives.find((alternative2) => alternative2.contentType === contentType);
+    return alternative === void 0 ? failUnsupportedContentType(response, contentType, alternatives) : alternative.decode(response, sseOptions);
+  };
+}
+function groupSchemasByContentType(schemas) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const body = isWithHeaders(schema) ? schema.schema : schema;
+    const contentType = isNoContent(body.ast) ? "" : normalize(getResponseEncodingSchema(schema).contentType);
+    const existing = grouped.get(contentType);
+    if (existing === void 0) {
+      grouped.set(contentType, [schema]);
+    } else {
+      existing.push(schema);
+    }
+  }
+  return grouped;
+}
+function failUnsupportedContentType(response, contentType, alternatives) {
+  const expected = Array.from(new Set(alternatives.map((alternative) => alternative.contentType))).join(", ");
+  return fail3(new HttpClientError({
+    reason: new DecodeError({
+      request: response.request,
+      response,
+      description: `Unsupported response content-type for status ${response.status}: ${contentType || "<missing>"}. Expected one of: ${expected}`
+    })
+  }));
+}
+var reservedStreamFailureEvent2 = "effect/httpapi/stream/failure";
+var isWithHeadersStreamSuccess = (schema) => isWithHeaders(schema);
+function getStreamSuccessSchemas(endpoint2) {
+  const schemas = [];
+  for (const schema of endpoint2.success) {
+    const body = isWithHeaders(schema) ? schema.schema : schema;
+    if (isStreamSchema(body)) {
+      schemas.push(schema);
+    }
+  }
+  return schemas;
+}
+function streamToResponse(successSchema, options2) {
+  const isWithHeaders2 = isWithHeadersStreamSuccess(successSchema);
+  const streamSchema2 = isWithHeaders2 ? successSchema.schema : successSchema;
+  const sse = isStreamUint8Array(streamSchema2) ? void 0 : {
+    declaration: streamSchema2,
+    decoder: makeSseDecoder(streamSchema2, options2)
+  };
+  const toStream = (response, sseOptions) => map2(context(), (context2) => provideContext(sse === void 0 ? response.stream : decodeSseStream(response.stream, sse.declaration, sse.decoder(sseOptions)), context2));
+  if (!isWithHeaders2) return toStream;
+  const decodeHeaders = decodeUnknownEffect(successSchema.headers, options2);
+  return (response, sseOptions) => flatMap(decodeHeaders(response.headers), (headers) => map2(toStream(response, sseOptions), (body) => withHeaders({
+    body,
+    headers
+  })));
+}
+function makeSseDecoder(declaration, parseOptions) {
+  const Event2 = Union([Struct({
+    id: optional(String2),
+    event: Literal(reservedStreamFailureEvent2),
+    data: fromJsonString(toCodecJson(Cause(declaration.error, Defect())))
+  }), declaration.events]);
+  const defaultDecoder = decodeSchema(Event2, void 0, parseOptions);
+  return (options2) => options2 === void 0 ? defaultDecoder : decodeSchema(Event2, options2, parseOptions);
+}
+function decodeSseStream(stream, declaration, decoder) {
+  const events = transformPull(stream.pipe(decodeText, pipeThroughChannel(decoder)), (pull) => sync(() => {
+    let pendingFailureCause = void 0;
+    return suspend(() => {
+      if (pendingFailureCause !== void 0) {
+        return failCause(pendingFailureCause);
+      }
+      return flatMap(pull, (events2) => {
+        for (let i = 0; i < events2.length; i++) {
+          const event = events2[i];
+          if (event.event === reservedStreamFailureEvent2 && isCause(event.data)) {
+            if (i === 0) {
+              return failCause(event.data);
+            }
+            pendingFailureCause = event.data;
+            events2 = events2.slice(0, i);
+            break;
+          }
+        }
+        return succeed2(events2);
+      });
+    });
+  }));
+  if (declaration.sseMode === "data") {
+    return map3(events, (event) => event.data);
+  }
+  return events;
+}
+var ArrayBuffer = /* @__PURE__ */ instanceOf(globalThis.ArrayBuffer, {
+  expected: "ArrayBuffer"
+});
+var Uint8ArrayFromArrayBuffer = /* @__PURE__ */ ArrayBuffer.pipe(/* @__PURE__ */ decodeTo(Uint8Array2, /* @__PURE__ */ transform({
+  decode(fromA) {
+    return new Uint8Array(fromA);
+  },
+  encode(arr) {
+    return arr.byteLength === arr.buffer.byteLength ? arr.buffer : arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
+  }
+})));
+var StringFromArrayBuffer = /* @__PURE__ */ ArrayBuffer.pipe(/* @__PURE__ */ decodeTo(String2, /* @__PURE__ */ transform({
+  decode(fromA) {
+    return new TextDecoder().decode(fromA);
+  },
+  encode(toI) {
+    const arr = new TextEncoder().encode(toI);
+    return arr.byteLength === arr.buffer.byteLength ? arr.buffer : arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
+  }
+})));
+var UnknownFromArrayBuffer = /* @__PURE__ */ StringFromArrayBuffer.pipe(/* @__PURE__ */ decodeTo(/* @__PURE__ */ Union([
+  // Handle No Content
+  /* @__PURE__ */ Literal("").pipe(/* @__PURE__ */ decodeTo(Undefined, /* @__PURE__ */ transform({
+    decode: () => void 0,
+    encode: () => ""
+  }))),
+  UnknownFromJsonString
+])));
+function toCodecArrayBuffer(schemas) {
+  return Union(schemas.map(onSchema));
+  function onSchema(schema) {
+    return fromArrayBuffer(schema).pipe(decodeTo(schema));
+  }
+}
+function fromArrayBuffer(schema) {
+  const encoding = getResponseEncoding(schema.ast);
+  switch (encoding._tag) {
+    case "Json": {
+      const encodedIsNull = isNull(toEncoded(schema.ast));
+      return encodedIsNull ? UnknownFromArrayBuffer.pipe(decodeTo(Unknown, transform({
+        decode: (a) => a === void 0 ? null : a,
+        encode: (a) => a === null ? void 0 : a
+      }))) : UnknownFromArrayBuffer;
+    }
+    case "FormUrlEncoded":
+      return StringFromArrayBuffer.pipe(decodeTo(RecordFromUrlParams, transform({
+        decode: (text2) => fromInput(new URLSearchParams(text2)),
+        encode: toString
+      })));
+    case "Uint8Array":
+      return Uint8ArrayFromArrayBuffer;
+    case "Text":
+      return StringFromArrayBuffer;
+  }
+}
+var statusOrElse = (response) => fail3(new HttpClientError({
+  reason: new DecodeError({
+    request: response.request,
+    response
+  })
+}));
+var $HttpBody = /* @__PURE__ */ declare(isHttpBody);
+function getEncodePayloadSchema(schemas, method) {
+  return Union(schemas.map((s) => getEncodePayloadSchemaFromBody(s, method)));
+}
+var bodyFromPayloadCache = /* @__PURE__ */ new WeakMap();
+function getEncodePayloadSchemaFromBody(schema, method) {
+  const ast = schema.ast;
+  const cached = bodyFromPayloadCache.get(ast);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const encoding = getPayloadEncoding(ast, method);
+  const out = $HttpBody.pipe(decodeTo(schema, transformEffect({
+    decode(input, options2) {
+      return fail3(new Forbidden({
+        message: "Encode only schema"
+      }, input, options2));
+    },
+    encode(t, options2) {
+      switch (encoding._tag) {
+        case "Multipart":
+          return fail3(new Forbidden({
+            message: "Payload must be a FormData"
+          }, t, options2));
+        case "Json": {
+          try {
+            const body = JSON.stringify(t);
+            return succeed2(text(body, encoding.contentType));
+          } catch {
+            return fail3(new InvalidValue({
+              expected: "a JSON-serializable request body"
+            }, t, options2));
+          }
+        }
+        case "Text": {
+          if (typeof t !== "string") {
+            return fail3(new InvalidValue({
+              message: "Expected a string"
+            }, t, options2));
+          }
+          return succeed2(text(t, encoding.contentType));
+        }
+        case "FormUrlEncoded": {
+          if (!isObject(t)) {
+            return fail3(new InvalidValue({
+              message: "Expected a record"
+            }, t, options2));
+          }
+          return succeed2(urlParams(fromInput(t), encoding.contentType));
+        }
+        case "Uint8Array": {
+          if (!(t instanceof Uint8Array)) {
+            return fail3(new InvalidValue({
+              message: "Expected a Uint8Array"
+            }, t, options2));
+          }
+          return succeed2(uint8Array(t, encoding.contentType));
+        }
+      }
+    }
+  })));
+  bodyFromPayloadCache.set(ast, out);
+  return out;
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/httpapi/HttpApiGroup.js
+var HttpApiGroup_exports = {};
+__export(HttpApiGroup_exports, {
+  isHttpApiGroup: () => isHttpApiGroup,
+  make: () => make6
+});
+var TypeId3 = "~effect/httpapi/HttpApiGroup";
+var isHttpApiGroup = (u) => hasProperty(u, TypeId3);
+var Proto3 = {
+  [TypeId3]: TypeId3,
+  add(...toAdd) {
+    const endpoints = {
+      ...this.endpoints
+    };
+    for (const endpoint2 of toAdd) {
+      assignProperty(endpoints, endpoint2.identifier, endpoint2);
+    }
+    return makeProto3({
+      ...optionsFromGroup(this),
+      endpoints
+    });
+  },
+  prefix(prefix) {
+    return makeProto3({
+      ...optionsFromGroup(this),
+      endpoints: map(this.endpoints, (endpoint2) => endpoint2.prefix(prefix))
+    });
+  },
+  middleware(middleware) {
+    return makeProto3({
+      ...optionsFromGroup(this),
+      endpoints: map(this.endpoints, (endpoint2) => endpoint2.middleware(middleware))
+    });
+  },
+  annotateMerge(annotations) {
+    return makeProto3({
+      ...optionsFromGroup(this),
+      annotations: merge(this.annotations, annotations)
+    });
+  },
+  annotate(annotation, value) {
+    return makeProto3({
+      ...optionsFromGroup(this),
+      annotations: add(this.annotations, annotation, value)
+    });
+  },
+  annotateEndpointsMerge(annotations) {
+    return makeProto3({
+      ...optionsFromGroup(this),
+      endpoints: map(this.endpoints, (endpoint2) => endpoint2.annotateMerge(annotations))
+    });
+  },
+  annotateEndpoints(annotation, value) {
+    return makeProto3({
+      ...optionsFromGroup(this),
+      endpoints: map(this.endpoints, (endpoint2) => endpoint2.annotate(annotation, value))
+    });
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var optionsFromGroup = (group2) => ({
+  identifier: group2.identifier,
+  topLevel: group2.topLevel,
+  endpoints: group2.endpoints,
+  annotations: group2.annotations
+});
+var makeProto3 = (options2) => {
+  function HttpApiGroup() {
+  }
+  Object.setPrototypeOf(HttpApiGroup, Proto3);
+  HttpApiGroup.key = `effect/httpapi/HttpApiGroup/${options2.identifier}`;
+  return Object.assign(HttpApiGroup, options2);
+};
+var make6 = (identifier, options2) => makeProto3({
+  identifier,
+  topLevel: options2?.topLevel ?? false,
+  endpoints: {},
+  annotations: empty()
+});
+
+// src/contracts/ui.ts
+var UiContext = Schema_exports.Struct({
+  deployment: Schema_exports.NonEmptyString,
+  profile: Schema_exports.optional(Schema_exports.NonEmptyString),
+  expectedProfileRevision: Schema_exports.optional(Schema_exports.Int)
+});
+var UiOperation = Schema_exports.Struct({
+  ...UiContext.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+});
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiDeploymentChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiDeploymentChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  HttpApiEndpoint_exports,
+  HttpApi_exports,
+  HttpApiClient_exports,
+  HttpApiGroup_exports,
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiDeploymentChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};