@zap-studio/fetch 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
+## @zap-studio/fetch@0.5.5
+
+### Migrate to ultracite lint/format
+
+Internal formatting and lint cleanup only. No public API or behavior change.
+
 # @zap-studio/fetch
 
+## 0.5.4
+
+### Changed
+
+- Added fetch ecosystem benchmarks and grouped benchmark output for easier cross-library comparisons.
+- Applied small internal performance optimizations in request preparation, URL resolution, and header merging without changing public API behavior.
+
 ## 0.5.3
 
 ### Changed

package/README.md

@@ -107,8 +107,7 @@ const created = await api.post("/api/users", UserSchema, {
 });
 ```
 
-In this example, `UserSchema` validates the response from `/api/users`.
-The `json` value is the outgoing request body and is not validated by `UserSchema`.
+In this example, `UserSchema` validates the response from `/api/users`. The `json` value is the outgoing request body and is not validated by `UserSchema`.
 
 These helpers set the HTTP method for you. For raw responses without validation, use `$fetch`.
 
@@ -124,8 +123,7 @@ await api.post("/api/users", UserSchema, {
 });
 ```
 
-The schema argument still validates the response. Validate request bodies separately before
-passing them to `json` if your application needs outgoing payload validation.
+The schema argument still validates the response. Validate request bodies separately before passing them to `json` if your application needs outgoing payload validation.
 
 This sets:
 

package/dist/constants.d.mts

@@ -1,17 +1,16 @@
 import { FetchDefaults } from "./types.mjs";
-
 //#region src/constants.d.ts
 /**
-* Default options for the global $fetch
-*
-* These defaults are used by the top-level `$fetch` export.
-* Use `createFetch(...)` when you need per-client defaults.
-*
-* @example
-* import { GLOBAL_DEFAULTS } from "@zap-studio/fetch/constants";
-*
-* console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true
-*/
+ * Default options for the global $fetch
+ *
+ * These defaults are used by the top-level `$fetch` export.
+ * Use `createFetch(...)` when you need per-client defaults.
+ *
+ * @example
+ * import { GLOBAL_DEFAULTS } from "@zap-studio/fetch/constants";
+ *
+ * console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true
+ */
 declare const GLOBAL_DEFAULTS: FetchDefaults;
 //#endregion
 export { GLOBAL_DEFAULTS };

package/dist/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":";;;;;;;;;;;;;;cAmBa,eAAA,EAAiB,aAAA"}
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":";;;;;;;;;;;;;cAmBa,iBAAiB"}

package/dist/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Shared defaults and constants for fetch behavior.\n *\n * @module @zap-studio/fetch/constants\n */\n\nimport type { FetchDefaults } from \"./types.js\";\n\n/**\n * Default options for the global $fetch\n *\n * These defaults are used by the top-level `$fetch` export.\n * Use `createFetch(...)` when you need per-client defaults.\n *\n * @example\n * import { GLOBAL_DEFAULTS } from \"@zap-studio/fetch/constants\";\n *\n * console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true\n */\nexport const GLOBAL_DEFAULTS: FetchDefaults = {\n  baseURL: \"\",\n  throwOnFetchError: true,\n  throwOnValidationError: true,\n};\n"],"mappings":";;;;;;;;;;;;AAmBA,MAAa,kBAAiC;CAC5C,SAAS;CACT,mBAAmB;CACnB,wBAAwB;CACzB"}
+{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Shared defaults and constants for fetch behavior.\n *\n * @module @zap-studio/fetch/constants\n */\n\nimport type { FetchDefaults } from \"./types.js\";\n\n/**\n * Default options for the global $fetch\n *\n * These defaults are used by the top-level `$fetch` export.\n * Use `createFetch(...)` when you need per-client defaults.\n *\n * @example\n * import { GLOBAL_DEFAULTS } from \"@zap-studio/fetch/constants\";\n *\n * console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true\n */\nexport const GLOBAL_DEFAULTS: FetchDefaults = {\n  baseURL: \"\",\n  throwOnFetchError: true,\n  throwOnValidationError: true,\n};\n"],"mappings":";;;;;;;;;;;;AAmBA,MAAa,kBAAiC;CAC5C,SAAS;CACT,mBAAmB;CACnB,wBAAwB;AAC1B"}

package/dist/errors.d.mts

@@ -1,39 +1,39 @@
 //#region src/errors.d.ts
 /**
-* Custom error types used by the fetch package.
-*
-* @module @zap-studio/fetch/errors
-*/
+ * Custom error types used by the fetch package.
+ *
+ * @module @zap-studio/fetch/errors
+ */
 /**
-* Error thrown for HTTP errors (non-2xx responses)
-*
-* Includes the failing `Response` object and status code for
-* downstream error handling and response inspection.
-*
-* @example
-* import { FetchError } from "@zap-studio/fetch/errors";
-*
-* try {
-*   await $fetch("/users/404");
-* } catch (error) {
-*   if (error instanceof FetchError) {
-*     console.error(error.status);
-*     console.error(await error.response.text());
-*   }
-* }
-*/
+ * Error thrown for HTTP errors (non-2xx responses)
+ *
+ * Includes the failing `Response` object and status code for
+ * downstream error handling and response inspection.
+ *
+ * @example
+ * import { FetchError } from "@zap-studio/fetch/errors";
+ *
+ * try {
+ *   await $fetch("/users/404");
+ * } catch (error) {
+ *   if (error instanceof FetchError) {
+ *     console.error(error.status);
+ *     console.error(await error.response.text());
+ *   }
+ * }
+ */
 declare class FetchError extends Error {
   /**
-  * HTTP status code from the failing response.
-  */
+   * HTTP status code from the failing response.
+   */
   status: Response["status"];
   /**
-  * Full response object for additional inspection.
-  */
+   * Full response object for additional inspection.
+   */
   response: Response;
   /**
-  * Creates a FetchError from a non-ok response.
-  */
+   * Creates a FetchError from a non-ok response.
+   */
   constructor(message: string, response: Response);
 }
 //#endregion

