@zap-studio/fetch 0.4.7 → 0.5.0

package/dist/types.d.mts

@@ -1,55 +1,56 @@
-import { StandardSchemaV1 } from "@standard-schema/spec";
+import { StandardSchemaV1 } from "@zap-studio/validation";
 
 //#region src/types.d.ts
-
-/**
-* Type representing various formats for search parameters
-* that can be used in requests.
-* Can be a URLSearchParams object, a record of string pairs,
-* a query string, or an array of tuples.
-*/
-type SearchParams = URLSearchParams | Record<string, string> | string | [string, string][];
-/**
-* JSON-serializable value used for request bodies.
-*/
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [key: string]: JsonValue;
+type FetchInput = Parameters<typeof fetch>[0];
+type URLSearchParamsInput = ConstructorParameters<typeof URLSearchParams>[0];
+type RequestBodyInit = RequestInit & {
+  json?: never;
 };
-/**
-* Request body type accepted by the fetch wrapper.
-*/
-type RequestBody = BodyInit | JsonValue;
-/**
-* Base extended request options without throwOnValidationError
-*/
-type BaseExtendedRequestInit = Omit<RequestInit, "body"> & {
+type JsonBodyInit = Omit<RequestInit, "body"> & {
   /**
-  * Request body - can be a BodyInit value or an object that will be JSON-stringified
+  * JSON body convenience. When provided, this is JSON-stringified into `body`.
+  * @default undefined
   */
-  body?: RequestBody;
+  json: unknown;
+  body?: never;
+};
+type CustomRequestInit = {
   /**
   * Per-request query/search params
   * @default undefined
   */
-  searchParams?: SearchParams;
+  searchParams?: URLSearchParamsInput | undefined;
   /**
   * Whether to throw a FetchError on HTTP errors (non-2xx responses)
   * @default true
   */
-  throwOnFetchError?: boolean;
-};
-/**
-* Extended RequestInit type to include custom fetch options
-*/
-type ExtendedRequestInit<TThrowOnValidationError extends boolean | undefined = boolean | undefined> = BaseExtendedRequestInit & {
+  throwOnFetchError?: boolean | undefined;
   /**
   * Whether to throw a ValidationError on validation errors
   * @default true
   */
-  throwOnValidationError?: TThrowOnValidationError;
+  throwOnValidationError?: boolean | undefined;
 };
 /**
+* Extended RequestInit type to include custom fetch options
+*
+* @example
+* const options: ExtendedRequestInit = {
+*   method: "POST",
+*   json: { name: "Ada" },
+*   throwOnFetchError: true,
+* };
+*/
+type ExtendedRequestInit = (RequestBodyInit | JsonBodyInit) & CustomRequestInit;
+/**
 * Internal defaults used by fetchInternal
+*
+* @example
+* const defaults: FetchDefaults = {
+*   baseURL: "https://api.example.com",
+*   throwOnFetchError: true,
+*   throwOnValidationError: true,
+* };
 */
 interface FetchDefaults {
   /**
@@ -61,12 +62,12 @@ interface FetchDefaults {
   * Default headers to include in all requests (can be overridden per request)
   * @default undefined
   */
-  headers?: HeadersInit;
+  headers?: HeadersInit | undefined;
   /**
   * Default query/search params applied to every request (can be overridden per request)
   * @default undefined
   */
-  searchParams?: SearchParams;
+  searchParams?: URLSearchParamsInput | undefined;
   /**
   * Whether to throw a `FetchError` on HTTP errors (non-2xx responses)
   * @default true
@@ -79,39 +80,64 @@ interface FetchDefaults {
   throwOnValidationError: boolean;
 }
 /**
-* Options for creating a custom fetch instance with `createFetch`
-*/
-type CreateFetchOptions = Partial<FetchDefaults>;
-/**
 * Type-safe fetch function with Standard Schema validation support
 */
 interface $Fetch {
   /**
   * Fetch with schema validation and throwOnValidationError: false
-  * @param resource - URL or path to fetch
+  * @param input - URL or path to fetch
   * @param schema - Standard Schema for response validation
   * @param options - Extended request options with throwOnValidationError: false
   * @returns Standard Schema Result object with value or issues
-  */
-  <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options: ExtendedRequestInit<false>): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+  * @throws {TypeError} When request construction, JSON request serialization, headers,
+  *   search params, native `fetch`, or `response.json()` body reading fail with a
+  *   `TypeError`.
+  * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+  *   request/body read as an `AbortError` DOMException.
+  * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+  * @throws Any error thrown or rejected by the provided Standard Schema validator.
+  */
+  <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options: ExtendedRequestInit & {
+    throwOnValidationError: false;
+  }): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
   /**
   * Fetch with schema validation and throwOnValidationError: true or undefined (default)
-  * @param resource - URL or path to fetch
+  * @param input - URL or path to fetch
   * @param schema - Standard Schema for response validation
   * @param options - Extended request options
   * @returns Validated data of type TSchema
-  */
-  <TSchema extends StandardSchemaV1>(resource: string, schema: TSchema, options?: ExtendedRequestInit<true | undefined>): Promise<StandardSchemaV1.InferOutput<TSchema>>;
+  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+  * @throws {ValidationError} When validation returns issues.
+  * @throws {TypeError} When request construction, JSON request serialization, headers,
+  *   search params, native `fetch`, or `response.json()` body reading fail with a
+  *   `TypeError`.
+  * @throws {DOMException} When native `fetch` or `response.json()` rejects an aborted
+  *   request/body read as an `AbortError` DOMException.
+  * @throws {SyntaxError} When `response.json()` cannot parse the response body.
+  * @throws Any error thrown or rejected by the provided Standard Schema validator.
+  */
+  <TSchema extends StandardSchemaV1>(input: FetchInput, schema: TSchema, options?: ExtendedRequestInit & {
+    throwOnValidationError?: true | undefined;
+  }): Promise<StandardSchemaV1.InferOutput<TSchema>>;
   /**
   * Fetch without schema validation
-  * @param resource - URL or path to fetch
+  * @param input - URL or path to fetch
   * @param options - Extended request options
   * @returns Raw Response object
+  * @throws {FetchError} When `throwOnFetchError` is `true` and the response is not ok.
+  * @throws {TypeError} When request construction, JSON request serialization, headers,
+  *   search params, or native `fetch` fail with a `TypeError`.
+  * @throws {DOMException} When native `fetch` rejects an aborted request as an
+  *   `AbortError` DOMException.
   */
-  (resource: string, options?: ExtendedRequestInit): Promise<Response>;
+  (input: FetchInput, options?: ExtendedRequestInit): Promise<Response>;
 }
 /**
 * API HTTP method-specific fetch functions
+*
+* @example
+* const user = await api.get("/users/1", UserSchema);
 */
 interface ApiMethods {
   /**
@@ -136,5 +162,5 @@ interface ApiMethods {
   put: $Fetch;
 }
 //#endregion
-export { $Fetch, ApiMethods, CreateFetchOptions, ExtendedRequestInit, FetchDefaults, JsonValue, RequestBody, SearchParams };
+export { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;AAQA;AASA;AAWA;AAAqC;AAKD,KAzBxB,YAAA,GACR,eAwBgC,GAvBhC,MAuBgC,CAAA,MAAA,EAAA,MAAA,CAAA,GAAA,MAAA,GAAA,CAAA,MAAA,EAAA,MAAA,CAAA,EAAA;;;;AASnB,KAzBL,SAAA,GAyBK,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,GApBb,SAoBa,EAAA,GAAA;EAWjB,CAAA,GAAY,EAAA,MAAA,CAAA,EA9BS,SA8BT;AAaZ,CAAA;AA+BA;AAKA;;AAUY,KApFA,WAAA,GAAc,QAoFd,GApFyB,SAoFzB;;;;KA/EP,uBAAA,GAA0B,IAiFD,CAjFM,WAiFN,EAAA,MAAA,CAAA,GAAA;EAAzB;;;EAYS,IAAA,CAAA,EAzFL,WAyFK;EAC4B;;;;EAQmB,YAAA,CAAA,EA7F5C,YA6F4C;EAAR;;AAMrD;;EAQO,iBAAA,CAAA,EAAA,OAAA;CAIE;;;;KApGG,iGAER;;;;;2BAKuB;;;;;UAMV,aAAA;;;;;;;;;;YAUL;;;;;iBAKK;;;;;;;;;;;;;;;KAgBL,kBAAA,GAAqB,QAAQ;;;;UAKxB,MAAA;;;;;;;;mBAQE,4CAEP,kBACC,6BACR,QAAQ,gBAAA,CAAiB,OAAO,gBAAA,CAAiB,YAAY;;;;;;;;mBAS/C,4CAEP,mBACE,wCACT,QAAQ,gBAAA,CAAiB,YAAY;;;;;;;+BAQX,sBAAsB,QAAQ;;;;;UAM5C,UAAA;;;;UAIP;;;;OAIH;;;;SAIE;;;;QAID;;;;OAID"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;KAQY,UAAA,GAAa,UAAA,QAAkB,KAAA;AAAA,KAEtC,oBAAA,GAAuB,qBAAA,QAA6B,eAAA;AAAA,KAEpD,eAAA,GAAkB,WAAA;EACrB,IAAA;AAAA;AAAA,KAGG,YAAA,GAAe,IAAA,CAAK,WAAA;EANgC;AAAA;;;EAWvD,IAAA;EACA,IAAA;AAAA;AAAA,KAGG,iBAAA;;;;;EAKH,YAAA,GAAe,oBAAA;;;;AARf;EAaA,iBAAA;;;;;EAKA,sBAAA;AAAA;;;AAaF;;;;;;;;KAAY,mBAAA,IAAuB,eAAA,GAAkB,YAAA,IAAgB,iBAAA;;;;;AAYrE;;;;;;UAAiB,aAAA;;;;;EAKf,OAAA;EAoBA;AAMF;;;EArBE,OAAA,GAAU,WAAA;;;;;EAKV,YAAA,GAAe,oBAAA;;;;;EAKf,iBAAA;;;;;EAKA,sBAAA;AAAA;;;;UAMe,MAAA;;;;;;;;;;;;;;;;mBAgBE,gBAAA,EACf,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,EAAS,mBAAA;IAAwB,sBAAA;EAAA,IAChC,OAAA,CAAQ,gBAAA,CAAiB,MAAA,CAAO,gBAAA,CAAiB,WAAA,CAAY,OAAA;;;;;;;;;;;;;;;;;mBAkB/C,gBAAA,EACf,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,OAAA,EACR,OAAA,GAAU,mBAAA;IACR,sBAAA;EAAA,IAED,OAAA,CAAQ,gBAAA,CAAiB,WAAA,CAAY,OAAA;EAsBzB;;;;;;;;;;;EAAA,CATd,KAAA,EAAO,UAAA,EAAY,OAAA,GAAU,mBAAA,GAAsB,OAAA,CAAQ,QAAA;AAAA;;;;;;;UAS7C,UAAA;EAoBV;;;EAhBL,MAAA,EAAQ,MAAA;;;;EAIR,GAAA,EAAK,MAAA;;;;EAIL,KAAA,EAAO,MAAA;;;;EAIP,IAAA,EAAM,MAAA;;;;EAIN,GAAA,EAAK,MAAA;AAAA"}

package/dist/types.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/dist/url.d.mts

@@ -0,0 +1,27 @@
+import { ExtendedRequestInit, FetchDefaults } from "./types.mjs";
+
+//#region src/url.d.ts
+/**
+* Resolves final request URL by applying baseURL and layered search params.
+*
+* Search param precedence:
+* 1. `defaults.searchParams`
+* 2. search params already present in `resourceUrl`
+* 3. per-request `searchParams`
+*
+* @example
+* const finalUrl = resolveRequestUrl(
+*   "/users?page=2",
+*   { ...defaults, baseURL: "https://api.example.com", searchParams: { locale: "en" } },
+*   { page: "3" },
+* );
+* // https://api.example.com/users?locale=en&page=3
+*
+* @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by
+*   `URL`, or when default/per-request search params cannot be converted by
+*   `URLSearchParams`.
+*/
+declare function resolveRequestUrl(resourceUrl: string, defaults: FetchDefaults, searchParams: ExtendedRequestInit["searchParams"] | undefined): string;
+//#endregion
+export { resolveRequestUrl };
+//# sourceMappingURL=url.d.mts.map

package/dist/url.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.mts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBA4BgB,iBAAA,CACd,WAAA,UACA,QAAA,EAAU,aAAA,EACV,YAAA,EAAc,mBAAA"}

package/dist/url.mjs

@@ -0,0 +1,56 @@
+//#region src/url.ts
+/**
+* Resolves final request URL by applying baseURL and layered search params.
+*
+* Search param precedence:
+* 1. `defaults.searchParams`
+* 2. search params already present in `resourceUrl`
+* 3. per-request `searchParams`
+*
+* @example
+* const finalUrl = resolveRequestUrl(
+*   "/users?page=2",
+*   { ...defaults, baseURL: "https://api.example.com", searchParams: { locale: "en" } },
+*   { page: "3" },
+* );
+* // https://api.example.com/users?locale=en&page=3
+*
+* @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by
+*   `URL`, or when default/per-request search params cannot be converted by
+*   `URLSearchParams`.
+*/
+function resolveRequestUrl(resourceUrl, defaults, searchParams) {
+	return resolveSearchParams(defaults.baseURL ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString() : resourceUrl, defaults.searchParams, searchParams);
+}
+/**
+* Resolves search params by applying default params, URL params, then request params.
+*/
+function resolveSearchParams(url, defaultSearchParams, searchParams) {
+	const hasFragment = url.includes("#");
+	const [urlWithoutHash = "", hash = ""] = url.split("#", 2);
+	const [pathname = "", urlSearchParams] = urlWithoutHash.split("?", 2);
+	const resolvedSearchParams = new URLSearchParams();
+	mergeSearchParams(resolvedSearchParams, defaultSearchParams);
+	mergeSearchParams(resolvedSearchParams, urlSearchParams);
+	mergeSearchParams(resolvedSearchParams, searchParams);
+	const resolvedSearch = resolvedSearchParams.toString();
+	const fragmentSuffix = hasFragment ? `#${hash}` : "";
+	if (!resolvedSearch) return `${pathname}${fragmentSuffix}`;
+	return `${pathname}?${resolvedSearch}${fragmentSuffix}`;
+}
+/**
+* Ensures a URL has a trailing slash for relative URL resolution.
+*/
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+/**
+* Copies search params into target, overriding duplicate keys.
+*/
+function mergeSearchParams(target, source) {
+	for (const [key, value] of new URLSearchParams(source)) target.set(key, value);
+}
+//#endregion
+export { resolveRequestUrl };
+
+//# sourceMappingURL=url.mjs.map

package/dist/url.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.mjs","names":[],"sources":["../src/url.ts"],"sourcesContent":["/**\n * URL resolution and query merging utilities.\n *\n * @module\n */\n\nimport type { ExtendedRequestInit, FetchDefaults } from \"./types.js\";\n\n/**\n * Resolves final request URL by applying baseURL and layered search params.\n *\n * Search param precedence:\n * 1. `defaults.searchParams`\n * 2. search params already present in `resourceUrl`\n * 3. per-request `searchParams`\n *\n * @example\n * const finalUrl = resolveRequestUrl(\n *   \"/users?page=2\",\n *   { ...defaults, baseURL: \"https://api.example.com\", searchParams: { locale: \"en\" } },\n *   { page: \"3\" },\n * );\n * // https://api.example.com/users?locale=en&page=3\n *\n * @throws {TypeError} When `baseURL` and `resourceUrl` cannot be resolved by\n *   `URL`, or when default/per-request search params cannot be converted by\n *   `URLSearchParams`.\n */\nexport function resolveRequestUrl(\n  resourceUrl: string,\n  defaults: FetchDefaults,\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined,\n): string {\n  const url = defaults.baseURL\n    ? new URL(resourceUrl, ensureTrailingSlash(defaults.baseURL)).toString()\n    : resourceUrl;\n\n  return resolveSearchParams(url, defaults.searchParams, searchParams);\n}\n\n/**\n * Resolves search params by applying default params, URL params, then request params.\n */\nfunction resolveSearchParams(\n  url: string,\n  defaultSearchParams: FetchDefaults[\"searchParams\"] | undefined,\n  searchParams: ExtendedRequestInit[\"searchParams\"] | undefined,\n): string {\n  const hasFragment = url.includes(\"#\");\n  const [urlWithoutHash = \"\", hash = \"\"] = url.split(\"#\", 2);\n  const [pathname = \"\", urlSearchParams] = urlWithoutHash.split(\"?\", 2);\n  const resolvedSearchParams = new URLSearchParams();\n\n  mergeSearchParams(resolvedSearchParams, defaultSearchParams);\n  mergeSearchParams(resolvedSearchParams, urlSearchParams);\n  mergeSearchParams(resolvedSearchParams, searchParams);\n\n  const resolvedSearch = resolvedSearchParams.toString();\n  const fragmentSuffix = hasFragment ? `#${hash}` : \"\";\n\n  if (!resolvedSearch) {\n    return `${pathname}${fragmentSuffix}`;\n  }\n\n  return `${pathname}?${resolvedSearch}${fragmentSuffix}`;\n}\n\n/**\n * Ensures a URL has a trailing slash for relative URL resolution.\n */\nfunction ensureTrailingSlash(url: string): string {\n  return url.endsWith(\"/\") ? url : `${url}/`;\n}\n\n/**\n * Copies search params into target, overriding duplicate keys.\n */\nfunction mergeSearchParams(\n  target: URLSearchParams,\n  source: ExtendedRequestInit[\"searchParams\"] | undefined,\n): void {\n  for (const [key, value] of new URLSearchParams(source)) {\n    target.set(key, value);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,kBACd,aACA,UACA,cACQ;AAKR,QAAO,oBAJK,SAAS,UACjB,IAAI,IAAI,aAAa,oBAAoB,SAAS,QAAQ,CAAC,CAAC,UAAU,GACtE,aAE4B,SAAS,cAAc,aAAa;;;;;AAMtE,SAAS,oBACP,KACA,qBACA,cACQ;CACR,MAAM,cAAc,IAAI,SAAS,IAAI;CACrC,MAAM,CAAC,iBAAiB,IAAI,OAAO,MAAM,IAAI,MAAM,KAAK,EAAE;CAC1D,MAAM,CAAC,WAAW,IAAI,mBAAmB,eAAe,MAAM,KAAK,EAAE;CACrE,MAAM,uBAAuB,IAAI,iBAAiB;AAElD,mBAAkB,sBAAsB,oBAAoB;AAC5D,mBAAkB,sBAAsB,gBAAgB;AACxD,mBAAkB,sBAAsB,aAAa;CAErD,MAAM,iBAAiB,qBAAqB,UAAU;CACtD,MAAM,iBAAiB,cAAc,IAAI,SAAS;AAElD,KAAI,CAAC,eACH,QAAO,GAAG,WAAW;AAGvB,QAAO,GAAG,SAAS,GAAG,iBAAiB;;;;;AAMzC,SAAS,oBAAoB,KAAqB;AAChD,QAAO,IAAI,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI;;;;;AAM1C,SAAS,kBACP,QACA,QACM;AACN,MAAK,MAAM,CAAC,KAAK,UAAU,IAAI,gBAAgB,OAAO,CACpD,QAAO,IAAI,KAAK,MAAM"}

