@springbrand/http 0.0.0-stage → 0.1.0-alpha.0

package/.agents/skills/dune-react-http/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: dune-react-http
+description: Use SpringBrand shared HTTP contracts, Axios request clients, Query error recovery, and server response helpers. Trigger when constructing requests, injecting tokens, handling HTTP failures, connecting TanStack Query, or creating standard server responses.
+---
+
+# Dune React HTTP
+
+Read the installed declarations and README before configuring a client. Public entry points own different runtime needs; import only the capability needed.
+
+| Entry point | Responsibility |
+| --- | --- |
+| @springbrand/http | Runtime-neutral contracts and one ApiError class |
+| @springbrand/http/errors | Error definitions and cancellation recognition |
+| @springbrand/http/client | Axios client and standard HTTP error parsing |
+| @springbrand/http/query | Optional TanStack React Query integration |
+| @springbrand/http/server | Standard Response helpers and service authentication |
+
+## Client setup
+
+Create one client per trusted API origin. Inject getToken; do not copy Token storage or Bearer construction into requests. Relative paths include the configured base path. Foreign origins and URL credentials are rejected. Defaults are Cookie omit, 15-second deadline and 10-MiB response limit.
+
+Use get/post/put/patch/delete for payloads, request for data plus status and headers. Explicitly choose json, text or blob for endpoints without the standard success envelope. FormData owns its boundary. Pass Query's signal through; do not wrap cancellation as network failure.
+
+## Error handling
+
+Errors stay rejected even when presentation is silent or a business callback returns true. Never return fake successful data, match error messages, or serialize an Axios error/config to logs. Business detail validation belongs to the consumer's decoder; default parsing does not expose arbitrary details.
+
+Choose one feedback owner: client for direct calls, query for Query/Mutation. Inline pages must render errors. Query integration retries safe reads only, with at most two extra attempts by default; mutations do not retry. Preserve cache after background failure. User refresh can explicitly request user feedback.
+
+Use the guarded onMutationSuccess(meta) hook for application-owned cache invalidation. The SDK passes metadata without owning business query keys; callback failures preserve successful mutation results.
+
+Only confirmed current Bearer session failures trigger onUnauthorized. Never clear sessions on network failures, every 401, or 403. SDK callbacks guard stale Token responses and duplicate feedback. Cookie login/recovery belongs to consumer authentication.
+
+## Server setup
+
+Return ok or fail through framework-compatible Response handling. Failures use real 4xx/5xx and public error messages. Keep domain errors separate until the HTTP handler translates them. Validate business details before returning them. toErrorResponse hides unknown exceptions.
+
+Use service request/verification helpers for service credentials, independently of user authentication. Never forward user Cookie/Authorization or send service tokens to another origin.
+
+## Verification
+
+Exercise transient read recovery, write uncertainty, field errors, cancellation, Token changes and callback failures. Verify server imports without React Query and packaged public entry points. Use HTTP Storybook examples as behavior references, not copied implementations. Do not add app-local parallel clients or edit installed node_modules.

package/README.md