package/dist/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;AAwBA;;;;;;;;;;;;;;;;;;;;;;cAAa,UAAA,SAAmB,KAAA;;;;EAI9B,MAAA,EAAQ,QAAA;;;;EAIR,QAAA,EAAU,QAAA;;;;EAKV,WAAA,CAAY,OAAA,UAAiB,QAAA,EAAU,QAAA;AAAA"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cAwBa,mBAAmB;;;;EAI9B,QAAQ;;;;EAIR,UAAU;;;;EAKV,YAAY,iBAAiB,UAAU"}

package/dist/errors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Custom error types used by the fetch package.\n *\n * @module @zap-studio/fetch/errors\n */\n\n/**\n * Error thrown for HTTP errors (non-2xx responses)\n *\n * Includes the failing `Response` object and status code for\n * downstream error handling and response inspection.\n *\n * @example\n * import { FetchError } from \"@zap-studio/fetch/errors\";\n *\n * try {\n *   await $fetch(\"/users/404\");\n * } catch (error) {\n *   if (error instanceof FetchError) {\n *     console.error(error.status);\n *     console.error(await error.response.text());\n *   }\n * }\n */\nexport class FetchError extends Error {\n  /**\n   * HTTP status code from the failing response.\n   */\n  status: Response[\"status\"];\n  /**\n   * Full response object for additional inspection.\n   */\n  response: Response;\n\n  /**\n   * Creates a FetchError from a non-ok response.\n   */\n  constructor(message: string, response: Response) {\n    super(message);\n    this.name = \"FetchError\";\n    this.status = response.status;\n    this.response = response;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;CAIA;;;;CAKA,YAAY,SAAiB,UAAoB;AAC/C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS,SAAS;AACvB,OAAK,WAAW"}
+{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Custom error types used by the fetch package.\n *\n * @module @zap-studio/fetch/errors\n */\n\n/**\n * Error thrown for HTTP errors (non-2xx responses)\n *\n * Includes the failing `Response` object and status code for\n * downstream error handling and response inspection.\n *\n * @example\n * import { FetchError } from \"@zap-studio/fetch/errors\";\n *\n * try {\n *   await $fetch(\"/users/404\");\n * } catch (error) {\n *   if (error instanceof FetchError) {\n *     console.error(error.status);\n *     console.error(await error.response.text());\n *   }\n * }\n */\nexport class FetchError extends Error {\n  /**\n   * HTTP status code from the failing response.\n   */\n  status: Response[\"status\"];\n  /**\n   * Full response object for additional inspection.\n   */\n  response: Response;\n\n  /**\n   * Creates a FetchError from a non-ok response.\n   */\n  constructor(message: string, response: Response) {\n    super(message);\n    this.name = \"FetchError\";\n    this.status = response.status;\n    this.response = response;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;CAIA;;;;CAKA,YAAY,SAAiB,UAAoB;EAC/C,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS,SAAS;EACvB,KAAK,WAAW;CAClB;AACF"}

package/dist/headers.d.mts

@@ -1,26 +1,26 @@
 //#region src/headers.d.ts
 /**
-* Header utility helpers for request normalization and merging.
-*
-* @module @zap-studio/fetch/headers
-*/
+ * Header utility helpers for request normalization and merging.
+ *
+ * @module @zap-studio/fetch/headers
+ */
 /**
-* Merges two HeadersInit objects, with the second one taking precedence.
-*
-* @param base - Base/default headers.
-* @param override - Request-level override headers.
-* @returns A merged `Headers` object, or `undefined` when both inputs are empty.
-* @throws {TypeError} When either header input contains invalid header names or values.
-*
-* @example
-* const headers = mergeHeaders(
-*   { Authorization: "Bearer token" },
-*   { "X-Trace-Id": "abc" },
-* );
-*
-* console.log(headers?.get("Authorization")); // Bearer token
-*/
-declare function mergeHeaders(base?: HeadersInit, override?: HeadersInit): Headers | undefined;
+ * Merges two HeadersInit objects, with the second one taking precedence.
+ *
+ * @param base - Base/default headers.
+ * @param override - Request-level override headers.
+ * @returns A merged `Headers` object, or `undefined` when both inputs are empty.
+ * @throws {TypeError} When either header input contains invalid header names or values.
+ *
+ * @example
+ * const headers = mergeHeaders(
+ *   { Authorization: "Bearer token" },
+ *   { "X-Trace-Id": "abc" },
+ * );
+ *
+ * console.log(headers?.get("Authorization")); // Bearer token
+ */
+declare const mergeHeaders: (base?: HeadersInit, override?: HeadersInit) => Headers | undefined;
 //#endregion
 export { mergeHeaders };
 //# sourceMappingURL=headers.d.mts.map

package/dist/headers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"headers.d.mts","names":[],"sources":["../src/headers.ts"],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;;;;iBAAgB,YAAA,CAAa,IAAA,GAAO,WAAA,EAAa,QAAA,GAAW,WAAA,GAAc,OAAA"}
+{"version":3,"file":"headers.d.mts","names":[],"sources":["../src/headers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAsBa,eACX,OAAO,aACP,WAAW,gBACV"}

package/dist/headers.mjs

@@ -20,15 +20,14 @@
 *
 * console.log(headers?.get("Authorization")); // Bearer token
 */
-function mergeHeaders(base, override) {
-	if (!(base || override)) return;
+const mergeHeaders = (base, override) => {
+	if (base === void 0 && override === void 0) return;
+	if (base === void 0) return new Headers(override);
+	if (override === void 0) return new Headers(base);
 	const merged = new Headers(base);
-	if (override) {
-		const overrideHeaders = new Headers(override);
-		for (const [key, value] of overrideHeaders.entries()) merged.set(key, value);
-	}
+	for (const [key, value] of new Headers(override).entries()) merged.set(key, value);
 	return merged;
-}
+};
 //#endregion
 export { mergeHeaders };
 

package/dist/headers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"headers.mjs","names":[],"sources":["../src/headers.ts"],"sourcesContent":["/**\n * Header utility helpers for request normalization and merging.\n *\n * @module @zap-studio/fetch/headers\n */\n\n/**\n * Merges two HeadersInit objects, with the second one taking precedence.\n *\n * @param base - Base/default headers.\n * @param override - Request-level override headers.\n * @returns A merged `Headers` object, or `undefined` when both inputs are empty.\n * @throws {TypeError} When either header input contains invalid header names or values.\n *\n * @example\n * const headers = mergeHeaders(\n *   { Authorization: \"Bearer token\" },\n *   { \"X-Trace-Id\": \"abc\" },\n * );\n *\n * console.log(headers?.get(\"Authorization\")); // Bearer token\n */\nexport function mergeHeaders(base?: HeadersInit, override?: HeadersInit): Headers | undefined {\n  if (!(base || override)) {\n    return;\n  }\n\n  const merged = new Headers(base);\n  if (override) {\n    const overrideHeaders = new Headers(override);\n    for (const [key, value] of overrideHeaders.entries()) {\n      merged.set(key, value);\n    }\n  }\n  return merged;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,aAAa,MAAoB,UAA6C;AAC5F,KAAI,EAAE,QAAQ,UACZ;CAGF,MAAM,SAAS,IAAI,QAAQ,KAAK;AAChC,KAAI,UAAU;EACZ,MAAM,kBAAkB,IAAI,QAAQ,SAAS;AAC7C,OAAK,MAAM,CAAC,KAAK,UAAU,gBAAgB,SAAS,CAClD,QAAO,IAAI,KAAK,MAAM;;AAG1B,QAAO"}
+{"version":3,"file":"headers.mjs","names":[],"sources":["../src/headers.ts"],"sourcesContent":["/**\n * Header utility helpers for request normalization and merging.\n *\n * @module @zap-studio/fetch/headers\n */\n\n/**\n * Merges two HeadersInit objects, with the second one taking precedence.\n *\n * @param base - Base/default headers.\n * @param override - Request-level override headers.\n * @returns A merged `Headers` object, or `undefined` when both inputs are empty.\n * @throws {TypeError} When either header input contains invalid header names or values.\n *\n * @example\n * const headers = mergeHeaders(\n *   { Authorization: \"Bearer token\" },\n *   { \"X-Trace-Id\": \"abc\" },\n * );\n *\n * console.log(headers?.get(\"Authorization\")); // Bearer token\n */\nexport const mergeHeaders = (\n  base?: HeadersInit,\n  override?: HeadersInit\n): Headers | undefined => {\n  if (base === undefined && override === undefined) {\n    return undefined;\n  }\n\n  if (base === undefined) {\n    return new Headers(override);\n  }\n\n  if (override === undefined) {\n    return new Headers(base);\n  }\n\n  const merged = new Headers(base);\n  for (const [key, value] of new Headers(override).entries()) {\n    merged.set(key, value);\n  }\n  return merged;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBACX,MACA,aACwB;CACxB,IAAI,SAAS,KAAA,KAAa,aAAa,KAAA,GACrC;CAGF,IAAI,SAAS,KAAA,GACX,OAAO,IAAI,QAAQ,QAAQ;CAG7B,IAAI,aAAa,KAAA,GACf,OAAO,IAAI,QAAQ,IAAI;CAGzB,MAAM,SAAS,IAAI,QAAQ,IAAI;CAC/B,KAAK,MAAM,CAAC,KAAK,UAAU,IAAI,QAAQ,QAAQ,CAAC,CAAC,QAAQ,GACvD,OAAO,IAAI,KAAK,KAAK;CAEvB,OAAO;AACT"}

package/dist/index.d.mts

@@ -1,53 +1,52 @@
 import { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput } from "./types.mjs";
 import { StandardSchemaV1 } from "@zap-studio/validation";
-
 //#region src/index.d.ts
 /**
-* Type-safe fetch wrapper with Standard Schema validation.
-*
-* - When `throwOnValidationError: true`: validated data of type `TSchema`
-* - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`
-* - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses
-*
-* If no schema is provided, returns the raw `Response` object.
-*
-* @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
-* @throws {ValidationError} When a schema is provided, validation returns issues, and
-*   `throwOnValidationError` is `true`.
-* @throws {TypeError} When both `body` and `json` are provided, when JSON request
-*   serialization fails, when request construction fails, when headers/search params are
-*   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`
-*   implementation rejects network-level failures as `TypeError`.
-* @throws {DOMException} When the runtime rejects an aborted request or response body read
-*   as an `AbortError` DOMException.
-* @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
-*   response body.
-* @throws Any error thrown or rejected by the provided Standard Schema validator.
-*
-* @example
-* import { z } from "zod";
-* import { $fetch } from "@zap-studio/fetch";
-*
-* const UserSchema = z.object({ id: z.number(), name: z.string() });
-*
-* // Basic usage (schema validation)
-* const user = await $fetch("/api/users/1", UserSchema, { headers: { "Authorization": "Bearer token" } });
-* console.log("Validated user:", user);
-*
-* // Raw usage (no schema validation and typed Response object)
-* const result = await $fetch("/api/data", { method: "POST", body: JSON.stringify({ key: "value" }) });
-* const json = await result.json() as ResultType;
-* console.log("Raw response data:", json);
-*
-* // Usage with validation errors returned instead of thrown
-* const result = await $fetch("/api/users/1", UserSchema, { throwOnValidationError: false });
-*
-* if (result.issues) {
-*   console.error("Validation errors:", result.issues);
-* } else {
-*   console.log("Validated user:", result.value);
-* }
-*/
+ * Type-safe fetch wrapper with Standard Schema validation.
+ *
+ * - When `throwOnValidationError: true`: validated data of type `TSchema`
+ * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`
+ * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses
+ *
+ * If no schema is provided, returns the raw `Response` object.
+ *
+ * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+ * @throws {ValidationError} When a schema is provided, validation returns issues, and
+ *   `throwOnValidationError` is `true`.
+ * @throws {TypeError} When both `body` and `json` are provided, when JSON request
+ *   serialization fails, when request construction fails, when headers/search params are
+ *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`
+ *   implementation rejects network-level failures as `TypeError`.
+ * @throws {DOMException} When the runtime rejects an aborted request or response body read
+ *   as an `AbortError` DOMException.
+ * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
+ *   response body.
+ * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { $fetch } from "@zap-studio/fetch";
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Basic usage (schema validation)
+ * const user = await $fetch("/api/users/1", UserSchema, { headers: { "Authorization": "Bearer token" } });
+ * console.log("Validated user:", user);
+ *
+ * // Raw usage (no schema validation and typed Response object)
+ * const result = await $fetch("/api/data", { method: "POST", body: JSON.stringify({ key: "value" }) });
+ * const json = await result.json() as ResultType;
+ * console.log("Raw response data:", json);
+ *
+ * // Usage with validation errors returned instead of thrown
+ * const result = await $fetch("/api/users/1", UserSchema, { throwOnValidationError: false });
+ *
+ * if (result.issues) {
+ *   console.error("Validation errors:", result.issues);
+ * } else {
+ *   console.log("Validated user:", result.value);
+ * }
+ */
 declare function $fetch<TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options: ExtendedRequestInit & {
   throwOnValidationError: false;
 }): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
@@ -56,57 +55,57 @@ declare function $fetch<TSchema extends StandardSchemaV1>(input: FetchInput, sch
 }): Promise<StandardSchemaV1.InferOutput<TSchema>>;
 declare function $fetch(input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;
 /**
-* Convenience methods for common HTTP verbs.
-*
-* These methods always require a schema for validation.
-* For raw responses without validation, use `$fetch` directly.
-*
-* Each method has the same throw behavior as {@link $fetch}.
-*
-* @example
-* import { z } from "zod";
-* import { api } from "@zap-studio/fetch";
-*
-* const PostSchema = z.object({
-*   id: z.number(),
-*   title: z.string(),
-*   content: z.string(),
-* });
-*
-* async function fetchPost(postId: number) {
-*   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
-*   return post; // post is typed as { id: number; title: string; content: string; }
-* }
-*/
+ * Convenience methods for common HTTP verbs.
+ *
+ * These methods always require a schema for validation.
+ * For raw responses without validation, use `$fetch` directly.
+ *
+ * Each method has the same throw behavior as {@link $fetch}.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { api } from "@zap-studio/fetch";
+ *
+ * const PostSchema = z.object({
+ *   id: z.number(),
+ *   title: z.string(),
+ *   content: z.string(),
+ * });
+ *
+ * async function fetchPost(postId: number) {
+ *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);
+ *   return post; // post is typed as { id: number; title: string; content: string; }
+ * }
+ */
 declare const api: ApiMethods;
 /**
-* Creates a custom fetch instance with pre-configured defaults.
-*
-* Use this factory to create API clients with a base URL, default headers,
-* and other shared configuration. Each instance is independent.
-*
-* The returned `$fetch` and `api` methods have the same throw behavior as the
-* top-level {@link $fetch} export.
-*
-* @example
-* import { z } from "zod";
-* import { createFetch } from "@zap-studio/fetch";
-*
-* // Create a configured instance
-* const { $fetch, api } = createFetch({
-*   baseURL: "https://api.example.com",
-*   headers: { "Authorization": "Bearer token" },
-* });
-*
-* const UserSchema = z.object({ id: z.number(), name: z.string() });
-*
-* // Now use relative paths - baseURL is prepended automatically
-* const user = await api.get("/users/1", UserSchema);
-*
-* // Or use $fetch directly
-* const response = await $fetch("/users", UserSchema, { method: "POST", json: { name: "John" } });
-*/
-declare function createFetch(factoryOptions?: Partial<FetchDefaults>): {
+ * Creates a custom fetch instance with pre-configured defaults.
+ *
+ * Use this factory to create API clients with a base URL, default headers,
+ * and other shared configuration. Each instance is independent.
+ *
+ * The returned `$fetch` and `api` methods have the same throw behavior as the
+ * top-level {@link $fetch} export.
+ *
+ * @example
+ * import { z } from "zod";
+ * import { createFetch } from "@zap-studio/fetch";
+ *
+ * // Create a configured instance
+ * const { $fetch, api } = createFetch({
+ *   baseURL: "https://api.example.com",
+ *   headers: { "Authorization": "Bearer token" },
+ * });
+ *
+ * const UserSchema = z.object({ id: z.number(), name: z.string() });
+ *
+ * // Now use relative paths - baseURL is prepended automatically
+ * const user = await api.get("/users/1", UserSchema);
+ *
+ * // Or use $fetch directly
+ * const response = await $fetch("/users", UserSchema, { method: "POST", json: { name: "John" } });
+ */
+declare const createFetch: (factoryOptions?: Partial<FetchDefaults>) => {
   $fetch: $Fetch;
   api: ApiMethods;
 };

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA;;;;;;;;;;;;;;;;;;;;;;;;iBANsB,MAAA,iBAAuB,gBAAA,CAAA,CAC3C,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,sBAAA;AAAA,IAChC,OAAA,CAAQ,gBAAA,CAAiB,MAAA,CAAO,gBAAA,CAAiB,WAAA,CAAY,OAAA;AAAA,iBAE1C,MAAA,iBAAuB,gBAAA,CAAA,CAC3C,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,GAAU,mBAAA;EAAwB,sBAAA;AAAA,IACjC,OAAA,CAAQ,gBAAA,CAAiB,WAAA,CAAY,OAAA;AAAA,iBAElB,MAAA,CAAO,KAAA,EAAO,UAAA,EAAY,OAAA,GAAU,mBAAA,GAAsB,OAAA,CAAQ,QAAA;;;;;;;;;;;;;;AAqCxF;;;;;AAmCA;;;;;cAnCa,GAAA,EAAK,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCF,WAAA,CAAY,cAAA,GAAgB,OAAA,CAAQ,aAAA;EAClD,MAAA,EAAQ,MAAA;EACR,GAAA,EAAK,UAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEsB,OAAO,gBAAgB,kBAC3C,OAAO,YACP,QAAQ,SACR,SAAS;EAAwB;IAChC,QAAQ,iBAAiB,OAAO,iBAAiB,YAAY;iBAE1C,OAAO,gBAAgB,kBAC3C,OAAO,YACP,QAAQ,SACR,UAAU;EAAwB;IACjC,QAAQ,iBAAiB,YAAY;iBAElB,OACpB,OAAO,YACP,UAAU,sBACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;cAqCE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,cACX,iBAAgB,QAAQ;EAExB,QAAQ;EACR,KAAK"}

package/dist/index.mjs

@@ -41,11 +41,11 @@ async function $fetch(input, schemaOrOptions, optionsOrUndefined) {
 * }
 */
 const api = {
+	delete: createMethod($fetch, "DELETE"),
 	get: createMethod($fetch, "GET"),
-	post: createMethod($fetch, "POST"),
-	put: createMethod($fetch, "PUT"),
 	patch: createMethod($fetch, "PATCH"),
-	delete: createMethod($fetch, "DELETE")
+	post: createMethod($fetch, "POST"),
+	put: createMethod($fetch, "PUT")
 };
 /**
 * Creates a custom fetch instance with pre-configured defaults.
@@ -74,7 +74,7 @@ const api = {
 * // Or use $fetch directly
 * const response = await $fetch("/users", UserSchema, { method: "POST", json: { name: "John" } });
 */
-function createFetch(factoryOptions = {}) {
+const createFetch = (factoryOptions = {}) => {
 	const defaults = {
 		...GLOBAL_DEFAULTS,
 		...factoryOptions,
@@ -89,14 +89,14 @@ function createFetch(factoryOptions = {}) {
 	return {
 		$fetch: customFetch,
 		api: {
+			delete: createMethod(customFetch, "DELETE"),
 			get: createMethod(customFetch, "GET"),
-			post: createMethod(customFetch, "POST"),
-			put: createMethod(customFetch, "PUT"),
 			patch: createMethod(customFetch, "PATCH"),
-			delete: createMethod(customFetch, "DELETE")
+			post: createMethod(customFetch, "POST"),
+			put: createMethod(customFetch, "PUT")
 		}
 	};
-}
+};
 //#endregion
 export { $fetch, api, createFetch };
 

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Public entrypoint for the fetch package.\n *\n * Exposes:\n * - `$fetch` low-level typed fetch function\n * - `api` method shortcuts\n * - `createFetch` instance factory\n *\n * @module @zap-studio/fetch\n */\n\nimport { isStandardSchema, type StandardSchemaV1 } from \"@zap-studio/validation\";\n\nimport { GLOBAL_DEFAULTS } from \"./constants.js\";\nimport { fetchInternal } from \"./internal.js\";\nimport { createMethod } from \"./methods.js\";\nimport type {\n  $Fetch,\n  ApiMethods,\n  ExtendedRequestInit,\n  FetchDefaults,\n  FetchInput,\n} from \"./types.js\";\n\n/**\n * Type-safe fetch wrapper with Standard Schema validation.\n *\n * - When `throwOnValidationError: true`: validated data of type `TSchema`\n * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`\n * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses\n *\n * If no schema is provided, returns the raw `Response` object.\n *\n * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.\n * @throws {ValidationError} When a schema is provided, validation returns issues, and\n *   `throwOnValidationError` is `true`.\n * @throws {TypeError} When both `body` and `json` are provided, when JSON request\n *   serialization fails, when request construction fails, when headers/search params are\n *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`\n *   implementation rejects network-level failures as `TypeError`.\n * @throws {DOMException} When the runtime rejects an aborted request or response body read\n *   as an `AbortError` DOMException.\n * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the\n *   response body.\n * @throws Any error thrown or rejected by the provided Standard Schema validator.\n *\n * @example\n * import { z } from \"zod\";\n * import { $fetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Basic usage (schema validation)\n * const user = await $fetch(\"/api/users/1\", UserSchema, { headers: { \"Authorization\": \"Bearer token\" } });\n * console.log(\"Validated user:\", user);\n *\n * // Raw usage (no schema validation and typed Response object)\n * const result = await $fetch(\"/api/data\", { method: \"POST\", body: JSON.stringify({ key: \"value\" }) });\n * const json = await result.json() as ResultType;\n * console.log(\"Raw response data:\", json);\n *\n * // Usage with validation errors returned instead of thrown\n * const result = await $fetch(\"/api/users/1\", UserSchema, { throwOnValidationError: false });\n *\n * if (result.issues) {\n *   console.error(\"Validation errors:\", result.issues);\n * } else {\n *   console.log(\"Validated user:\", result.value);\n * }\n */\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  input: FetchInput,\n  schema: TSchema,\n  options: ExtendedRequestInit & { throwOnValidationError: false },\n): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  input: FetchInput,\n  schema: TSchema,\n  options?: ExtendedRequestInit & { throwOnValidationError?: true },\n): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\nexport async function $fetch(input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;\n\nexport async function $fetch(\n  input: FetchInput,\n  schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n  optionsOrUndefined?: ExtendedRequestInit,\n): Promise<unknown> {\n  const [schema, options] = isStandardSchema(schemaOrOptions)\n    ? [schemaOrOptions, optionsOrUndefined]\n    : [undefined, schemaOrOptions];\n\n  return await fetchInternal(input, schema, options, GLOBAL_DEFAULTS);\n}\n\n/**\n * Convenience methods for common HTTP verbs.\n *\n * These methods always require a schema for validation.\n * For raw responses without validation, use `$fetch` directly.\n *\n * Each method has the same throw behavior as {@link $fetch}.\n *\n * @example\n * import { z } from \"zod\";\n * import { api } from \"@zap-studio/fetch\";\n *\n * const PostSchema = z.object({\n *   id: z.number(),\n *   title: z.string(),\n *   content: z.string(),\n * });\n *\n * async function fetchPost(postId: number) {\n *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);\n *   return post; // post is typed as { id: number; title: string; content: string; }\n * }\n */\nexport const api: ApiMethods = {\n  get: createMethod($fetch, \"GET\"),\n  post: createMethod($fetch, \"POST\"),\n  put: createMethod($fetch, \"PUT\"),\n  patch: createMethod($fetch, \"PATCH\"),\n  delete: createMethod($fetch, \"DELETE\"),\n};\n\n/**\n * Creates a custom fetch instance with pre-configured defaults.\n *\n * Use this factory to create API clients with a base URL, default headers,\n * and other shared configuration. Each instance is independent.\n *\n * The returned `$fetch` and `api` methods have the same throw behavior as the\n * top-level {@link $fetch} export.\n *\n * @example\n * import { z } from \"zod\";\n * import { createFetch } from \"@zap-studio/fetch\";\n *\n * // Create a configured instance\n * const { $fetch, api } = createFetch({\n *   baseURL: \"https://api.example.com\",\n *   headers: { \"Authorization\": \"Bearer token\" },\n * });\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Now use relative paths - baseURL is prepended automatically\n * const user = await api.get(\"/users/1\", UserSchema);\n *\n * // Or use $fetch directly\n * const response = await $fetch(\"/users\", UserSchema, { method: \"POST\", json: { name: \"John\" } });\n */\nexport function createFetch(factoryOptions: Partial<FetchDefaults> = {}): {\n  $fetch: $Fetch;\n  api: ApiMethods;\n} {\n  const defaults: FetchDefaults = {\n    ...GLOBAL_DEFAULTS,\n    ...factoryOptions,\n    baseURL: factoryOptions.baseURL ?? GLOBAL_DEFAULTS.baseURL,\n    throwOnFetchError: factoryOptions.throwOnFetchError ?? GLOBAL_DEFAULTS.throwOnFetchError,\n    throwOnValidationError:\n      factoryOptions.throwOnValidationError ?? GLOBAL_DEFAULTS.throwOnValidationError,\n  };\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options: ExtendedRequestInit & { throwOnValidationError: false },\n  ): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options?: ExtendedRequestInit & {\n      throwOnValidationError?: true;\n    },\n  ): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\n  async function customFetch(input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;\n\n  async function customFetch(\n    input: FetchInput,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit,\n  ): Promise<unknown> {\n    const [schema, options] = isStandardSchema(schemaOrOptions)\n      ? [schemaOrOptions, optionsOrUndefined]\n      : [undefined, schemaOrOptions];\n\n    return await fetchInternal(input, schema, options, defaults);\n  }\n\n  const customApi = {\n    get: createMethod(customFetch, \"GET\"),\n    post: createMethod(customFetch, \"POST\"),\n    put: createMethod(customFetch, \"PUT\"),\n    patch: createMethod(customFetch, \"PATCH\"),\n    delete: createMethod(customFetch, \"DELETE\"),\n  };\n\n  return {\n    $fetch: customFetch,\n    api: customApi,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoFA,eAAsB,OACpB,OACA,iBACA,oBACkB;CAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,gBAAgB,GACvD,CAAC,iBAAiB,mBAAmB,GACrC,CAAC,KAAA,GAAW,gBAAgB;AAEhC,QAAO,MAAM,cAAc,OAAO,QAAQ,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;AA0BrE,MAAa,MAAkB;CAC7B,KAAK,aAAa,QAAQ,MAAM;CAChC,MAAM,aAAa,QAAQ,OAAO;CAClC,KAAK,aAAa,QAAQ,MAAM;CAChC,OAAO,aAAa,QAAQ,QAAQ;CACpC,QAAQ,aAAa,QAAQ,SAAS;CACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,SAAgB,YAAY,iBAAyC,EAAE,EAGrE;CACA,MAAM,WAA0B;EAC9B,GAAG;EACH,GAAG;EACH,SAAS,eAAe,WAAW,gBAAgB;EACnD,mBAAmB,eAAe,qBAAqB,gBAAgB;EACvE,wBACE,eAAe,0BAA0B,gBAAgB;EAC5D;CAkBD,eAAe,YACb,OACA,iBACA,oBACkB;EAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,gBAAgB,GACvD,CAAC,iBAAiB,mBAAmB,GACrC,CAAC,KAAA,GAAW,gBAAgB;AAEhC,SAAO,MAAM,cAAc,OAAO,QAAQ,SAAS,SAAS;;AAW9D,QAAO;EACL,QAAQ;EACR,KAVgB;GAChB,KAAK,aAAa,aAAa,MAAM;GACrC,MAAM,aAAa,aAAa,OAAO;GACvC,KAAK,aAAa,aAAa,MAAM;GACrC,OAAO,aAAa,aAAa,QAAQ;GACzC,QAAQ,aAAa,aAAa,SAAS;GAC5C;EAKA"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Public entrypoint for the fetch package.\n *\n * Exposes:\n * - `$fetch` low-level typed fetch function\n * - `api` method shortcuts\n * - `createFetch` instance factory\n *\n * @module @zap-studio/fetch\n */\n\nimport { isStandardSchema } from \"@zap-studio/validation\";\nimport type { StandardSchemaV1 } from \"@zap-studio/validation\";\n\nimport { GLOBAL_DEFAULTS } from \"./constants.js\";\nimport { fetchInternal } from \"./internal.js\";\nimport { createMethod } from \"./methods.js\";\nimport type {\n  $Fetch,\n  ApiMethods,\n  ExtendedRequestInit,\n  FetchDefaults,\n  FetchInput,\n} from \"./types.js\";\n\n/**\n * Type-safe fetch wrapper with Standard Schema validation.\n *\n * - When `throwOnValidationError: true`: validated data of type `TSchema`\n * - When `throwOnValidationError: false`: Standard Schema Result object `{ value?, issues? }`\n * - When `throwOnFetchError: true`: throws `FetchError` on non-ok responses\n *\n * If no schema is provided, returns the raw `Response` object.\n *\n * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.\n * @throws {ValidationError} When a schema is provided, validation returns issues, and\n *   `throwOnValidationError` is `true`.\n * @throws {TypeError} When both `body` and `json` are provided, when JSON request\n *   serialization fails, when request construction fails, when headers/search params are\n *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`\n *   implementation rejects network-level failures as `TypeError`.\n * @throws {DOMException} When the runtime rejects an aborted request or response body read\n *   as an `AbortError` DOMException.\n * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the\n *   response body.\n * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.\n *\n * @example\n * import { z } from \"zod\";\n * import { $fetch } from \"@zap-studio/fetch\";\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Basic usage (schema validation)\n * const user = await $fetch(\"/api/users/1\", UserSchema, { headers: { \"Authorization\": \"Bearer token\" } });\n * console.log(\"Validated user:\", user);\n *\n * // Raw usage (no schema validation and typed Response object)\n * const result = await $fetch(\"/api/data\", { method: \"POST\", body: JSON.stringify({ key: \"value\" }) });\n * const json = await result.json() as ResultType;\n * console.log(\"Raw response data:\", json);\n *\n * // Usage with validation errors returned instead of thrown\n * const result = await $fetch(\"/api/users/1\", UserSchema, { throwOnValidationError: false });\n *\n * if (result.issues) {\n *   console.error(\"Validation errors:\", result.issues);\n * } else {\n *   console.log(\"Validated user:\", result.value);\n * }\n */\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  input: FetchInput,\n  schema: TSchema,\n  options: ExtendedRequestInit & { throwOnValidationError: false }\n): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\nexport async function $fetch<TSchema extends StandardSchemaV1>(\n  input: FetchInput,\n  schema: TSchema,\n  options?: ExtendedRequestInit & { throwOnValidationError?: true }\n): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\nexport async function $fetch(\n  input: FetchInput,\n  options?: ExtendedRequestInit\n): Promise<Response>;\n\nexport async function $fetch(\n  input: FetchInput,\n  schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n  optionsOrUndefined?: ExtendedRequestInit\n): Promise<unknown> {\n  const [schema, options] = isStandardSchema(schemaOrOptions)\n    ? [schemaOrOptions, optionsOrUndefined]\n    : [undefined, schemaOrOptions];\n\n  return await fetchInternal(input, schema, options, GLOBAL_DEFAULTS);\n}\n\n/**\n * Convenience methods for common HTTP verbs.\n *\n * These methods always require a schema for validation.\n * For raw responses without validation, use `$fetch` directly.\n *\n * Each method has the same throw behavior as {@link $fetch}.\n *\n * @example\n * import { z } from \"zod\";\n * import { api } from \"@zap-studio/fetch\";\n *\n * const PostSchema = z.object({\n *   id: z.number(),\n *   title: z.string(),\n *   content: z.string(),\n * });\n *\n * async function fetchPost(postId: number) {\n *   const post = await api.get(`https://api.example.com/posts/${postId}`, PostSchema);\n *   return post; // post is typed as { id: number; title: string; content: string; }\n * }\n */\nexport const api: ApiMethods = {\n  delete: createMethod($fetch, \"DELETE\"),\n  get: createMethod($fetch, \"GET\"),\n  patch: createMethod($fetch, \"PATCH\"),\n  post: createMethod($fetch, \"POST\"),\n  put: createMethod($fetch, \"PUT\"),\n};\n\n/**\n * Creates a custom fetch instance with pre-configured defaults.\n *\n * Use this factory to create API clients with a base URL, default headers,\n * and other shared configuration. Each instance is independent.\n *\n * The returned `$fetch` and `api` methods have the same throw behavior as the\n * top-level {@link $fetch} export.\n *\n * @example\n * import { z } from \"zod\";\n * import { createFetch } from \"@zap-studio/fetch\";\n *\n * // Create a configured instance\n * const { $fetch, api } = createFetch({\n *   baseURL: \"https://api.example.com\",\n *   headers: { \"Authorization\": \"Bearer token\" },\n * });\n *\n * const UserSchema = z.object({ id: z.number(), name: z.string() });\n *\n * // Now use relative paths - baseURL is prepended automatically\n * const user = await api.get(\"/users/1\", UserSchema);\n *\n * // Or use $fetch directly\n * const response = await $fetch(\"/users\", UserSchema, { method: \"POST\", json: { name: \"John\" } });\n */\nexport const createFetch = (\n  factoryOptions: Partial<FetchDefaults> = {}\n): {\n  $fetch: $Fetch;\n  api: ApiMethods;\n} => {\n  const defaults: FetchDefaults = {\n    ...GLOBAL_DEFAULTS,\n    ...factoryOptions,\n    baseURL: factoryOptions.baseURL ?? GLOBAL_DEFAULTS.baseURL,\n    throwOnFetchError:\n      factoryOptions.throwOnFetchError ?? GLOBAL_DEFAULTS.throwOnFetchError,\n    throwOnValidationError:\n      factoryOptions.throwOnValidationError ??\n      GLOBAL_DEFAULTS.throwOnValidationError,\n  };\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options: ExtendedRequestInit & { throwOnValidationError: false }\n  ): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;\n\n  async function customFetch<TSchema extends StandardSchemaV1>(\n    input: FetchInput,\n    schema: TSchema,\n    options?: ExtendedRequestInit & {\n      throwOnValidationError?: true;\n    }\n  ): Promise<StandardSchemaV1.InferOutput<TSchema>>;\n\n  async function customFetch(\n    input: FetchInput,\n    options?: ExtendedRequestInit\n  ): Promise<Response>;\n\n  async function customFetch(\n    input: FetchInput,\n    schemaOrOptions?: StandardSchemaV1 | ExtendedRequestInit,\n    optionsOrUndefined?: ExtendedRequestInit\n  ): Promise<unknown> {\n    const [schema, options] = isStandardSchema(schemaOrOptions)\n      ? [schemaOrOptions, optionsOrUndefined]\n      : [undefined, schemaOrOptions];\n\n    return await fetchInternal(input, schema, options, defaults);\n  }\n\n  const customApi = {\n    delete: createMethod(customFetch, \"DELETE\"),\n    get: createMethod(customFetch, \"GET\"),\n    patch: createMethod(customFetch, \"PATCH\"),\n    post: createMethod(customFetch, \"POST\"),\n    put: createMethod(customFetch, \"PUT\"),\n  };\n\n  return {\n    $fetch: customFetch,\n    api: customApi,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;AAwFA,eAAsB,OACpB,OACA,iBACA,oBACkB;CAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,eAAe,IACtD,CAAC,iBAAiB,kBAAkB,IACpC,CAAC,KAAA,GAAW,eAAe;CAE/B,OAAO,MAAM,cAAc,OAAO,QAAQ,SAAS,eAAe;AACpE;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,MAAkB;CAC7B,QAAQ,aAAa,QAAQ,QAAQ;CACrC,KAAK,aAAa,QAAQ,KAAK;CAC/B,OAAO,aAAa,QAAQ,OAAO;CACnC,MAAM,aAAa,QAAQ,MAAM;CACjC,KAAK,aAAa,QAAQ,KAAK;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,eACX,iBAAyC,CAAC,MAIvC;CACH,MAAM,WAA0B;EAC9B,GAAG;EACH,GAAG;EACH,SAAS,eAAe,WAAW,gBAAgB;EACnD,mBACE,eAAe,qBAAqB,gBAAgB;EACtD,wBACE,eAAe,0BACf,gBAAgB;CACpB;CAqBA,eAAe,YACb,OACA,iBACA,oBACkB;EAClB,MAAM,CAAC,QAAQ,WAAW,iBAAiB,eAAe,IACtD,CAAC,iBAAiB,kBAAkB,IACpC,CAAC,KAAA,GAAW,eAAe;EAE/B,OAAO,MAAM,cAAc,OAAO,QAAQ,SAAS,QAAQ;CAC7D;CAUA,OAAO;EACL,QAAQ;EACR,KAAK;GATL,QAAQ,aAAa,aAAa,QAAQ;GAC1C,KAAK,aAAa,aAAa,KAAK;GACpC,OAAO,aAAa,aAAa,OAAO;GACxC,MAAM,aAAa,aAAa,MAAM;GACtC,KAAK,aAAa,aAAa,KAAK;EAKvB;CACf;AACF"}

package/dist/internal.d.mts

@@ -1,33 +1,32 @@
 import { ExtendedRequestInit, FetchDefaults, FetchInput } from "./types.mjs";
 import { StandardSchemaV1 } from "@zap-studio/validation";
-
 //#region src/internal.d.ts
 /**
-* Internal fetch implementation used by both $fetch and createFetch.
-*
-* This function normalizes request input, resolves final URL + query params,
-* executes `fetch`, optionally throws `FetchError`, and optionally validates
-* JSON response payloads using Standard Schema.
-*
-* @param input - Request URL, path, or Request object.
-* @param schema - Optional Standard Schema for response validation.
-* @param options - Optional request options and package-specific flags.
-* @param defaults - Effective client defaults.
-* @returns Raw `Response` when no schema is provided; otherwise validated output.
-* @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
-* @throws {ValidationError} When a schema is provided, validation returns issues, and
-*   `throwOnValidationError` is `true`.
-* @throws {TypeError} When both `body` and `json` are provided, when JSON request
-*   serialization fails, when request construction fails, when headers/search params are
-*   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`
-*   implementation rejects network-level failures as `TypeError`.
-* @throws {DOMException} When the runtime rejects an aborted request or response body read
-*   as an `AbortError` DOMException.
-* @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
-*   response body.
-* @throws Any error thrown or rejected by the provided Standard Schema validator.
-*/
-declare function fetchInternal(input: FetchInput, schema: StandardSchemaV1 | undefined, options: ExtendedRequestInit | undefined, defaults: FetchDefaults): Promise<unknown>;
+ * Internal fetch implementation used by both $fetch and createFetch.
+ *
+ * This function normalizes request input, resolves final URL + query params,
+ * executes `fetch`, optionally throws `FetchError`, and optionally validates
+ * JSON response payloads using Standard Schema.
+ *
+ * @param input - Request URL, path, or Request object.
+ * @param schema - Optional Standard Schema for response validation.
+ * @param options - Optional request options and package-specific flags.
+ * @param defaults - Effective client defaults.
+ * @returns Raw `Response` when no schema is provided; otherwise validated output.
+ * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+ * @throws {ValidationError} When a schema is provided, validation returns issues, and
+ *   `throwOnValidationError` is `true`.
+ * @throws {TypeError} When both `body` and `json` are provided, when JSON request
+ *   serialization fails, when request construction fails, when headers/search params are
+ *   invalid, when `response.json()` cannot read the body, or when the runtime `fetch`
+ *   implementation rejects network-level failures as `TypeError`.
+ * @throws {DOMException} When the runtime rejects an aborted request or response body read
+ *   as an `AbortError` DOMException.
+ * @throws {SyntaxError} When a schema is provided and `response.json()` cannot parse the
+ *   response body.
+ * @throws {unknown} Any error thrown or rejected by the provided Standard Schema validator.
+ */
+declare const fetchInternal: (input: FetchInput, schema: StandardSchemaV1 | undefined, options: ExtendedRequestInit | undefined, defaults: FetchDefaults) => Promise<unknown>;
 //#endregion
 export { fetchInternal };
 //# sourceMappingURL=internal.d.mts.map

package/dist/internal.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.mts","names":[],"sources":["../src/internal.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCsB,aAAA,CACpB,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,gBAAA,cACR,OAAA,EAAS,mBAAA,cACT,QAAA,EAAU,aAAA,GACT,OAAA"}
+{"version":3,"file":"internal.d.mts","names":[],"sources":["../src/internal.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoGa,gBACX,OAAO,YACP,QAAQ,8BACR,SAAS,iCACT,UAAU,kBACT"}