package/package.json

@@ -1,80 +1,73 @@
 {
   "name": "@zap-studio/fetch",
-  "version": "0.4.7",
-  "type": "module",
-  "license": "MIT",
+  "version": "0.5.0",
   "private": false,
-  "homepage": "https://www.zapstudio.dev/packages/fetch",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zap-studio/monorepo.git",
-    "directory": "packages/fetch"
-  },
   "description": "A type-safe fetch wrapper for HTTP requests with runtime schema validation.",
   "keywords": [
-    "fetch",
-    "type-safe",
-    "validation",
-    "schema",
-    "typescript",
-    "http",
     "api",
-    "zod",
-    "valibot",
     "arktype",
-    "runtime validation",
     "error handling",
-    "standard schema",
+    "fetch",
+    "http",
     "request",
-    "response"
+    "response",
+    "runtime validation",
+    "schema",
+    "standard schema",
+    "type-safe",
+    "typescript",
+    "valibot",
+    "validation",
+    "zod"
   ],
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://www.zapstudio.dev/packages/fetch",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zap-studio/monorepo.git",
+    "directory": "packages/fetch"
   },
   "files": [
     "dist",
     "CHANGELOG.md",
     "LICENSE",
-    "README.md",
-    "skills",
-    "bin",
-    "!skills/_artifacts"
+    "README.md"
   ],