@@ -1,3 +1,153 @@
-# Temporary Holding Version
+# SpringBrand HTTP SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+一个包提供共享 HTTP 合同、Axios 客户端、Query 接入和框架无关的服务端辅助函数。错误规则由 SDK 维护，消费者提供 Token、通知和业务回调。
+
+## 安装
+
+```sh
+pnpm add @springbrand/http@alpha
+```
+
+使用 Query 入口时，另外安装兼容的 `@tanstack/react-query`。
+
+## 入口
+
+| 入口 | 能力 |
+| --- | --- |
+| `@springbrand/http` | 共享类型与 ApiError，无浏览器初始化 |
+| `@springbrand/http/errors` | 基础错误码和取消识别 |
+| `@springbrand/http/client` | createHttpClient、parseHttpError |
+| `@springbrand/http/query` | createHttpQueryClient、读取重试策略 |
+| `@springbrand/http/server` | ok、fail、toErrorResponse、服务鉴权与安全诊断 |
+
+客户端依赖 Axios。Query 是独立入口，以 `@tanstack/react-query` 作为可选 peer；核心和服务端使用者无需安装 React 或 Query。服务端要求标准 Request、Response 和 Web Crypto，建议 Node.js 24 或兼容运行时。
+
+## 请求实例
+
+```ts
+import { createHttpClient } from '@springbrand/http/client';
+
+let token: string | null = null;
+const api = createHttpClient({
+  baseUrl: 'https://api.example.com/api',
+  getToken: () => token,
+  notify: notice => showNotice(notice),
+  onUnauthorized: () => { token = null; },
+});
+
+const items = await api.get<Item[]>('/items');
+await api.post('/items', { name: 'Example' });
+```
+
+Token 每次发送时读取。实例只向绑定来源发送请求；非法地址、带用户名密码的 URL 和其他来源的绝对 URL 会在发送前失败。`baseUrl` 的路径前缀会与相对接口路径拼接。
+
+客户端使用 Axios Fetch Adapter，默认 `credentials: 'omit'`。Cookie 登录使用显式 `credentials: 'include'` 的独立实例。`auth: false` 关闭 SDK 的 Bearer 注入，Cookie 策略不随之改变。有 getToken 时，SDK 管理 Authorization，额外请求头不能覆盖它。
+
+### 响应与下载
+
+默认解包 `{ success: true, msg, errMsg: '', code: '' }`。失败保留真实 HTTP 状态、稳定错误码、字段错误和请求编号。未验证的 details 不直接透传；需要业务详情时通过 decodeError 校验。
+
+get、post、put、patch、delete 返回业务数据。通用 request 返回 `{ data, status, headers }`，响应头名称统一为小写。
+
+```ts
+const file = await api.request<Blob>('/download', { responseMode: 'blob' });
+const filenameHeader = file.headers['content-disposition'];
+```
+
+普通 JSON、文本和 Blob 分别使用 json、text、blob 模式。GET 和 HEAD 不接受请求体。FormData 不手工设置 multipart boundary。
+
+默认超时 15 秒，覆盖 timeoutMs，0 表示关闭超时。默认最大响应 10 MiB，覆盖 maxResponseBytes；0 仅允许空内容。客户端在读取数据流时检查实际字节数，超限取消读取。第一版不暴露无限流、SSE 或原生 Response 合同。
+
+## Query 接入
+
+```ts
+import { createHttpQueryClient } from '@springbrand/http/query';
+
+const api = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  feedbackOwner: 'query',
+  notify: notice => showNotice(notice),
+});
+const queryClient = createHttpQueryClient({ handleError: api.handleError });
+
+// 传入 QueryClientProvider，业务 queryKey 由功能模块管理。
+useQuery({
+  queryKey: ['items'],
+  queryFn: ({ signal }) => api.get<Item[]>('/items', { signal }),
+  meta: { feedback: 'inline' },
+});
+```
+
+默认最多两次额外重试，只针对已确认 GET 或 HEAD 的网络错误、超时和 429、502、503、504。Mutation 默认不重试；POST 即使误放进 queryFn 也不会获得默认重试权限。业务主动覆盖 Query 的 retry 选项后，由消费者承担该操作的重试合同。
+
+恢复可见或网络恢复时，Query 刷新过期数据。已有缓存的后台错误静默，首次加载在页面内展示；SDK 不吞掉失败。用户主动刷新需要在失败后用 `api.handleError(error, { intent: 'read', trigger: 'user' })` 明确反馈。
+
+Query 项目中的直接命令式调用使用 `{ feedbackOwner: 'client' }`；经 Mutation 管理的操作继续由 Query 负责最终反馈，避免重复提示。
+
+业务缓存失效通过 `createHttpQueryClient` 的 `onMutationSuccess(meta)` 扩展接入。它接收 Mutation 元数据，由消费者解释业务缓存键；回调失败不会改变已经成功的 Mutation 结果。
+
+## 错误和业务扩展
+
+```ts
+import { ApiError, isRequestCancelled } from '@springbrand/http';
+
+const api = createHttpClient({
+  baseUrl: 'https://api.example.com',
+  notify: notice => showNotice(notice),
+  onBusinessError(error, context) {
+    if (context.intent === 'mutation' && error.code === 'ACTION_REQUIRED') {
+      openActionDialog();
+      return true;
+    }
+    return false;
+  },
+});
+```
+
+返回 true 只接管提示，原请求仍然拒绝。inline、silent 和后台场景不打开全局业务窗口。业务、通知或诊断回调自身异常不替换原始请求结果。
+
+主动写入的网络失败会提示结果暂时无法确认，不自动重发。取消保持取消语义，不包装成 NETWORK_ERROR。超时为 REQUEST_TIMEOUT，格式错误为 RESPONSE_INVALID，内容超限为 RESPONSE_TOO_LARGE。
+
+默认仅 401 且 AUTH_UNAUTHENTICATED 触发失效回调。旧身份的响应不清理新身份，同一 Token 并发失效仅处理一次；网络错误、其他 401 和 403 不退出登录。默认自动处理针对实例携带的 Bearer 身份，Cookie 会话的恢复流程由消费者掌握。
+
+ApiError 使用对象参数，泛型 details 可用于业务详情：
+
+```ts
+throw new ApiError<{ revision: number }>({
+  status: 409,
+  code: 'VERSION_CONFLICT',
+  message: 'Please refresh before saving',
+  details: { revision: 2 },
+});
+```
+
+decodeResponse 处理特殊成功协议；decodeError 可调用公开 parseHttpError 后验证并附加业务 details。SDK 保留请求上下文、错误类和原始状态，不在公共错误中保存原始 Axios config 或凭据。
+
+## 服务端
+
+```ts
+import { ok, fail, toErrorResponse } from '@springbrand/http/server';
+
+return ok({ items: [] }, { requestId });
+return fail({ status: 403, code: 'REQUEST_FORBIDDEN', message: 'Access denied', requestId });
+```
+
+ok 支持 200、201、202；无内容成功直接用标准 Response。fail 只接受真实 4xx、5xx，拒绝客户端网络码。请求编号同时进入错误响应体和 X-Request-ID，缺失时自动生成。
+
+toErrorResponse 公开标准 ApiError 的安全信息，未知异常返回固定 500 INTERNAL_ERROR。业务错误和 details 在 HTTP 处理器中翻译和验证。
+
+createServiceRequest 为绑定来源构造服务请求，清理用户 Authorization 和 Cookie，注入 X-SpringBrand-Service-Token。verifyServiceToken 比较等长摘要。服务请求不跟随重定向，不使用用户 Bearer 的登录失效流程。
+
+## 验证与示例
+
+```sh
+pnpm --filter @springbrand/http typecheck
+pnpm --filter @springbrand/http lint
+pnpm --filter @springbrand/http test
+pnpm --filter @springbrand/http build
+pnpm build-storybook
+```
+
+Storybook 的 HTTP 分类包含成功、后台恢复、首次失败、字段错误、业务扩展、认证、取消、动态 Token 和上传下载。模拟服务仍通过真实 Axios 请求实现。
+
+完整设计位于 dune-react 的 trevordocs/axios-request-sdk-architecture.md。预发布版本使用 npm 的 alpha 标签，业务项目的迁移由各项目独立安排。

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { HttpClientConfig, HttpRequestOptions, HttpResult } from "./types.js";
+export type { HttpClientConfig, HttpRequestOptions, HttpResult } from "./types.js";
+export { ApiError } from "./errors.js";
+export { parseHttpError } from "./response.js";
+export declare function createHttpClient(config: HttpClientConfig): {
+    request: <T>(path: string, options?: HttpRequestOptions) => Promise<HttpResult<T>>;
+    get: <T>(path: string, options?: HttpRequestOptions) => Promise<T>;
+    post: <T>(path: string, body?: unknown, options?: HttpRequestOptions) => Promise<T>;
+    put: <T>(path: string, body?: unknown, options?: HttpRequestOptions) => Promise<T>;
+    patch: <T>(path: string, body?: unknown, options?: HttpRequestOptions) => Promise<T>;
+    delete: <T>(path: string, options?: HttpRequestOptions) => Promise<T>;
+    handleError: (error: unknown, input?: Partial<import("./types.js").ErrorContext>) => void;
+};
+export type HttpClient = ReturnType<typeof createHttpClient>;

