apps 0.0.1-beta.34 → 0.0.1-beta.35

package/js/{chunk-QYM4STZW.js → chunk-PHO7HXTC.js}

@@ -1,3 +1,7 @@
+import {
+  EventEncoded,
+  decodeSchema
+} from "./chunk-V5DWGYRK.js";
 import {
   DecodeError,
   HttpClient,
@@ -19,7 +23,7 @@ import {
   text,
   uint8Array,
   urlParams
-} from "./chunk-CJY5X26R.js";
+} from "./chunk-KOOJUMLR.js";
 import {
   Cause,
   Defect,
@@ -31,16 +35,14 @@ import {
   Service,
   String as String2,
   Struct,
-  TaggedClass,
-  TaggedError,
   Uint8Array as Uint8Array2,
   Undefined,
-  UndefinedOr,
   Union,
   Unknown,
   UnknownFromJsonString,
   Void,
   add,
+  all,
   as,
   assignProperty,
   brand,
@@ -49,25 +51,21 @@ import {
   constVoid,
   context,
   declare,
-  decode2 as decode,
-  decodeEffect,
   decodeText,
   decodeTo,
   decodeUnknownEffect2 as decodeUnknownEffect,
-  empty2 as empty,
-  empty6 as empty2,
+  empty,
+  empty5 as empty2,
   encodeSync,
   encodeUnknownEffect2 as encodeUnknownEffect,
   ensure,
-  fail,
-  fail2,
-  fail4 as fail3,
+  fail2 as fail,
+  fail4 as fail2,
   failCause2 as failCause,
   flatMap2 as flatMap,
   fnUntraced,
   fromInput3 as fromInput,
   fromJsonString,
-  fromTransform,
   gen,
   getLastEncoding,
   getOrUndefined2 as getOrUndefined,
@@ -85,41 +83,36 @@ import {
   isSuspend,
   isUnion,
   isVoid,
-  make6 as make,
+  make4 as make,
   map2 as map,
   map3 as map2,
   map4 as map3,
   map6 as map4,
+  mapError,
   memoize,
   merge,
-  millis,
   optional,
   pipeArguments,
   pipeThroughChannel,
-  pipeTo,
   provideContext2 as provideContext,
   resolveAt,
-  succeed,
-  succeed4 as succeed2,
+  succeed4 as succeed,
   suspend,
   sync2 as sync,
-  tag,
   toCodecJson,
   toCodecStringTree,
   toEncoded,
-  toEncoded2,
   toString,
   toType,
   transform,
   transformEffect,
-  transformPull,
-  void_2 as void_
-} from "./chunk-EXGKN554.js";
+  transformPull
+} from "./chunk-IJQ5LE74.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApiSchema.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApiSchema.js
 var HttpApiSchema_exports = {};
 __export(HttpApiSchema_exports, {
   Accepted: () => Accepted,
@@ -159,242 +152,7 @@ __export(HttpApiSchema_exports, {
   status: () => status,
   withHeaders: () => withHeaders
 });
-
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/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@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApiSchema.js
-var StreamSchemaTypeId = "~effect/httpapi/HttpApiSchema/Stream";
+var StreamSchemaTypeId = "~effect/http-api/HttpApiSchema/Stream";
 function status(code) {
   const statusCode = typeof code === "string" ? fromLiteral(code) : code;
   return (self) => self.annotate({
@@ -449,8 +207,8 @@ function defaultStreamContentType(mode) {
       return "application/octet-stream";
   }
 }
-var WithHeadersTypeId = "~effect/httpapi/HttpApiSchema/WithHeaders";
-var WithHeadersValueTypeId = "~effect/httpapi/HttpApiSchema/WithHeadersValue";
+var WithHeadersTypeId = "~effect/http-api/HttpApiSchema/WithHeaders";
+var WithHeadersValueTypeId = "~effect/http-api/HttpApiSchema/WithHeadersValue";
 var isWithHeadersValue = (u) => hasProperty(u, WithHeadersValueTypeId);
 var withHeadersValueSchema = /* @__PURE__ */ declare(isWithHeadersValue);
 function WithHeaders(schema, headers) {
@@ -489,14 +247,16 @@ function encodeToWithHeaders(options2, transformation) {
       "~httpApiWithHeaders": {
         body,
         headers,
-        headersCodec: toEncoded2(headers)
+        bodyCodec: body,
+        headersCodec: headers,
+        transformation
       },
       httpApiStatus: status2,
       "~httpApiEncoding": encoding
     });
   };
 }
-var MultipartTypeId = "~effect/httpapi/HttpApiSchema/Multipart";
+var MultipartTypeId = "~effect/http-api/HttpApiSchema/Multipart";
 function asMultipart(options2) {
   return (self) => self.pipe(brand(MultipartTypeId)).annotate({
     "~httpApiEncoding": {
@@ -507,7 +267,7 @@ function asMultipart(options2) {
     }
   });
 }
-var MultipartStreamTypeId = "~effect/httpapi/HttpApiSchema/MultipartStream";
+var MultipartStreamTypeId = "~effect/http-api/HttpApiSchema/MultipartStream";
 function asMultipartStream(options2) {
   return (self) => self.pipe(brand(MultipartStreamTypeId)).annotate({
     "~httpApiEncoding": {
@@ -623,7 +383,7 @@ function getStatusErrorSchema(schema) {
   return getStatusError(schema.ast);
 }
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApiEndpoint.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApiEndpoint.js
 var HttpApiEndpoint_exports = {};
 __export(HttpApiEndpoint_exports, {
   delete: () => del,
@@ -641,15 +401,15 @@ __export(HttpApiEndpoint_exports, {
   query: () => query
 });
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/internal/mediaType.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/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@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApiEndpoint.js
-var TypeId = "~effect/httpapi/HttpApiEndpoint";
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApiEndpoint.js
+var TypeId = "~effect/http-api/HttpApiEndpoint";
 var isHttpApiEndpoint = (u) => hasProperty(u, TypeId);
 function getPayloadSchemas(endpoint2) {
   const result = [];
@@ -774,7 +534,7 @@ function getPayload(payload, method, disableCodecs) {
   }
   return result;
 }
-var reservedStreamFailureEvent = "effect/httpapi/stream/failure";
+var reservedStreamFailureEvent = "effect/http-api/stream/failure";
 function getSuccessResponse(success, method, disableCodecs) {
   if (success === void 0) return /* @__PURE__ */ new Set();
   const schemas = ensure(success);
@@ -931,14 +691,11 @@ function transformResponse(schema) {
   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({
+  return schema.annotate({
     "~httpApiWithHeaders": {
       ...withHeaders2,
-      headersCodec: toCodecStringTree(headers)
+      bodyCodec: applyResponseEncoding(withHeaders2.body, encoding),
+      headersCodec: toCodecStringTree(withHeaders2.headers)
     }
   });
 }
@@ -975,16 +732,23 @@ 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@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApi.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApi.js
 var HttpApi_exports = {};
 __export(HttpApi_exports, {
   AdditionalSchemas: () => AdditionalSchemas,
+  ErrorParseOptions: () => ErrorParseOptions,
+  HeadersParseOptions: () => HeadersParseOptions,
+  ParamsParseOptions: () => ParamsParseOptions,
   ParseOptions: () => ParseOptions,
+  PayloadParseOptions: () => PayloadParseOptions,
+  QueryParseOptions: () => QueryParseOptions,
+  SuccessParseOptions: () => SuccessParseOptions,
+  getSlotParseOptions: () => getSlotParseOptions,
   isHttpApi: () => isHttpApi,
   make: () => make4,
   reflect: () => reflect
 });
-var TypeId2 = "~effect/httpapi/HttpApi";
+var TypeId2 = "~effect/http-api/HttpApi";
 var isHttpApi = (u) => hasProperty(u, TypeId2);
 var Proto2 = {
   [TypeId2]: TypeId2,
@@ -1022,10 +786,10 @@ var Proto2 = {
       groups: map(this.groups, (group2) => group2.prefix(prefix))
     });
   },
-  middleware(tag2) {
+  middleware(tag) {
     return makeProto2({
       ...optionsFromApi(this),
-      groups: map(this.groups, (group2) => group2.middleware(tag2))
+      groups: map(this.groups, (group2) => group2.middleware(tag))
     });
   },
   annotate(key, value) {
@@ -1083,33 +847,56 @@ var reflect = (self, options2) => {
   }
 };
 var extractResponseContent = (schemas, getStatus) => {
-  const map7 = /* @__PURE__ */ new Map();
+  const map5 = /* @__PURE__ */ new Map();
   schemas.forEach(add2);
-  return map7;
+  return map5;
   function add2(schema) {
     const body = isWithHeaders(schema) ? schema.schema : schema;
     if (isStreamSchema(body)) return;
     const status2 = getStatus(schema);
-    const schemas2 = map7.get(status2);
+    const schemas2 = map5.get(status2);
     if (schemas2 === void 0) {
-      map7.set(status2, [schema]);
+      map5.set(status2, [schema]);
     } else {
       schemas2.push(schema);
     }
   }
 };
-var AdditionalSchemas = class extends (/* @__PURE__ */ Service()("effect/httpapi/HttpApi/AdditionalSchemas")) {
+var AdditionalSchemas = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/AdditionalSchemas")) {
 };
-var ParseOptions = class extends (/* @__PURE__ */ Service()("effect/httpapi/HttpApi/ParseOptions")) {
+var ParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/ParseOptions")) {
+};
+var ParamsParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/ParamsParseOptions")) {
+};
+var QueryParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/QueryParseOptions")) {
+};
+var HeadersParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/HeadersParseOptions")) {
+};
+var PayloadParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/PayloadParseOptions")) {
+};
+var SuccessParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/SuccessParseOptions")) {
+};
+var ErrorParseOptions = class extends (/* @__PURE__ */ Service()("effect/http-api/HttpApi/ErrorParseOptions")) {
+};
+var getSlotParseOptions = (annotations) => {
+  const fallback = getOrUndefined(annotations, ParseOptions);
+  return {
+    params: getOrUndefined(annotations, ParamsParseOptions) ?? fallback,
+    query: getOrUndefined(annotations, QueryParseOptions) ?? fallback,
+    headers: getOrUndefined(annotations, HeadersParseOptions) ?? fallback,
+    payload: getOrUndefined(annotations, PayloadParseOptions) ?? fallback,
+    success: getOrUndefined(annotations, SuccessParseOptions) ?? fallback,
+    error: getOrUndefined(annotations, ErrorParseOptions) ?? fallback
+  };
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApiGroup.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApiGroup.js
 var HttpApiGroup_exports = {};
 __export(HttpApiGroup_exports, {
   isHttpApiGroup: () => isHttpApiGroup,
   make: () => make5
 });
-var TypeId3 = "~effect/httpapi/HttpApiGroup";
+var TypeId3 = "~effect/http-api/HttpApiGroup";
 var isHttpApiGroup = (u) => hasProperty(u, TypeId3);
 var Proto3 = {
   [TypeId3]: TypeId3,
@@ -1175,7 +962,7 @@ var makeProto3 = (options2) => {
   function HttpApiGroup() {
   }
   Object.setPrototypeOf(HttpApiGroup, Proto3);
-  HttpApiGroup.key = `effect/httpapi/HttpApiGroup/${options2.identifier}`;
+  HttpApiGroup.key = `effect/http-api/HttpApiGroup/${options2.identifier}`;
   return Object.assign(HttpApiGroup, options2);
 };
 var make5 = (identifier, options2) => makeProto3({
@@ -1185,7 +972,7 @@ var make5 = (identifier, options2) => makeProto3({
   annotations: empty()
 });
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/internal/path.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/internal/path.js
 var emptyParamNames = /* @__PURE__ */ new Set();
 function getParamNames(schema) {
   if (schema === void 0) return emptyParamNames;
@@ -1193,7 +980,7 @@ function getParamNames(schema) {
   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@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/httpapi/HttpApiClient.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApiClient.js
 var HttpApiClient_exports = {};
 __export(HttpApiClient_exports, {
   endpoint: () => endpoint,
@@ -1236,7 +1023,7 @@ var makeClient = (api, options2) => gen(function* () {
         successes,
         mergedAnnotations
       } = onEndpointOptions;
-      const parseOptions = getOrUndefined(mergedAnnotations, ParseOptions);
+      const parseOptions = getSlotParseOptions(mergedAnnotations);
       const makeUrl = compilePath(endpoint2.path, endpoint2.params);
       const decodeMap = {
         orElse: statusOrElse
@@ -1245,39 +1032,38 @@ var makeClient = (api, options2) => gen(function* () {
       for (const [status2, schemas] of errors.entries()) {
         const grouped = groupSchemasByContentType(schemas);
         for (const [contentType, schemas2] of grouped.entries()) {
-          addResponseAlternative(errorAlternatives, status2, contentType, schemasToResponse(schemas2, parseOptions));
+          addResponseAlternative(errorAlternatives, status2, contentType, schemasToResponse(schemas2, parseOptions.error, parseOptions.headers));
         }
       }
       for (const [status2, alternatives] of errorAlternatives.entries()) {
-        const decode3 = makeResponseDecoder(alternatives);
-        decodeMap[status2] = (response) => flatMap(catchCause(decode3(response), (cause) => failCause(combine(fail2(new HttpClientError({
+        const decode = makeResponseDecoder(alternatives);
+        decodeMap[status2] = (response) => flatMap(catchCause(decode(response), (cause) => failCause(combine(fail(new HttpClientError({
           reason: new StatusCodeError({
             request: response.request,
             response
           })
-        })), cause))), fail3);
+        })), cause))), fail2);
       }
       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));
+          addResponseAlternative(successAlternatives, status2, contentType, schemasToResponse(schemas2, parseOptions.success, parseOptions.headers));
         }
       }
       for (const streamSuccess of getStreamSuccessSchemas(endpoint2)) {
         const streamSchema2 = isWithHeadersStreamSuccess(streamSuccess) ? streamSuccess.schema : streamSuccess;
-        addResponseAlternative(successAlternatives, getStatusSuccessSchema(streamSuccess), streamSchema2.contentType, streamToResponse(streamSuccess, parseOptions));
+        addResponseAlternative(successAlternatives, getStatusSuccessSchema(streamSuccess), streamSchema2.contentType, streamToResponse(streamSuccess, parseOptions.success, parseOptions.headers));
       }
       for (const [status2, alternatives] of successAlternatives.entries()) {
         decodeMap[status2] = makeResponseDecoder(alternatives);
       }
-      const encodeUnknownEffect2 = (schema) => encodeUnknownEffect(schema, parseOptions);
-      const encodeParams = map4(endpoint2.params, encodeUnknownEffect2);
+      const encodeParams = map4(endpoint2.params, (schema) => encodeUnknownEffect(schema, parseOptions.params));
       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 encodePayload = isArrayNonEmpty(payloadSchemas) ? encodeUnknownEffect(hasBody(endpoint2.method) ? getEncodePayloadSchema(payloadSchemas, endpoint2.method) : Union(payloadSchemas), parseOptions.payload) : void 0;
+      const encodeHeaders = map4(endpoint2.headers, (schema) => encodeUnknownEffect(schema, parseOptions.headers));
+      const encodeQuery = map4(endpoint2.query, (schema) => encodeUnknownEffect(schema, parseOptions.query));
+      const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag) => `${tag.key}/Client`);
       const endpointFn = fnUntraced(function* (request) {
         let httpRequest = make2(endpoint2.method)(endpoint2.path);
         if (request !== void 0) {
@@ -1390,10 +1176,10 @@ var urlBuilder = (api, options2) => {
       endpoint: endpoint2,
       mergedAnnotations
     }) {
-      const parseOptions = getOrUndefined(mergedAnnotations, ParseOptions);
+      const parseOptions = getSlotParseOptions(mergedAnnotations);
       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 encodeParams = endpoint2.params === void 0 ? void 0 : encodeSync(endpoint2.params, parseOptions.params);
+      const encodeQuery = endpoint2.query === void 0 ? void 0 : encodeSync(endpoint2.query, parseOptions.query);
       const endpointBuilder = (request) => {
         const params = request?.params;
         const path = params === void 0 ? endpoint2.path : makeUrl(encodeParams === void 0 ? params : encodeParams(params));
@@ -1438,48 +1224,58 @@ var compilePath = (path, schema) => {
     });
   };
 };
-function schemasToResponse(schemas, options2) {
+function schemasToResponse(schemas, options2, headersOptions) {
   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({
+  const codec = hasWithHeaders ? Union(schemas.map((schema) => toCodecArrayBufferWithHeaders(schema, options2, headersOptions))) : toCodecArrayBuffer(schemas);
+  const decode = decodeUnknownEffect(codec, options2);
+  return (response) => flatMap(response.arrayBuffer, hasWithHeaders ? (body) => decode({
     body,
     headers: response.headers
-  }) : decode3);
+  }) : decode);
 }
-function toCodecArrayBufferWithHeaders(schema) {
-  const isWithHeaders2 = isWithHeaders(schema);
+var ResponsePair = /* @__PURE__ */ Struct({
+  body: Unknown,
+  headers: Unknown
+});
+function toCodecArrayBufferWithHeaders(schema, options2, headersOptions) {
   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
-    }
+  const parts = annotation !== void 0 ? {
+    body: annotation.bodyCodec,
+    headers: annotation.headersCodec,
+    toValue: annotation.transformation.decode
+  } : isWithHeaders(schema) ? {
+    body: schema.schema,
+    headers: schema.headers,
+    toValue: withHeaders
+  } : {
+    body: schema,
+    headers: Unknown,
+    toValue: (pair) => pair.body
+  };
+  const decodeBody = decodeUnknownEffect(fromArrayBuffer(parts.body).pipe(decodeTo(parts.body)), options2);
+  const decodeHeaders = decodeUnknownEffect(parts.headers, headersOptions);
+  return ResponsePair.pipe(decodeTo(isWithHeaders(schema) ? schema : toType(schema), transformEffect({
+    decode: (pair) => all({
+      body: decodeBody(pair.body),
+      headers: decodeHeaders(pair.headers)
+    }).pipe(map2(parts.toValue), mapError((error) => error.issue)),
+    encode: (input, options3) => fail2(new Forbidden({
+      message: "Decode only schema"
+    }, input, options3))
   })));
 }
-function addResponseAlternative(map7, status2, contentType, decode3) {
+function addResponseAlternative(map5, status2, contentType, decode) {
   const normalizedContentType = normalize(contentType);
-  const alternatives = map7.get(status2);
+  const alternatives = map5.get(status2);
   if (alternatives === void 0) {
-    map7.set(status2, [{
+    map5.set(status2, [{
       contentType: normalizedContentType,
-      decode: decode3
+      decode
     }]);
   } else {
     alternatives.push({
       contentType: normalizedContentType,
-      decode: decode3
+      decode
     });
   }
 }
@@ -1510,7 +1306,7 @@ function groupSchemasByContentType(schemas) {
 }
 function failUnsupportedContentType(response, contentType, alternatives) {
   const expected = Array.from(new Set(alternatives.map((alternative) => alternative.contentType))).join(", ");
-  return fail3(new HttpClientError({
+  return fail2(new HttpClientError({
     reason: new DecodeError({
       request: response.request,
       response,
@@ -1518,7 +1314,7 @@ function failUnsupportedContentType(response, contentType, alternatives) {
     })
   }));
 }
-var reservedStreamFailureEvent2 = "effect/httpapi/stream/failure";
+var reservedStreamFailureEvent2 = "effect/http-api/stream/failure";
 var isWithHeadersStreamSuccess = (schema) => isWithHeaders(schema);
 function getStreamSuccessSchemas(endpoint2) {
   const schemas = [];
@@ -1530,7 +1326,7 @@ function getStreamSuccessSchemas(endpoint2) {
   }
   return schemas;
 }
-function streamToResponse(successSchema, options2) {
+function streamToResponse(successSchema, options2, headersOptions) {
   const isWithHeaders2 = isWithHeadersStreamSuccess(successSchema);
   const streamSchema2 = isWithHeaders2 ? successSchema.schema : successSchema;
   const sse = isStreamUint8Array(streamSchema2) ? void 0 : {
@@ -1539,20 +1335,20 @@ function streamToResponse(successSchema, 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);
+  const decodeHeaders = decodeUnknownEffect(successSchema.headers, headersOptions);
   return (response, sseOptions) => flatMap(decodeHeaders(response.headers), (headers) => map2(toStream(response, sseOptions), (body) => withHeaders({
     body,
     headers
   })));
 }
 function makeSseDecoder(declaration, parseOptions) {
-  const Event2 = Union([Struct({
+  const Event = 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);
+  const defaultDecoder = decodeSchema(Event, void 0, parseOptions);
+  return (options2) => options2 === void 0 ? defaultDecoder : decodeSchema(Event, options2, parseOptions);
 }
 function decodeSseStream(stream, declaration, decoder) {
   const events = transformPull(stream.pipe(decodeText, pipeThroughChannel(decoder)), (pull) => sync(() => {
@@ -1573,7 +1369,7 @@ function decodeSseStream(stream, declaration, decoder) {
             break;
           }
         }
-        return succeed2(events2);
+        return succeed(events2);
       });
     });
   }));
@@ -1637,7 +1433,7 @@ function fromArrayBuffer(schema) {
       return StringFromArrayBuffer;
   }
 }
-var statusOrElse = (response) => fail3(new HttpClientError({
+var statusOrElse = (response) => fail2(new HttpClientError({
   reason: new DecodeError({
     request: response.request,
     response
@@ -1657,49 +1453,49 @@ function getEncodePayloadSchemaFromBody(schema, method) {
   const encoding = getPayloadEncoding(ast, method);
   const out = $HttpBody.pipe(decodeTo(schema, transformEffect({
     decode(input, options2) {
-      return fail3(new Forbidden({
+      return fail2(new Forbidden({
         message: "Encode only schema"
       }, input, options2));
     },
     encode(t, options2) {
       switch (encoding._tag) {
         case "Multipart":
-          return fail3(new Forbidden({
+          return fail2(new Forbidden({
             message: "Payload must be a FormData"
           }, t, options2));
         case "Json": {
           try {
             const body = JSON.stringify(t);
-            return succeed2(text(body, encoding.contentType));
+            return succeed(text(body, encoding.contentType));
           } catch {
-            return fail3(new InvalidValue({
+            return fail2(new InvalidValue({
               expected: "a JSON-serializable request body"
             }, t, options2));
           }
         }
         case "Text": {
           if (typeof t !== "string") {
-            return fail3(new InvalidValue({
+            return fail2(new InvalidValue({
               message: "Expected a string"
             }, t, options2));
           }
-          return succeed2(text(t, encoding.contentType));
+          return succeed(text(t, encoding.contentType));
         }
         case "FormUrlEncoded": {
           if (!isObject(t)) {
-            return fail3(new InvalidValue({
+            return fail2(new InvalidValue({
               message: "Expected a record"
             }, t, options2));
           }
-          return succeed2(urlParams(fromInput(t), encoding.contentType));
+          return succeed(urlParams(fromInput(t), encoding.contentType));
         }
         case "Uint8Array": {
           if (!(t instanceof Uint8Array)) {
-            return fail3(new InvalidValue({
+            return fail2(new InvalidValue({
               message: "Expected a Uint8Array"
             }, t, options2));
           }
-          return succeed2(uint8Array(t, encoding.contentType));
+          return succeed(uint8Array(t, encoding.contentType));
         }
       }
     }