-  "dependencies": {
-    "@standard-schema/spec": "^1.1.0",
-    "@zap-studio/validation": "0.3.2"
-  },
-  "devDependencies": {
-    "@types/node": "^25.0.2",
-    "@vitest/coverage-v8": "^4.0.15",
-    "arktype": "^2.1.29",
-    "tsdown": "^0.18.0",
-    "typescript": "^5.9.3",
-    "valibot": "^1.2.0",
-    "vitest": "^4.0.18",
-    "zod": "^4.2.0",
-    "@zap-studio/tsdown-config": "0.0.0",
-    "@zap-studio/typescript-config": "0.0.0",
-    "@zap-studio/vitest-config": "0.0.0"
-  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
     "./constants": "./dist/constants.mjs",
     "./errors": "./dist/errors.mjs",
+    "./headers": "./dist/headers.mjs",
+    "./internal": "./dist/internal.mjs",
+    "./methods": "./dist/methods.mjs",
+    "./request": "./dist/request.mjs",
     "./types": "./dist/types.mjs",
-    "./utils": "./dist/utils.mjs",
+    "./url": "./dist/url.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "bin": {
-    "intent": "./bin/intent.js"
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@zap-studio/validation": "0.3.2"
+  },
+  "devDependencies": {
+    "arktype": "^2.2.0",
+    "typescript": "^6.0.3",
+    "valibot": "^1.3.1",
+    "vite-plus": "^0.1.19",
+    "zod": "^4.3.6",
+    "@zap-studio/typescript": "0.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "tsdown --config tsdown.config.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest --watch"
+    "build": "vp pack",
+    "test": "vp test run",
+    "test:watch": "vp test watch"
   }
 }