package/dist/client.js

@@ -0,0 +1,138 @@
+import axios from "axios";
+import { ApiError, errorDefinitions, isRequestCancelled } from "./errors.js";
+import { createErrorHandler } from "./error-handler.js";
+import { toSafeDiagnostics } from "./diagnostics.js";
+import { serviceUrl, boundUrl } from "./url.js";
+import { readBody, errorBody, parseRetryAfter, parseHttpError, decodeBody } from "./response.js";
+function createHttpClient(config) {
+  const base = serviceUrl(config.baseUrl);
+  const transport = axios.create({
+    adapter: "fetch",
+    env: { fetch: config.fetch ?? globalThis.fetch },
+    validateStatus: () => true,
+    responseType: "stream",
+    timeout: 0,
+    withCredentials: config.credentials === "same-origin" ? void 0 : config.credentials === "include",
+    fetchOptions: { redirect: "error" }
+  });
+  const handleError = createErrorHandler(config);
+  let rejectedToken;
+  function report(error, started, method, stage = "request") {
+    if (isRequestCancelled(error)) return;
+    try {
+      config.onFailure?.(toSafeDiagnostics(error, { method, origin: base.origin, elapsedMs: Date.now() - started, stage }));
+    } catch {
+    }
+  }
+  async function request(path, options = {}) {
+    const started = Date.now();
+    const method = options.method ?? "GET";
+    const context = { method, feedback: options.feedback ?? "auto", feedbackOwner: options.feedbackOwner ?? config.feedbackOwner ?? "client" };
+    const controller = new AbortController();
+    const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+    let timer;
+    let sentToken;
+    let received = false;
+    try {
+      if (!["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(method) || (method === "GET" || method === "HEAD") && options.body !== void 0) throw new ApiError({ status: 0, code: "REQUEST_INVALID_INPUT", message: errorDefinitions.REQUEST_INVALID_INPUT, kind: "input" });
+      const url = boundUrl(base, path);
+      for (const [key, value] of Object.entries(options.params ?? {})) {
+        for (const item of Array.isArray(value) ? value : [value]) if (item !== void 0 && item !== null) url.searchParams.append(key, String(item));
+      }
+      const timeout = options.timeoutMs ?? config.timeoutMs ?? 15e3;
+      const limit = options.maxResponseBytes ?? config.maxResponseBytes ?? 10 * 1024 * 1024;
+      if (!Number.isFinite(timeout) || timeout < 0 || !Number.isSafeInteger(limit) || limit < 0) throw new ApiError({ status: 0, code: "REQUEST_INVALID_INPUT", message: errorDefinitions.REQUEST_INVALID_INPUT, kind: "input" });
+      if (signal.aborted) throw signal.reason;
+      const headers = new Headers(config.getHeaders?.());
+      new Headers(options.headers).forEach((value, key) => headers.set(key, value));
+      if (config.getToken) {
+        headers.delete("Authorization");
+        sentToken = options.auth === false ? null : config.getToken();
+        if (sentToken !== rejectedToken) rejectedToken = void 0;
+        if (sentToken) headers.set("Authorization", `Bearer ${sentToken}`);
+      }
+      if (options.idempotencyKey) headers.set("Idempotency-Key", options.idempotencyKey);
+      if (options.body instanceof FormData) headers.delete("Content-Type");
+      if (timeout > 0) timer = setTimeout(() => controller.abort(new ApiError({ status: 0, code: "REQUEST_TIMEOUT", message: errorDefinitions.REQUEST_TIMEOUT, kind: "timeout" })), timeout);
+      const requestHeaders = new axios.AxiosHeaders(Object.fromEntries(headers));
+      if (options.body instanceof FormData) requestHeaders.setContentType("multipart/form-data");
+      const response = await transport.request({
+        url: url.href,
+        method,
+        headers: requestHeaders,
+        data: options.body,
+        signal,
+        onUploadProgress: options.onUploadProgress ? (progress) => {
+          try {
+            options.onUploadProgress?.({ loaded: progress.loaded, total: progress.total, progress: progress.progress });
+          } catch (error) {
+            report(error, started, method, "callback");
+          }
+        } : void 0
+      });
+      received = true;
+      const responseHeaders = {};
+      const rawHeaders = response.headers instanceof axios.AxiosHeaders ? response.headers.toJSON() : response.headers;
+      for (const [key, value] of Object.entries(rawHeaders)) if (typeof value === "string" || typeof value === "number" || Array.isArray(value)) responseHeaders[key.toLowerCase()] = String(value);
+      const info = { status: response.status, headers: responseHeaders };
+      const chunks = await readBody(response.data, info, limit);
+      if (signal.aborted) throw signal.reason;
+      if (response.status < 200 || response.status >= 300) {
+        const data2 = errorBody(chunks);
+        if (config.decodeError) {
+          try {
+            const decoded = config.decodeError(data2, info);
+            if (!(decoded instanceof ApiError)) throw new Error("invalid decoder");
+            throw decoded;
+          } catch (error) {
+            if (error instanceof ApiError) throw new ApiError({ ...error, status: response.status, message: error.message, requestId: error.requestId ?? responseHeaders["x-request-id"], retryAfterMs: error.retryAfterMs ?? parseRetryAfter(responseHeaders["retry-after"]) });
+            throw new ApiError({ status: response.status, code: "RESPONSE_INVALID", message: errorDefinitions.RESPONSE_INVALID, kind: "response", requestId: responseHeaders["x-request-id"] });
+          }
+        }
+        throw parseHttpError(data2, info);
+      }
+      const data = decodeBody(chunks, options.responseMode ?? config.responseMode ?? "envelope", info, config);
+      return { data, status: response.status, headers: responseHeaders };
+    } catch (error) {
+      const reason = signal.aborted ? signal.reason : error;
+      if (signal.aborted && !(reason instanceof ApiError) && !(reason instanceof Error && reason.name === "TimeoutError")) throw reason;
+      if (isRequestCancelled(reason)) throw reason;
+      const normalized = reason instanceof ApiError ? reason : new ApiError({
+        status: 0,
+        code: reason instanceof Error && reason.name === "TimeoutError" ? "REQUEST_TIMEOUT" : received || axios.isAxiosError(reason) && reason.request instanceof Request ? "NETWORK_ERROR" : "REQUEST_INVALID_INPUT",
+        message: reason instanceof Error && reason.name === "TimeoutError" ? errorDefinitions.REQUEST_TIMEOUT : received || axios.isAxiosError(reason) && reason.request instanceof Request ? errorDefinitions.NETWORK_ERROR : errorDefinitions.REQUEST_INVALID_INPUT,
+        kind: reason instanceof Error && reason.name === "TimeoutError" ? "timeout" : received || axios.isAxiosError(reason) && reason.request instanceof Request ? "network" : "input"
+      });
+      const failure = new ApiError({ ...normalized, message: normalized.message, context });
+      const unauthorized = config.isUnauthorized ?? ((value) => value.status === 401 && value.code === "AUTH_UNAUTHENTICATED");
+      try {
+        if (options.handleUnauthorized !== false && sentToken && config.onUnauthorized && failure.kind === "http" && failure.status >= 400 && unauthorized(failure)) {
+          if (config.getToken?.() !== sentToken || rejectedToken === sentToken) context.authHandled = true;
+          else {
+            rejectedToken = sentToken;
+            context.authHandled = true;
+            config.onUnauthorized(failure);
+          }
+        }
+      } catch (callbackError) {
+        report(callbackError, started, method, "callback");
+      }
+      report(failure, started, method);
+      if (context.feedbackOwner === "client") handleError(failure);
+      throw failure;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  const get = (path, options) => request(path, { ...options, method: "GET" }).then((value) => value.data);
+  const post = (path, body, options) => request(path, { ...options, method: "POST", body }).then((value) => value.data);
+  const put = (path, body, options) => request(path, { ...options, method: "PUT", body }).then((value) => value.data);
+  const patch = (path, body, options) => request(path, { ...options, method: "PATCH", body }).then((value) => value.data);
+  const remove = (path, options) => request(path, { ...options, method: "DELETE" }).then((value) => value.data);
+  return { request, get, post, put, patch, delete: remove, handleError };
+}
+export {
+  ApiError,
+  createHttpClient,
+  parseHttpError
+};

package/dist/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import type { RequestFailure } from "./types.js";
+export declare function toSafeDiagnostics(error: unknown, context?: Pick<RequestFailure, "method" | "origin" | "elapsedMs" | "stage">): RequestFailure;

package/dist/diagnostics.js

@@ -0,0 +1,9 @@
+import { ApiError, isRequestCancelled } from "./errors.js";
+function toSafeDiagnostics(error, context = {}) {
+  const safe = { method: context.method, origin: context.origin, elapsedMs: context.elapsedMs, stage: context.stage };
+  if (error instanceof ApiError) return { ...safe, kind: error.kind, status: error.status, code: error.code, requestId: error.requestId };
+  return { ...safe, kind: isRequestCancelled(error) ? "cancelled" : "unknown" };
+}
+export {
+  toSafeDiagnostics
+};

package/dist/error-handler.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorContext, HttpClientConfig } from "./types.js";
+export declare function createErrorHandler(config: Pick<HttpClientConfig, "notify" | "onBusinessError" | "onFailure">): (error: unknown, input?: Partial<ErrorContext>) => void;

package/dist/error-handler.js

@@ -0,0 +1,45 @@
+import { isRequestCancelled, ApiError, errorDefinitions } from "./errors.js";
+import { toSafeDiagnostics } from "./diagnostics.js";
+const handled = /* @__PURE__ */ new WeakSet();
+function createErrorHandler(config) {
+  function callback(run) {
+    try {
+      run();
+    } catch (error) {
+      try {
+        config.onFailure?.(toSafeDiagnostics(error, { stage: "callback" }));
+      } catch {
+      }
+    }
+  }
+  return function handleError(error, input = {}) {
+    if (isRequestCancelled(error) || error && typeof error === "object" && handled.has(error)) return;
+    const apiError = error instanceof ApiError ? error : new ApiError({ status: 0, code: "INTERNAL_ERROR", message: errorDefinitions.INTERNAL_ERROR, kind: "response" });
+    const method = apiError.context?.method;
+    const context = {
+      intent: input.intent ?? (method === "GET" || method === "HEAD" ? "read" : "mutation"),
+      trigger: input.trigger ?? "user",
+      feedback: input.feedback ?? apiError.context?.feedback ?? "auto"
+    };
+    if (apiError.context?.authHandled || context.feedback !== "auto" || context.trigger === "background" || context.intent === "read" && context.trigger === "initial") return;
+    let businessHandled = false;
+    callback(() => {
+      businessHandled = config.onBusinessError?.(apiError, context) === true;
+    });
+    if (businessHandled) {
+      if (error && typeof error === "object") handled.add(error);
+      return;
+    }
+    if (!config.notify) return;
+    if (error && typeof error === "object") handled.add(error);
+    const uncertain = context.intent === "mutation" && (apiError.kind === "network" || apiError.kind === "timeout");
+    callback(() => config.notify?.({
+      message: uncertain ? "暂时无法确认操作结果，请保留输入并检查结果后再重试。" : apiError.message,
+      requestId: apiError.requestId,
+      id: apiError.kind === "network" || apiError.kind === "timeout" ? "http-network" : void 0
+    }));
+  };
+}
+export {
+  createErrorHandler
+};

package/dist/errors.d.ts

@@ -0,0 +1,37 @@
+import type { FieldError, RequestContext } from "./types.js";
+export declare const errorDefinitions: {
+    readonly NETWORK_ERROR: "网络连接暂时不可用，请稍后重试。";
+    readonly REQUEST_TIMEOUT: "请求超时，请稍后重试。";
+    readonly RESPONSE_INVALID: "服务返回的数据格式异常。";
+    readonly RESPONSE_TOO_LARGE: "返回内容超过读取限制。";
+    readonly REQUEST_INVALID_INPUT: "请求配置无效。";
+    readonly AUTH_UNAUTHENTICATED: "登录状态已失效，请重新登录。";
+    readonly REQUEST_FORBIDDEN: "没有执行此操作的权限。";
+    readonly INTERNAL_ERROR: "服务暂时无法完成请求，请稍后重试。";
+    readonly HTTP_ERROR: "请求未能完成，请检查后重试。";
+};
+export type ApiErrorKind = "network" | "timeout" | "http" | "response" | "input";
+export type ApiErrorOptions<T = unknown> = {
+    status: number;
+    code: string;
+    message: string;
+    requestId?: string;
+    errors?: FieldError[];
+    details?: T;
+    kind?: ApiErrorKind;
+    retryAfterMs?: number;
+    context?: RequestContext;
+};
+export declare class ApiError<T = unknown> extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly requestId?: string;
+    readonly errors?: FieldError[];
+    readonly details?: T;
+    readonly kind: ApiErrorKind;
+    readonly retryAfterMs?: number;
+    readonly context?: RequestContext;
+    constructor(options: ApiErrorOptions<T>);
+}
+export declare function isRequestCancelled(error: unknown): boolean;
+export declare const isApiError: (error: unknown) => error is ApiError;

package/dist/errors.js

@@ -0,0 +1,45 @@
+const errorDefinitions = {
+  NETWORK_ERROR: "网络连接暂时不可用，请稍后重试。",
+  REQUEST_TIMEOUT: "请求超时，请稍后重试。",
+  RESPONSE_INVALID: "服务返回的数据格式异常。",
+  RESPONSE_TOO_LARGE: "返回内容超过读取限制。",
+  REQUEST_INVALID_INPUT: "请求配置无效。",
+  AUTH_UNAUTHENTICATED: "登录状态已失效，请重新登录。",
+  REQUEST_FORBIDDEN: "没有执行此操作的权限。",
+  INTERNAL_ERROR: "服务暂时无法完成请求，请稍后重试。",
+  HTTP_ERROR: "请求未能完成，请检查后重试。"
+};
+class ApiError extends Error {
+  status;
+  code;
+  requestId;
+  errors;
+  details;
+  kind;
+  retryAfterMs;
+  context;
+  constructor(options) {
+    super(options.message);
+    this.name = "ApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.requestId = options.requestId;
+    this.errors = options.errors;
+    this.details = options.details;
+    this.kind = options.kind ?? "http";
+    this.retryAfterMs = options.retryAfterMs;
+    this.context = options.context;
+  }
+}
+function isRequestCancelled(error) {
+  if (error instanceof ApiError) return false;
+  if (!error || typeof error !== "object") return false;
+  return "name" in error && error.name === "AbortError" || "code" in error && error.code === "ERR_CANCELED";
+}
+const isApiError = (error) => error instanceof ApiError;
+export {
+  ApiError,
+  errorDefinitions,
+  isApiError,
+  isRequestCancelled
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ApiError, errorDefinitions, isApiError, isRequestCancelled } from "./errors.js";
+export type { ApiErrorOptions, ApiErrorKind } from "./errors.js";
+export type { ApiSuccessResponse, HttpErrorResponse, FieldError, HttpResult, ErrorContext, RequestNotice, RequestFailure, HttpClientConfig, HttpRequestOptions, HttpMethod, ResponseMode } from "./types.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+import { ApiError, errorDefinitions, isApiError, isRequestCancelled } from "./errors.js";
+export {
+  ApiError,
+  errorDefinitions,
+  isApiError,
+  isRequestCancelled
+};

package/dist/query.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from "@tanstack/react-query";
+import { toSafeDiagnostics } from "./diagnostics.js";
+import type { ErrorContext, Feedback } from "./types.js";
+export type HttpQueryMeta = {
+    feedback?: Feedback;
+    successMessage?: string;
+};
+export type HttpQueryClientConfig = {
+    handleError: (error: unknown, context?: Partial<ErrorContext>) => void;
+    queries?: {
+        staleTime?: number;
+        maxRetries?: number;
+        retryDelay?: (attempt: number, error: unknown) => number;
+        refetchOnWindowFocus?: boolean;
+        refetchOnReconnect?: boolean;
+    };
+    notifySuccess?: (message: string) => void;
+    onMutationSuccess?: (meta: Readonly<Record<string, unknown>> | undefined) => void;
+    onFailure?: (failure: ReturnType<typeof toSafeDiagnostics>) => void;
+};
+export declare function shouldRetryRequest(failureCount: number, error: unknown, maxRetries?: number): boolean;
+export declare function requestRetryDelay(attempt: number, error: unknown): number;
+export declare function createHttpQueryClient(config: HttpQueryClientConfig): QueryClient;

package/dist/query.js

@@ -0,0 +1,68 @@
+import { QueryClient, MutationCache, QueryCache, isCancelledError } from "@tanstack/react-query";
+import { isRequestCancelled, ApiError } from "./errors.js";
+import { toSafeDiagnostics } from "./diagnostics.js";
+function shouldRetryRequest(failureCount, error, maxRetries = 2) {
+  if (failureCount >= maxRetries || !(error instanceof ApiError)) return false;
+  if (error.context?.method !== "GET" && error.context?.method !== "HEAD") return false;
+  return error.kind === "network" || error.kind === "timeout" || error.kind === "http" && [429, 502, 503, 504].includes(error.status);
+}
+function requestRetryDelay(attempt, error) {
+  const requested = error instanceof ApiError ? error.retryAfterMs : void 0;
+  return requested === void 0 ? Math.min(1e3 * 2 ** attempt, 3e4) : Math.min(Math.max(0, requested), 3e4);
+}
+function createHttpQueryClient(config) {
+  function callback(run) {
+    try {
+      run();
+    } catch (error) {
+      try {
+        config.onFailure?.(toSafeDiagnostics(error, { stage: "callback" }));
+      } catch {
+      }
+    }
+  }
+  const retries = config.queries?.maxRetries ?? 2;
+  if (!Number.isSafeInteger(retries) || retries < 0) throw new RangeError("maxRetries must be a non-negative integer");
+  const queryOptions = {
+    staleTime: config.queries?.staleTime ?? 1e4,
+    retry: (count, error) => shouldRetryRequest(count, error, retries),
+    retryDelay: (attempt, error) => {
+      let delay = requestRetryDelay(attempt, error);
+      callback(() => {
+        delay = config.queries?.retryDelay?.(attempt, error) ?? delay;
+      });
+      return Number.isFinite(delay) ? Math.max(0, Math.min(delay, 3e4)) : requestRetryDelay(attempt, error);
+    },
+    refetchOnWindowFocus: config.queries?.refetchOnWindowFocus ?? true,
+    refetchOnReconnect: config.queries?.refetchOnReconnect ?? true,
+    networkMode: "online"
+  };
+  return new QueryClient({
+    queryCache: new QueryCache({
+      onError: (error, query) => {
+        if (isCancelledError(error) || isRequestCancelled(error)) return;
+        const meta = query.meta;
+        callback(() => config.handleError(error, { intent: "read", trigger: query.state.data === void 0 ? "initial" : "background", ...meta?.feedback ? { feedback: meta.feedback } : {} }));
+      }
+    }),
+    mutationCache: new MutationCache({
+      onError: (error, _variables, _context, mutation) => {
+        if (isCancelledError(error) || isRequestCancelled(error)) return;
+        const meta = mutation.meta;
+        callback(() => config.handleError(error, { intent: "mutation", trigger: "user", ...meta?.feedback ? { feedback: meta.feedback } : {} }));
+      },
+      onSuccess: (_data, _variables, _context, mutation) => {
+        callback(() => config.onMutationSuccess?.(mutation.meta));
+        const meta = mutation.meta;
+        const message = meta?.successMessage;
+        if (message) callback(() => config.notifySuccess?.(message));
+      }
+    }),
+    defaultOptions: { queries: queryOptions, mutations: { retry: false, networkMode: "online" } }
+  });
+}
+export {
+  createHttpQueryClient,
+  requestRetryDelay,
+  shouldRetryRequest
+};

package/dist/response.d.ts

@@ -0,0 +1,7 @@
+import { ApiError } from "./errors.js";
+import type { HttpClientConfig, ResponseInfo, ResponseMode } from "./types.js";
+export declare function parseRetryAfter(value: string | undefined): number | undefined;
+export declare function parseHttpError(data: unknown, info: ResponseInfo): ApiError;
+export declare function readBody(body: ReadableStream<Uint8Array> | null, info: ResponseInfo, limit: number): Promise<Uint8Array[]>;
+export declare function decodeBody(chunks: Uint8Array[], mode: ResponseMode, info: ResponseInfo, config: HttpClientConfig): unknown;
+export declare function errorBody(chunks: Uint8Array[]): unknown;

package/dist/response.js

@@ -0,0 +1,97 @@
+import { ApiError, errorDefinitions } from "./errors.js";
+const record = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  const milliseconds = /^\d+(?:\.\d+)?$/.test(value) ? seconds * 1e3 : Date.parse(value) - Date.now();
+  return Number.isFinite(milliseconds) ? Math.max(0, Math.min(milliseconds, 3e4)) : void 0;
+}
+function parseHttpError(data, info) {
+  const body = record(data) ? data : {};
+  const valid = typeof body.code === "string" && /^[A-Z][A-Z0-9_]{0,127}$/.test(body.code) && typeof body.errMsg === "string";
+  const errors = Array.isArray(body.errors) ? body.errors.filter((item) => record(item) && typeof item.path === "string" && typeof item.errMsg === "string").slice(0, 100).map((item) => ({ path: item.path.slice(0, 256), errMsg: item.errMsg.slice(0, 2048) })) : void 0;
+  return new ApiError({
+    status: info.status,
+    code: valid ? body.code : info.status >= 500 ? "INTERNAL_ERROR" : "HTTP_ERROR",
+    message: valid ? body.errMsg.slice(0, 4096) : info.status >= 500 ? errorDefinitions.INTERNAL_ERROR : errorDefinitions.HTTP_ERROR,
+    requestId: typeof body.requestId === "string" ? body.requestId.slice(0, 256) : info.headers["x-request-id"],
+    errors: valid ? errors : void 0,
+    retryAfterMs: parseRetryAfter(info.headers["retry-after"])
+  });
+}
+async function readBody(body, info, limit) {
+  if (!body) return [];
+  const reader = body.getReader();
+  const chunks = [];
+  let bytes = 0;
+  try {
+    if (Number(info.headers["content-length"]) > limit) throw new ApiError({ status: info.status, code: "RESPONSE_TOO_LARGE", message: errorDefinitions.RESPONSE_TOO_LARGE, kind: "response", requestId: info.headers["x-request-id"] });
+    let chunk = await reader.read();
+    while (!chunk.done) {
+      const value = chunk.value;
+      bytes += value.byteLength;
+      if (bytes > limit) throw new ApiError({ status: info.status, code: "RESPONSE_TOO_LARGE", message: errorDefinitions.RESPONSE_TOO_LARGE, kind: "response", requestId: info.headers["x-request-id"] });
+      chunks.push(value);
+      chunk = await reader.read();
+    }
+    return chunks;
+  } catch (error) {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function decodeBody(chunks, mode, info, config) {
+  const bytes = bodyBytes(chunks);
+  let value;
+  if (mode === "blob") value = new Blob([bytes], { type: info.headers["content-type"] ?? "application/octet-stream" });
+  else {
+    const text = new TextDecoder().decode(bytes);
+    if (mode === "text") value = text;
+    else {
+      try {
+        value = text ? JSON.parse(text) : void 0;
+      } catch {
+        throw new ApiError({ status: info.status, code: "RESPONSE_INVALID", message: errorDefinitions.RESPONSE_INVALID, kind: "response", requestId: info.headers["x-request-id"] });
+      }
+    }
+  }
+  if (config.decodeResponse) {
+    try {
+      return config.decodeResponse(value, info);
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new ApiError({ status: info.status, code: "RESPONSE_INVALID", message: errorDefinitions.RESPONSE_INVALID, kind: "response", requestId: info.headers["x-request-id"] });
+    }
+  }
+  if (mode !== "envelope") return value;
+  if (record(value) && value.success === true && Object.hasOwn(value, "msg")) return value.msg;
+  throw new ApiError({ status: info.status, code: "RESPONSE_INVALID", message: errorDefinitions.RESPONSE_INVALID, kind: "response", requestId: info.headers["x-request-id"] });
+}
+function errorBody(chunks) {
+  try {
+    return JSON.parse(new TextDecoder().decode(bodyBytes(chunks)));
+  } catch {
+    return void 0;
+  }
+}
+function bodyBytes(chunks) {
+  const bytes = new Uint8Array(chunks.reduce((sum, value) => sum + value.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+export {
+  decodeBody,
+  errorBody,
+  parseHttpError,
+  parseRetryAfter,
+  readBody
+};

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+export { ok, fail, toErrorResponse } from "./response.js";
+export type { ServerResponseOptions, HttpFailureInput } from "./response.js";
+export { createServiceRequest, verifyServiceToken, SERVICE_TOKEN_HEADER } from "./service-auth.js";
+export { toSafeDiagnostics } from "../diagnostics.js";

package/dist/server/index.js

@@ -0,0 +1,12 @@
+import { fail, ok, toErrorResponse } from "./response.js";
+import { SERVICE_TOKEN_HEADER, createServiceRequest, verifyServiceToken } from "./service-auth.js";
+import { toSafeDiagnostics } from "../diagnostics.js";
+export {
+  SERVICE_TOKEN_HEADER,
+  createServiceRequest,
+  fail,
+  ok,
+  toErrorResponse,
+  toSafeDiagnostics,
+  verifyServiceToken
+};

package/dist/server/response.d.ts

@@ -0,0 +1,18 @@
+import type { FieldError } from "../types.js";
+export type ServerResponseOptions = {
+    status?: number;
+    headers?: NonNullable<RequestInit["headers"]>;
+    requestId?: string;
+};
+export type HttpFailureInput<T = unknown> = {
+    status: number;
+    code: string;
+    message: string;
+    requestId?: string;
+    errors?: FieldError[];
+    details?: T;
+    headers?: NonNullable<RequestInit["headers"]>;
+};
+export declare function ok<T>(data: T, options?: ServerResponseOptions): Response;
+export declare function fail<T>(input: HttpFailureInput<T>): Response;
+export declare function toErrorResponse(error: unknown, options?: Omit<ServerResponseOptions, "status">): Response;

package/dist/server/response.js

@@ -0,0 +1,31 @@
+import { ApiError, errorDefinitions } from "../errors.js";
+function responseHeaders(options) {
+  const requestId = options.requestId ?? crypto.randomUUID();
+  const headers = new Headers(options.headers);
+  headers.set("X-Request-ID", requestId);
+  return { headers, requestId };
+}
+function ok(data, options = {}) {
+  const status = options.status ?? 200;
+  if (![200, 201, 202].includes(status)) throw new RangeError("ok supports 200, 201 and 202");
+  const { headers } = responseHeaders(options);
+  const body = { success: true, msg: data, errMsg: "", code: "" };
+  return Response.json(body, { status, headers });
+}
+function fail(input) {
+  if (!Number.isInteger(input.status) || input.status < 400 || input.status > 599 || ["NETWORK_ERROR", "REQUEST_TIMEOUT", "RESPONSE_TOO_LARGE"].includes(input.code) || !/^[A-Z][A-Z0-9_]{0,127}$/.test(input.code)) throw new RangeError("Invalid HTTP failure contract");
+  const { headers, requestId } = responseHeaders(input);
+  const body = { code: input.code, errMsg: input.message, requestId, ...input.errors ? { errors: input.errors } : {}, ...input.details === void 0 ? {} : { details: input.details } };
+  return Response.json(body, { status: input.status, headers });
+}
+function toErrorResponse(error, options = {}) {
+  if (error instanceof ApiError && error.kind === "http" && Number.isInteger(error.status) && error.status >= 400 && error.status <= 599 && /^[A-Z][A-Z0-9_]{0,127}$/.test(error.code) && !["NETWORK_ERROR", "REQUEST_TIMEOUT", "RESPONSE_TOO_LARGE"].includes(error.code)) {
+    return fail({ status: error.status, code: error.code, message: error.message, errors: error.errors, details: error.details, requestId: options.requestId ?? error.requestId, headers: options.headers });
+  }
+  return fail({ status: 500, code: "INTERNAL_ERROR", message: errorDefinitions.INTERNAL_ERROR, ...options });
+}
+export {
+  fail,
+  ok,
+  toErrorResponse
+};

package/dist/server/service-auth.d.ts

@@ -0,0 +1,3 @@
+export declare const SERVICE_TOKEN_HEADER = "X-SpringBrand-Service-Token";
+export declare function createServiceRequest(baseUrl: string, token: string, path: string | URL, init?: RequestInit): Request;
+export declare function verifyServiceToken(provided: string | null | undefined, expected: string): Promise<boolean>;

package/dist/server/service-auth.js

@@ -0,0 +1,24 @@
+import { boundUrl, serviceUrl } from "../url.js";
+const SERVICE_TOKEN_HEADER = "X-SpringBrand-Service-Token";
+function createServiceRequest(baseUrl, token, path, init = {}) {
+  if (!token.trim()) throw new TypeError("Service token is required");
+  const url = boundUrl(serviceUrl(baseUrl), path);
+  const headers = new Headers(init.headers);
+  headers.delete("Authorization");
+  headers.delete("Cookie");
+  headers.set(SERVICE_TOKEN_HEADER, token);
+  return new Request(url, { ...init, headers, credentials: "omit", redirect: "error" });
+}
+async function verifyServiceToken(provided, expected) {
+  if (!provided || !expected) return false;
+  const encoder = new TextEncoder();
+  const [left, right] = await Promise.all([provided, expected].map((value) => crypto.subtle.digest("SHA-256", encoder.encode(value)).then((buffer) => new Uint8Array(buffer))));
+  let difference = 0;
+  for (let i = 0; i < left.length; i++) difference |= left[i] ^ right[i];
+  return difference === 0;
+}
+export {
+  SERVICE_TOKEN_HEADER,
+  createServiceRequest,
+  verifyServiceToken
+};

package/dist/types.d.ts

@@ -0,0 +1,98 @@
+import type { ApiError } from "./errors.js";
+export type HttpMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+export type ResponseMode = "envelope" | "json" | "text" | "blob";
+export type Feedback = "auto" | "inline" | "silent";
+export type FeedbackOwner = "client" | "query";
+export type FieldError = {
+    path: string;
+    errMsg: string;
+};
+export type ApiSuccessResponse<T> = {
+    success: true;
+    msg: T;
+    errMsg: "";
+    code: "";
+};
+export type HttpErrorResponse<T = unknown> = {
+    code: string;
+    errMsg: string;
+    requestId?: string;
+    errors?: FieldError[];
+    details?: T;
+};
+export type HttpResult<T> = {
+    data: T;
+    status: number;
+    headers: Readonly<Record<string, string>>;
+};
+export type ErrorContext = {
+    intent: "read" | "mutation";
+    trigger: "initial" | "background" | "user";
+    feedback: Feedback;
+};
+export type RequestContext = {
+    method: HttpMethod;
+    feedback: Feedback;
+    feedbackOwner: FeedbackOwner;
+    authHandled?: boolean;
+};
+export type RequestNotice = {
+    message: string;
+    requestId?: string;
+    id?: string;
+};
+export type RequestFailure = {
+    kind: string;
+    status?: number;
+    code?: string;
+    requestId?: string;
+    method?: HttpMethod;
+    origin?: string;
+    elapsedMs?: number;
+    stage?: "request" | "callback";
+};
+export type ResponseInfo = {
+    status: number;
+    headers: Readonly<Record<string, string>>;
+};
+export type QueryScalar = string | number | boolean | null | undefined;
+export type UploadProgress = {
+    loaded: number;
+    total?: number;
+    progress?: number;
+};
+export type HttpRequestOptions = {
+    method?: HttpMethod;
+    body?: unknown;
+    params?: Record<string, QueryScalar | readonly QueryScalar[]>;
+    headers?: NonNullable<RequestInit["headers"]>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    auth?: boolean;
+    handleUnauthorized?: boolean;
+    responseMode?: ResponseMode;
+    feedback?: Feedback;
+    feedbackOwner?: FeedbackOwner;
+    idempotencyKey?: string;
+    onUploadProgress?: (progress: UploadProgress) => void;
+};
+export type HttpClientConfig = {
+    baseUrl: string;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    credentials?: NonNullable<RequestInit["credentials"]>;
+    getToken?: () => string | null | undefined;
+    getHeaders?: () => NonNullable<RequestInit["headers"]>;
+    responseMode?: ResponseMode;
+    decodeResponse?: (data: unknown, info: ResponseInfo) => unknown;
+    decodeError?: (data: unknown, info: ResponseInfo) => ApiError;
+    isUnauthorized?: (error: ApiError) => boolean;
+    onUnauthorized?: (error: ApiError) => void;
+    notify?: (notice: RequestNotice) => void;
+    onBusinessError?: (error: ApiError, context: ErrorContext) => boolean;
+    feedbackOwner?: FeedbackOwner;
+    onFailure?: (failure: RequestFailure) => void;
+    /** 注入标准 Fetch，便于测试或适配宿主；请求仍由 Axios 执行。 */
+    fetch?: typeof globalThis.fetch;
+};

package/dist/url.d.ts

@@ -0,0 +1,2 @@
+export declare function serviceUrl(baseUrl: string): URL;
+export declare function boundUrl(base: URL, path: string | URL): URL;

package/dist/url.js

@@ -0,0 +1,31 @@
+import { ApiError, errorDefinitions } from "./errors.js";
+function invalidUrl() {
+  throw new ApiError({ status: 0, code: "REQUEST_INVALID_INPUT", message: errorDefinitions.REQUEST_INVALID_INPUT, kind: "input" });
+}
+function serviceUrl(baseUrl) {
+  try {
+    const origin = typeof window === "undefined" ? void 0 : window.location.origin;
+    if (/^https?:/i.test(baseUrl) && !/^https?:\/\//i.test(baseUrl)) return invalidUrl();
+    const url = new URL(baseUrl, origin);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) return invalidUrl();
+    return url;
+  } catch {
+    return invalidUrl();
+  }
+}
+function boundUrl(base, path) {
+  try {
+    const value = String(path);
+    const absolute = /^[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith("//");
+    if (/^https?:/i.test(value) && !/^https?:\/\//i.test(value)) return invalidUrl();
+    const url = absolute ? new URL(value, base) : new URL(`${base.pathname.replace(/\/$/, "")}/${value.replace(/^\/+/, "")}`, base.origin);
+    if (url.origin !== base.origin || url.username || url.password || url.hash) return invalidUrl();
+    return url;
+  } catch {
+    return invalidUrl();
+  }
+}
+export {
+  boundUrl,
+  serviceUrl
+};

package/package.json

@@ -1,6 +1,73 @@
 {
   "name": "@springbrand/http",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.0",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    ".agents",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js",
+      "default": "./dist/errors.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "default": "./dist/client.js"
+    },
+    "./query": {
+      "types": "./dist/query.d.ts",
+      "import": "./dist/query.js",
+      "default": "./dist/query.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "watch": "vite build --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests --ext ts --max-warnings 0",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "axios": "1.20.0"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.104.1"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "5.104.1",
+    "vitest": "3.2.6",
+    "typescript": "^5.0.2",
+    "vite": "^5.4.19",
+    "@types/node": "^20.8.3"
+  }
+}