package/bin/intent.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-// Auto-generated by @tanstack/intent setup
-// Exposes the intent end-user CLI for consumers of this library.
-await import("@tanstack/intent/intent-library");

package/dist/errors-DQfwnwmz.mjs

@@ -1,18 +0,0 @@
-//#region src/errors.ts
-/**
-* Error thrown for HTTP errors (non-2xx responses)
-*/
-var FetchError = class extends Error {
-	status;
-	response;
-	constructor(message, response) {
-		super(message);
-		this.name = "FetchError";
-		this.status = response.status;
-		this.response = response;
-	}
-};
-
-//#endregion
-export { FetchError as t };
-//# sourceMappingURL=errors-DQfwnwmz.mjs.map

package/dist/errors-DQfwnwmz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-DQfwnwmz.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Error thrown for HTTP errors (non-2xx responses)\n */\nexport class FetchError extends Error {\n  status: Response[\"status\"];\n  response: 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":";;;;AAGA,IAAa,aAAb,cAAgC,MAAM;CACpC;CACA;CAEA,YAAY,SAAiB,UAAoB;AAC/C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,SAAS,SAAS;AACvB,OAAK,WAAW"}

package/dist/utils.d.mts

@@ -1,33 +0,0 @@
-import { $Fetch, ExtendedRequestInit, FetchDefaults } from "./types.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/utils.d.ts
-
-/**
-* Merges two HeadersInit objects, with the second one taking precedence
-*
-* @example
-* const baseHeaders = { "Authorization": "Bearer token", "Content-Type": "application/json" };
-* const overrideHeaders = { "Content-Type": "application/xml", "X-Custom-Header": "value" };
-*
-* const merged = mergeHeaders(baseHeaders, overrideHeaders);
-*
-* // Resulting headers:
-* // {
-* //   "Authorization": "Bearer token",
-* //   "Content-Type": "application/xml",
-* //   "X-Custom-Header": "value"
-* // }
-*/
-declare function mergeHeaders(base: HeadersInit | undefined, override: HeadersInit | undefined): Headers | undefined;
-/**
-* Internal fetch implementation used by both $fetch and createFetch
-*/
-declare function fetchInternal(resource: string, schema: StandardSchemaV1 | undefined, options: ExtendedRequestInit | undefined, defaults: FetchDefaults): Promise<unknown>;
-/**
-* Creates an HTTP method helper bound to a fetch function
-*/
-declare function createMethod<TFetch extends $Fetch>(fetchFn: TFetch, method: string): $Fetch;
-//#endregion
-export { createMethod, fetchInternal, mergeHeaders };
-//# sourceMappingURL=utils.d.mts.map

package/dist/utils.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;AAyLA;;;;;;AAiFA;;;AAGG,iBA7Qa,YAAA,CA6Qb,IAAA,EA5QK,WA4QL,GAAA,SAAA,EAAA,QAAA,EA3QS,WA2QT,GAAA,SAAA,CAAA,EA1QA,OA0QA,GAAA,SAAA;;;;iBApFmB,aAAA,2BAEZ,uCACC,2CACC,gBACT;;;;iBA4Ea,4BAA4B,iBACjC,yBAER"}