@firtoz/hono-fetcher 2.5.0 → 2.7.0

package/README.md

@@ -4,7 +4,11 @@
 [![npm downloads](https://img.shields.io/npm/dm/%40firtoz%2Fhono-fetcher.svg)](https://www.npmjs.com/package/@firtoz/hono-fetcher)
 [![license](https://img.shields.io/npm/l/%40firtoz%2Fhono-fetcher.svg)](https://github.com/firtoz/fullstack-toolkit/blob/main/LICENSE)
 
-Type-safe Hono API client with full TypeScript inference for routes, params, and payloads.
+[![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Hono](https://img.shields.io/badge/Hono-E36002?logo=hono&logoColor=white)](https://hono.dev)
+[![Cloudflare Workers](https://img.shields.io/badge/Cloudflare-Workers-F38020?logo=cloudflare&logoColor=white)](https://developers.cloudflare.com/workers/)
+
+**Typed Hono fetcher for Workers and Durable Objects** — infer `AppType` routes, params, and JSON bodies end to end.
 
 > **⚠️ Early WIP Notice:** This package is in very early development and is **not production-ready**. It is TypeScript-only and may have breaking changes. While I (the maintainer) have limited time, I'm open to PRs for features, bug fixes, or additional support (like JS builds). Please feel free to try it out and contribute! See [CONTRIBUTING.md](../../CONTRIBUTING.md) for details.
 
@@ -131,14 +135,13 @@ export class ChatRoomDO extends DurableObject {
   }
 }
 
-// In your worker — use `using` so the RPC stub is disposed when the block exits
+// `using api` disposes the stub. Returning the DO `Response` directly is a common pass-through pattern;
+// if you consume the body in this worker instead, also dispose the RPC result (e.g. `using res`).
+// See https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
-    // From namespace + name (recommended)
     using api = honoDoFetcherWithName(env.CHAT_ROOM, 'room-1');
-    // Or from an existing stub: using api = honoDoFetcher(env.CHAT_ROOM.getByName('room-1'));
-    const response = await api.get({ url: '/messages' });
-    return response;
+    return api.get({ url: '/messages' });
   }
 };
 ```
@@ -372,23 +375,23 @@ const wsResp = await api.websocket({
 });
 ```
 
-### Integration with ZodWebSocketClient
+### Integration with StandardSchemaWebSocketClient
 
-For even better type safety, combine with `@firtoz/websocket-do`'s `ZodWebSocketClient`:
+For even better type safety, combine with `@firtoz/websocket-do`'s `StandardSchemaWebSocketClient`:
 
 ```typescript
-import { ZodWebSocketClient } from '@firtoz/websocket-do';
+import { StandardSchemaWebSocketClient } from '@firtoz/websocket-do';
 import { honoDoFetcherWithName } from '@firtoz/hono-fetcher';
 
 // 1. Connect to DO WebSocket
 const api = honoDoFetcherWithName(env.CHAT_ROOM, 'room-1');
 const wsResp = await api.websocket({
   url: '/websocket',
-  config: { autoAccept: false }, // Let ZodWebSocketClient handle acceptance
+  config: { autoAccept: false }, // Let StandardSchemaWebSocketClient handle acceptance
 });
 
 // 2. Wrap with type-safe client
-const client = new ZodWebSocketClient({
+const client = new StandardSchemaWebSocketClient({
   webSocket: wsResp.webSocket,
   clientSchema: ClientMessageSchema,
   serverSchema: ServerMessageSchema,
@@ -402,29 +405,33 @@ const client = new ZodWebSocketClient({
 wsResp.webSocket?.accept();
 
 // 4. Send type-safe messages
-client.send({ type: 'chat', text: 'Hello!' }); // Validated with Zod!
+await client.send({ type: 'chat', text: 'Hello!' }); // Validated with Standard Schema
 ```
 
-See the [ZodWebSocketClient documentation](#) for more details on type-safe WebSocket communication.
+See the `@firtoz/websocket-do` README for more details on type-safe WebSocket communication.
 
 ## Durable Objects API
 
-Each of `honoDoFetcher`, `honoDoFetcherWithName`, and `honoDoFetcherWithId` returns a fetcher that is also a **`Disposable`**: calling `api[Symbol.dispose]()` releases the underlying Durable Object stub. In production Workers, prefer the **`using`** declaration so disposal runs when the block exits (success or throw). See [Durable Object stubs and disposal](#durable-object-stubs-and-disposal) below.
+All of these return a fetcher that is also a **`Disposable`** for the **stub**: **`api[Symbol.dispose]()`** releases the Durable Object stub only.
+
+**RPC `Response` typing:** **`honoDoFetcherWithName`** / **`honoDoFetcherWithId`** (and **`honoDoFetcher`** when you pass a **full `DurableObjectStub`**) use **`TypedDoFetcher`**: HTTP results are **`RpcDisposableJsonResponse`** and **`websocket`** is **`Response & Disposable`**, so **`using res = await …`** type-checks when Workers RPC attaches disposers. If you pass only **`Pick<DurableObjectStub, "fetch">`** (minimal mock), the return type is **`TypedHonoFetcher<Hono>`** with **plain `JsonResponse` / `Response`**—**not** typed as **`Disposable`**, so we do not pretend mocks have RPC disposers. See [Durable Object stubs and disposal](#durable-object-stubs-and-disposal) and the [RPC lifecycle](https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/) doc.
 
 ### `honoDoFetcher<T>(stub)`
 
 Creates a typed fetcher for a Durable Object stub with support for both HTTP and WebSocket connections.
 
-**Returns:** `TypedDoFetcher<T> & Disposable`
+**Returns:** **`TypedDoFetcher<T> & Disposable`** when **`T`** is a **full `DurableObjectStub<DOWithHonoApp>`**; **`TypedHonoFetcher<Hono> & Disposable`** when **`T`** is only **`Pick<DurableObjectStub<DOWithHonoApp>, "fetch">`** (e.g. unit tests).
 
 ```typescript
 using api = honoDoFetcher(env.MY_DO.getByName('example'));
 
-// HTTP requests
-await api.get({ url: '/status' });
+// HTTP — dispose each RPC Response (stub disposal alone is not enough)
+using res = await api.get({ url: '/status' });
+const data = await res.json();
 
-// WebSocket connections
-const wsResp = await api.websocket({ url: '/ws' });
+// WebSocket
+using wsRes = await api.websocket({ url: '/ws' });
+wsRes.webSocket?.accept();
 ```
 
 ### `honoDoFetcherWithName<T>(namespace, name)`
@@ -436,11 +443,11 @@ Convenience method to create a fetcher from a namespace and name. Uses a single
 ```typescript
 using api = honoDoFetcherWithName(env.MY_DO, 'example');
 
-// HTTP
-await api.get({ url: '/status' });
+using res = await api.get({ url: '/status' });
+await res.json();
 
-// WebSocket
-await api.websocket({ url: '/chat' });
+using wsRes = await api.websocket({ url: '/chat' });
+wsRes.webSocket?.accept();
 ```
 
 ### `honoDoFetcherWithId<T>(namespace, id)`
@@ -451,15 +458,20 @@ Convenience method to create a fetcher from a namespace and hex ID string.
 
 ```typescript
 using api = honoDoFetcherWithId(env.MY_DO, 'abc123...');
-await api.get({ url: '/status' });
+using res = await api.get({ url: '/status' });
+await res.json();
 ```
 
 ### Durable Object stubs and disposal
 
-- **Production Workers:** Durable Object stubs participate in RPC and should be released when you are done. The easiest pattern is **`using api = honoDoFetcherWithName(...)`** (or `honoDoFetcher` / `honoDoFetcherWithId`). You can also call **`api[Symbol.dispose]()`** manually (for example in a `finally` block) if you cannot use `using`.
-- **Vite SSR, some Miniflare setups, or test mocks** may expose stubs that only implement **`fetch`** and not **`Symbol.dispose`**. The library checks for a callable `Symbol.dispose` before invoking it; if it is missing, disposal is a no-op (no `TypeError`).
+Cloudflare Workers RPC gives **separate disposers** for the **Durable Object stub** and for **non-primitive RPC results** such as the `Response` from `stub.fetch()`. Disposing only the stub can still produce *“An RPC stub was not disposed properly”* if the `Response` was not released. See the official **[Workers RPC lifecycle](https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/)** documentation.
+
+- **Stub (`using api = honoDoFetcherWithName(...)`):** Releases the **stub** when the block ends. This does **not** release RPC **`Response`** objects from individual requests.
+- **Response (HTTP / WebSocket upgrade):** On a **real stub** (`TypedDoFetcher`), TypeScript types those results as **`Disposable`** so **`using res`** / **`using wsRes`** is valid. At runtime, **`[Symbol.dispose]`** is present when Workers RPC attaches it (often in production); **minimal `fetch`-only mocks** are typed as **non-**`Disposable` **`Response`**s because disposers are usually absent. Prefer **`using res`** when types allow it; otherwise call **`res[Symbol.dispose]()`** or use a **`DisposableStack`** as described in Cloudflare’s **[Workers RPC lifecycle](https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/)** documentation. Reading the body does **not** implicitly dispose the RPC result in this library.
+- **Returning `Response` to the client:** **Do not** use **`using res`** on a response you **`return`** from your Worker—disposal can run on scope exit before the runtime finishes serving it. Return the value directly; see **[Workers RPC lifecycle](https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/)** for pass-through patterns.
+- **Vite SSR, some Miniflare setups, or test mocks** may expose stubs or **`Response`** objects without **`Symbol.dispose`**; there is nothing to call in that case.
 - **Errors from `Symbol.dispose`:** If the runtime’s dispose implementation throws (for example during unwind after your code threw), the library catches the error and logs it with **`console.error`**. It does **not** rethrow, so your original error is not masked by a `SuppressedError`.
-- **TypeScript `using`:** Add **`"ESNext.Disposable"`** to the `compilerOptions.lib` array in your **`tsconfig.json`** (alongside your existing libs) so `using` and `Disposable` type-check. TypeScript 5.2+ is required for `using`.
+- **TypeScript `using`:** Add **`"ESNext.Disposable"`** to the `compilerOptions.lib` array in your **`tsconfig.json`** (alongside your existing libs) so `using` and `Disposable` type-check. TypeScript 5.2+ is required for `using`. That applies to **`TypedDoFetcher`** (full **`DurableObjectStub`** path): **`RpcDisposableJsonResponse`** / **`Response & Disposable`** on **`websocket`**. **`Pick<stub, "fetch">`** clients get ordinary **`TypedHonoFetcher`** return types without **`Disposable`** on responses. Cloudflare’s runtime rules for RPC disposal are documented under **[Workers RPC lifecycle](https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/)**.
 
 ## Type Exports
 
@@ -486,6 +498,10 @@ const response: JsonResponse<{ id: string }> = await api.get({ url: '/user' });
 const data = await response.json(); // Type: { id: string }
 ```
 
+### `RpcDisposableJsonResponse<T>` / `BaseDisposableTypedHonoFetcher<T>` / `HonoDoFetcherStubInput`
+
+**`RpcDisposableJsonResponse<T>`** is **`JsonResponse<T> & Disposable`**. **`BaseDisposableTypedHonoFetcher<T>`** mirrors **`TypedHonoFetcher<T>`** but uses that for HTTP methods and **`Response & Disposable`** for **`websocket`**. **`TypedDoFetcher`** is **`BaseDisposableTypedHonoFetcher<Hono<…, DO schema>>`** — used only when **`honoDoFetcher`** is given a **full `DurableObjectStub`**, or when using **`honoDoFetcherWithName` / `honoDoFetcherWithId`**. **`HonoDoFetcherStubInput`** documents the **`DurableObjectStub | Pick<stub, "fetch">`** union for **`honoDoFetcher`**. Background: **[Workers RPC lifecycle](https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/)** (official disposal / `using` / `DisposableStack` guidance).
+
 ### `WebSocketConfig`
 
 Configuration options for WebSocket connections.
@@ -501,7 +517,7 @@ await api.websocket({ url: '/ws', config });
 ```
 
 **Options:**
-- `autoAccept?: boolean` - Whether to automatically call `accept()` on the WebSocket. Defaults to `true` for convenience. Set to `false` if you need manual control over when the WebSocket is accepted (e.g., when using with `ZodWebSocketClient`).
+- `autoAccept?: boolean` - Whether to automatically call `accept()` on the WebSocket. Defaults to `true` for convenience. Set to `false` if you need manual control over when the WebSocket is accepted (e.g., when using with `StandardSchemaWebSocketClient`).
 
 ### `ParsePathParams<T>`
 

package/dist/chunk-EXAM5VFZ.js

@@ -0,0 +1,43 @@
+import { honoFetcher } from './chunk-ULIZJ5OD.js';
+
+// src/honoDoFetcher.ts
+var DUMMY_URL = "http://dummy-url";
+function withStubDispose(stub, api) {
+  return Object.assign(api, {
+    [Symbol.dispose]() {
+      const disposeFn = Reflect.get(stub, Symbol.dispose);
+      if (typeof disposeFn !== "function") {
+        return;
+      }
+      try {
+        disposeFn.call(stub);
+      } catch (e) {
+        console.error(
+          "[@firtoz/hono-fetcher] Durable Object stub dispose failed",
+          e
+        );
+      }
+    }
+  });
+}
+var honoDoFetcher = (durableObject) => {
+  const api = honoFetcher((url, init) => {
+    return durableObject.fetch(`${DUMMY_URL}${url}`, init);
+  });
+  return withStubDispose(
+    durableObject,
+    api
+  );
+};
+var honoDoFetcherWithName = (namespace, name) => {
+  return honoDoFetcher(namespace.getByName(name));
+};
+var honoDoFetcherWithId = (namespace, id) => {
+  return honoDoFetcher(
+    namespace.get(namespace.idFromString(id))
+  );
+};
+
+export { honoDoFetcher, honoDoFetcherWithId, honoDoFetcherWithName };
+//# sourceMappingURL=chunk-EXAM5VFZ.js.map
+//# sourceMappingURL=chunk-EXAM5VFZ.js.map

package/dist/chunk-EXAM5VFZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/honoDoFetcher.ts"],"names":[],"mappings":";;;AAQA,IAAM,SAAA,GAAY,kBAAA;AAiDlB,SAAS,eAAA,CAIR,MAEA,GAAA,EAE+C;AAC/C,EAAA,OAAO,MAAA,CAAO,OAAO,GAAA,EAAK;AAAA,IACzB,CAAC,MAAA,CAAO,OAAO,CAAA,GAAI;AAElB,MAAA,MAAM,SAAA,GAAY,OAAA,CAAQ,GAAA,CAAI,IAAA,EAAM,OAAO,OAAO,CAAA;AAClD,MAAA,IAAI,OAAO,cAAc,UAAA,EAAY;AACpC,QAAA;AAAA,MACD;AACA,MAAA,IAAI;AACH,QAAA,SAAA,CAAU,KAAK,IAAI,CAAA;AAAA,MACpB,SAAS,CAAA,EAAG;AACX,QAAA,OAAA,CAAQ,KAAA;AAAA,UACP,2DAAA;AAAA,UACA;AAAA,SACD;AAAA,MACD;AAAA,IACD;AAAA,GACA,CAAA;AACF;AAkBO,IAAM,aAAA,GAAgB,CAC5B,aAAA,KAGyC;AAIzC,EAAA,MAAM,GAAA,GAAM,WAAA,CAAkC,CAAC,GAAA,EAAK,IAAA,KAAS;AAC5D,IAAA,OAAO,cAAc,KAAA,CAAM,CAAA,EAAG,SAAS,CAAA,EAAG,GAAG,IAAI,IAAI,CAAA;AAAA,EACtD,CAAC,CAAA;AACD,EAAA,OAAO,eAAA;AAAA,IACN,aAAA;AAAA,IACA;AAAA,GACD;AAGD;AAEO,IAAM,qBAAA,GAAwB,CAGpC,SAAA,EACA,IAAA,KACuD;AACvD,EAAA,OAAO,aAAA,CAAc,SAAA,CAAU,SAAA,CAAU,IAAI,CAAC,CAAA;AAI/C;AAEO,IAAM,mBAAA,GAAsB,CAGlC,SAAA,EACA,EAAA,KACuD;AACvD,EAAA,OAAO,aAAA;AAAA,IACN,SAAA,CAAU,GAAA,CAAI,SAAA,CAAU,YAAA,CAAa,EAAE,CAAC;AAAA,GACzC;AACD","file":"chunk-EXAM5VFZ.js","sourcesContent":["import type { Hono, Schema } from \"hono\";\nimport type { ExtractSchema } from \"hono/types\";\nimport {\n\thonoFetcher,\n\ttype BaseDisposableTypedHonoFetcher,\n\ttype TypedHonoFetcher,\n} from \"./honoFetcher\";\n\nconst DUMMY_URL = \"http://dummy-url\";\n\nexport type DOWithHonoApp<S extends Schema = Schema> =\n\tRpc.DurableObjectBranded & {\n\t\t// biome-ignore lint/suspicious/noExplicitAny: We need to be able to pass in any schema\n\t\tapp: Hono<any, S>;\n\t};\n\nexport type DOSchemaMap<T extends DOWithHonoApp> = T extends DOWithHonoApp\n\t? ExtractSchema<T[\"app\"]>\n\t: never;\n\nexport type DOSchemaKeys<T extends DOWithHonoApp> = string &\n\tkeyof DOSchemaMap<T>;\n\nexport type DOStubSchema<T extends DurableObjectStub> =\n\tT extends DurableObjectStub<infer S>\n\t\t? S extends DOWithHonoApp\n\t\t\t? ExtractSchema<S[\"app\"]>\n\t\t\t: never\n\t\t: never;\n\n/**\n * Fetcher for a **real** `DurableObjectStub`: HTTP results are {@link RpcDisposableJsonResponse}\n * and `websocket` returns `Response & Disposable`, matching Workers RPC when the runtime attaches\n * disposers. Use with {@link honoDoFetcher} / {@link honoDoFetcherWithName} / {@link honoDoFetcherWithId}\n * when `T` is a full stub—not with a minimal `Pick<stub, \"fetch\">` mock (that path uses plain\n * {@link TypedHonoFetcher} responses instead).\n *\n * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/\n */\nexport type TypedDoFetcher<T extends DurableObjectStub> =\n\tBaseDisposableTypedHonoFetcher<\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Generic parameter needs flexibility\n\t\tHono<any, DOStubSchema<T>>\n\t>;\n\n/**\n * Argument to {@link honoDoFetcher}: a **full** {@link DurableObjectStub} (production) or a minimal\n * **`{ fetch }`** mock. Only the full stub is typed as {@link TypedDoFetcher} with disposable RPC\n * responses; **`Pick<stub, \"fetch\">`** is typed as {@link TypedHonoFetcher} for `Hono` with ordinary\n * `JsonResponse` / `Response` (no `Disposable` on results—matches mocks without `Symbol.dispose`).\n *\n * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/\n */\nexport type HonoDoFetcherStubInput =\n\t| DurableObjectStub<DOWithHonoApp>\n\t| Pick<DurableObjectStub<DOWithHonoApp>, \"fetch\">;\n\nfunction withStubDispose<\n\tTStub extends Pick<DurableObjectStub<DOWithHonoApp>, \"fetch\">,\n\tTS extends Schema,\n>(\n\tstub: TStub,\n\t// biome-ignore lint/suspicious/noExplicitAny: Matches honoFetcher generic pattern for schema-driven apps\n\tapi: TypedHonoFetcher<Hono<any, TS>>,\n\t// biome-ignore lint/suspicious/noExplicitAny: Matches honoFetcher generic pattern for schema-driven apps\n): TypedHonoFetcher<Hono<any, TS>> & Disposable {\n\treturn Object.assign(api, {\n\t\t[Symbol.dispose]() {\n\t\t\t// Stubs may omit Symbol.dispose (e.g. Vite mocks); DurableObjectStub types may not list it.\n\t\t\tconst disposeFn = Reflect.get(stub, Symbol.dispose);\n\t\t\tif (typeof disposeFn !== \"function\") {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tdisposeFn.call(stub);\n\t\t\t} catch (e) {\n\t\t\t\tconsole.error(\n\t\t\t\t\t\"[@firtoz/hono-fetcher] Durable Object stub dispose failed\",\n\t\t\t\t\te,\n\t\t\t\t);\n\t\t\t}\n\t\t},\n\t});\n}\n\n/**\n * Typed fetcher for a Durable Object stub.\n *\n * - **Full `DurableObjectStub`:** return type is {@link TypedDoFetcher} **`& Disposable`** — each\n *   HTTP/WebSocket result is typed as disposable (`RpcDisposableJsonResponse` / `Response & Disposable`)\n *   so **`using res = await …`** type-checks when `\"ESNext.Disposable\"` is in `lib`, matching Workers RPC\n *   when the runtime attaches `[Symbol.dispose]` (see `@see` below).\n * - **`Pick<stub, \"fetch\">` only (e.g. tests):** return type is **`TypedHonoFetcher<Hono> & Disposable`**\n *   — same **`JsonResponse` / `Response`** shapes as {@link honoFetcher}; results are **not** typed as\n *   `Disposable` so typings are not faked for mocks that lack RPC disposers.\n *\n * Disposing only the fetcher (`using api = …`) releases the **stub**; RPC **`Response`** disposal\n * (when applicable) is separate — prefer **`using res`**, **`res[Symbol.dispose]()`**, or **`DisposableStack`**.\n *\n * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/\n */\nexport const honoDoFetcher = <const T extends HonoDoFetcherStubInput>(\n\tdurableObject: T,\n): T extends DurableObjectStub<DOWithHonoApp>\n\t? TypedDoFetcher<T> & Disposable\n\t: TypedHonoFetcher<Hono> & Disposable => {\n\ttype OutSchema =\n\t\tT extends DurableObjectStub<DOWithHonoApp> ? DOStubSchema<T> : Schema;\n\t// biome-ignore lint/suspicious/noExplicitAny: Generic parameter needs flexibility\n\tconst api = honoFetcher<Hono<any, OutSchema>>((url, init) => {\n\t\treturn durableObject.fetch(`${DUMMY_URL}${url}`, init);\n\t});\n\treturn withStubDispose(\n\t\tdurableObject,\n\t\tapi,\n\t) as T extends DurableObjectStub<DOWithHonoApp>\n\t\t? TypedDoFetcher<T> & Disposable\n\t\t: TypedHonoFetcher<Hono> & Disposable;\n};\n\nexport const honoDoFetcherWithName = <\n\tconst T extends Rpc.DurableObjectBranded & DOWithHonoApp,\n>(\n\tnamespace: DurableObjectNamespace<T>,\n\tname: string,\n): TypedDoFetcher<DurableObjectStub<T>> & Disposable => {\n\treturn honoDoFetcher(namespace.getByName(name)) as TypedDoFetcher<\n\t\tDurableObjectStub<T>\n\t> &\n\t\tDisposable;\n};\n\nexport const honoDoFetcherWithId = <\n\tconst T extends Rpc.DurableObjectBranded & DOWithHonoApp,\n>(\n\tnamespace: DurableObjectNamespace<T>,\n\tid: string,\n): TypedDoFetcher<DurableObjectStub<T>> & Disposable => {\n\treturn honoDoFetcher(\n\t\tnamespace.get(namespace.idFromString(id)),\n\t) as TypedDoFetcher<DurableObjectStub<T>> & Disposable;\n};\n"]}

package/dist/chunk-ULIZJ5OD.js

@@ -0,0 +1,112 @@
+// src/honoFetcher.ts
+function appendQueryString(url, query) {
+  if (!query) {
+    return url;
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    searchParams.append(key, String(value));
+  }
+  const serialized = searchParams.toString();
+  if (!serialized) {
+    return url;
+  }
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}${serialized}`;
+}
+function restOfRequestInit(init) {
+  const { headers: _h, body: _b, method: _m, ...rest } = init;
+  return rest;
+}
+var createMethodFetcher = (fetcher, method) => {
+  return (async (request) => {
+    let finalUrl = request.url;
+    const { init = {}, params, query } = request;
+    if (params && typeof params === "object") {
+      finalUrl = Object.entries(params).reduce((acc, [key, value]) => {
+        return acc.replace(`:${key}`, value);
+      }, finalUrl);
+    }
+    finalUrl = appendQueryString(finalUrl, query);
+    const requestAsOptionalFormBody = request;
+    let body;
+    if (requestAsOptionalFormBody.form) {
+      const formData = new FormData();
+      for (const [key, value] of Object.entries(
+        requestAsOptionalFormBody.form
+      )) {
+        formData.append(key, value);
+      }
+      body = formData;
+    } else if (requestAsOptionalFormBody.body) {
+      body = JSON.stringify(requestAsOptionalFormBody.body);
+    }
+    const newHeaders = new Headers(
+      init.headers
+    );
+    if (body && !requestAsOptionalFormBody.form) {
+      newHeaders.set("Content-Type", "application/json");
+    }
+    try {
+      return await fetcher(finalUrl, {
+        ...restOfRequestInit(init),
+        method: method.toUpperCase(),
+        headers: newHeaders,
+        ...body ? { body } : {}
+      });
+    } catch (error) {
+      console.error(`Error ${method}ing`, error);
+      throw new Error(`Failed to ${method} ${finalUrl}: ${error}`);
+    }
+  });
+};
+var createWebSocketFetcher = (fetcher) => {
+  return (async (request) => {
+    let finalUrl = request.url;
+    const { init = {}, params, query, config } = request;
+    const autoAccept = config?.autoAccept ?? true;
+    if (params && typeof params === "object") {
+      finalUrl = Object.entries(params).reduce((acc, [key, value]) => {
+        return acc.replace(`:${key}`, value);
+      }, finalUrl);
+    }
+    finalUrl = appendQueryString(finalUrl, query);
+    const newHeaders = new Headers(
+      init.headers
+    );
+    newHeaders.set("Upgrade", "websocket");
+    try {
+      const response = await fetcher(finalUrl, {
+        ...restOfRequestInit(init),
+        method: "GET",
+        headers: newHeaders
+      });
+      if (autoAccept && response.webSocket) {
+        response.webSocket.accept();
+      }
+      return response;
+    } catch (error) {
+      console.error("Error upgrading to WebSocket", error);
+      throw new Error(`Failed to upgrade WebSocket at ${finalUrl}: ${error}`);
+    }
+  });
+};
+var honoFetcher = (fetcher) => {
+  const methods = ["get", "post", "put", "delete", "patch"];
+  const result = methods.reduce(
+    (acc, method) => {
+      acc[method] = createMethodFetcher(fetcher, method);
+      return acc;
+    },
+    {}
+  );
+  result.websocket = createWebSocketFetcher(fetcher);
+  return result;
+};
+
+export { honoFetcher };
+//# sourceMappingURL=chunk-ULIZJ5OD.js.map
+//# sourceMappingURL=chunk-ULIZJ5OD.js.map

package/dist/chunk-ULIZJ5OD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/honoFetcher.ts"],"names":[],"mappings":"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","file":"chunk-ULIZJ5OD.js","sourcesContent":["import type { Hono } from \"hono\";\nimport type { ExtractSchema } from \"hono/types\";\n\nexport type ParsePathParams<T extends string> =\n\tT extends `${infer _Start}/:${infer Param}/${infer Rest}`\n\t\t? { [K in Param | keyof ParsePathParams<`/${Rest}`>]: string }\n\t\t: T extends `${infer _Start}/:${infer Param}`\n\t\t\t? { [K in Param]: string }\n\t\t\t: never;\n\nexport type HttpMethod = \"get\" | \"post\" | \"put\" | \"delete\" | \"patch\";\n\nexport type HonoSchemaKeys<T extends Hono> = string & keyof ExtractSchema<T>;\n\ntype FilterKeysByMethod<\n\tTApp extends ExtractSchema<unknown>,\n\tTMethod extends HttpMethod,\n> = {\n\t[K in keyof TApp as TApp[K] extends { [key in `$${TMethod}`]: unknown }\n\t\t? K\n\t\t: never]: TApp[K];\n};\n\ntype HonoSchema<TApp extends Hono> = {\n\t[M in HttpMethod]: FilterKeysByMethod<ExtractSchema<TApp>, M>;\n};\n\nexport type JsonResponse<T> = Omit<Response, \"json\"> & {\n\tjson: () => Promise<T>;\n};\n\n/**\n * {@link JsonResponse} intersected with `Disposable` for Workers RPC: `Response`\n * values from `DurableObjectStub#fetch()` may implement `[Symbol.dispose]` even\n * though `Fetcher.fetch` is still typed as `Promise<Response>`. Use with\n * {@link BaseDisposableTypedHonoFetcher} (and `TypedDoFetcher` from `./honoDoFetcher`) so\n * `using resp = await api.get(...)` type-checks when `\"ESNext.Disposable\"` is in `lib`.\n *\n * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/\n */\nexport type RpcDisposableJsonResponse<T> = JsonResponse<T> & Disposable;\n\ntype HasPathParams<T extends string> = T extends `${string}:${string}`\n\t? true\n\t: false;\n\n/**\n * Values allowed in the optional `query` object on fetcher requests.\n * `null` and `undefined` entries are omitted from the serialized query string.\n */\nexport type HonoFetcherQueryParamValue = string | number | boolean;\n\nexport type HonoFetcherQueryParams = Record<\n\tstring,\n\tHonoFetcherQueryParamValue | null | undefined\n>;\n\nfunction appendQueryString(\n\turl: string,\n\tquery?: HonoFetcherQueryParams,\n): string {\n\tif (!query) {\n\t\treturn url;\n\t}\n\tconst searchParams = new URLSearchParams();\n\tfor (const [key, value] of Object.entries(query)) {\n\t\tif (value === undefined || value === null) {\n\t\t\tcontinue;\n\t\t}\n\t\tsearchParams.append(key, String(value));\n\t}\n\tconst serialized = searchParams.toString();\n\tif (!serialized) {\n\t\treturn url;\n\t}\n\tconst separator = url.includes(\"?\") ? \"&\" : \"?\";\n\treturn `${url}${separator}${serialized}`;\n}\n\n/**\n * `RequestInit` fields that honoFetcher sets must not be overwritten by spreading `...init` last.\n */\nfunction restOfRequestInit(\n\tinit: RequestInit,\n): Omit<RequestInit, \"headers\" | \"body\" | \"method\"> {\n\tconst { headers: _h, body: _b, method: _m, ...rest } = init;\n\treturn rest;\n}\n\ntype FetcherParams<SchemaPath extends string> =\n\tHasPathParams<SchemaPath> extends true\n\t\t? {\n\t\t\t\tparams: ParsePathParams<SchemaPath>;\n\t\t\t\tquery?: HonoFetcherQueryParams;\n\t\t\t\tinit?: RequestInit;\n\t\t\t}\n\t\t: {\n\t\t\t\tparams?: never;\n\t\t\t\tquery?: HonoFetcherQueryParams;\n\t\t\t\tinit?: RequestInit;\n\t\t\t};\n\n// biome-ignore lint/complexity/noBannedTypes: We need an empty object to remove the body and form keys from the request object\ntype EmptyObject = {};\n\ntype TypedMethodFetcher<T extends Hono, M extends HttpMethod> = <\n\tSchemaPath extends string & keyof HonoSchema<T>[M],\n>(\n\trequest: {\n\t\turl: SchemaPath;\n\t} & FetcherParams<SchemaPath> &\n\t\t(M extends \"get\" | \"delete\" ? EmptyObject : BodyParams<T, M, SchemaPath>),\n) => Promise<SchemaOutput<T, M, SchemaPath>>;\n\ntype SchemaOutput<\n\tT extends Hono,\n\tM extends HttpMethod,\n\tSchemaPath extends string & keyof HonoSchema<T>[M],\n\tDollarM extends `$${M}` & keyof HonoSchema<T>[M][SchemaPath] = `$${M}` &\n\t\tkeyof HonoSchema<T>[M][SchemaPath],\n> = \"output\" extends keyof HonoSchema<T>[M][SchemaPath][DollarM]\n\t? JsonResponse<HonoSchema<T>[M][SchemaPath][DollarM][\"output\"]>\n\t: never;\n\ntype DoSchemaOutput<\n\tT extends Hono,\n\tM extends HttpMethod,\n\tSchemaPath extends string & keyof HonoSchema<T>[M],\n\tDollarM extends `$${M}` & keyof HonoSchema<T>[M][SchemaPath] = `$${M}` &\n\t\tkeyof HonoSchema<T>[M][SchemaPath],\n> = \"output\" extends keyof HonoSchema<T>[M][SchemaPath][DollarM]\n\t? RpcDisposableJsonResponse<HonoSchema<T>[M][SchemaPath][DollarM][\"output\"]>\n\t: never;\n\ntype BodyParams<\n\tTApp extends Hono,\n\tTMethod extends HttpMethod,\n\tSchemaPath extends string & keyof HonoSchema<TApp>[TMethod],\n\tDollarMethod extends `$${TMethod}` &\n\t\tkeyof HonoSchema<TApp>[TMethod][SchemaPath] = `$${TMethod}` &\n\t\tkeyof HonoSchema<TApp>[TMethod][SchemaPath],\n> = \"input\" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]\n\t? \"json\" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"]\n\t\t? \"form\" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"]\n\t\t\t?\n\t\t\t\t\t| {\n\t\t\t\t\t\t\tbody: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"][\"json\"];\n\t\t\t\t\t  }\n\t\t\t\t\t| {\n\t\t\t\t\t\t\tform: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"][\"form\"];\n\t\t\t\t\t  }\n\t\t\t: {\n\t\t\t\t\tbody: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"][\"json\"];\n\t\t\t\t}\n\t\t: \"form\" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"]\n\t\t\t? {\n\t\t\t\t\tform: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod][\"input\"][\"form\"];\n\t\t\t\t}\n\t\t\t: { body?: unknown } | { form?: unknown }\n\t: EmptyObject;\n\ntype AvailableMethods<T extends Hono> = {\n\t[M in HttpMethod]: keyof HonoSchema<T>[M] extends never ? never : M;\n}[HttpMethod];\n\nexport interface WebSocketConfig {\n\t/**\n\t * Whether to automatically call accept() on the WebSocket before returning.\n\t * Defaults to true for convenience.\n\t *\n\t * In Cloudflare Workers, you must call accept() before using a WebSocket.\n\t * Setting this to false allows you to call accept() manually if needed.\n\t *\n\t * @default true\n\t */\n\tautoAccept?: boolean;\n}\n\nexport type TypedWebSocketFetcher<T extends Hono> = <\n\tSchemaPath extends string & keyof HonoSchema<T>[\"get\"],\n>(\n\trequest: {\n\t\turl: SchemaPath;\n\t\tconfig?: WebSocketConfig;\n\t} & FetcherParams<SchemaPath>,\n) => Promise<Response>;\n\nexport type BaseTypedHonoFetcher<T extends Hono> = {\n\t[M in AvailableMethods<T>]: TypedMethodFetcher<T, M>;\n} & (keyof HonoSchema<T>[\"get\"] extends never\n\t? // biome-ignore lint/complexity/noBannedTypes: We really do want an empty object if the get method is not available\n\t\t{}\n\t: { websocket: TypedWebSocketFetcher<T> });\n\ntype TypedDisposableMethodFetcher<T extends Hono, M extends HttpMethod> = <\n\tSchemaPath extends string & keyof HonoSchema<T>[M],\n>(\n\trequest: {\n\t\turl: SchemaPath;\n\t} & FetcherParams<SchemaPath> &\n\t\t(M extends \"get\" | \"delete\" ? EmptyObject : BodyParams<T, M, SchemaPath>),\n) => Promise<DoSchemaOutput<T, M, SchemaPath>>;\n\nexport type TypedDisposableWebSocketFetcher<T extends Hono> = <\n\tSchemaPath extends string & keyof HonoSchema<T>[\"get\"],\n>(\n\trequest: {\n\t\turl: SchemaPath;\n\t\tconfig?: WebSocketConfig;\n\t} & FetcherParams<SchemaPath>,\n) => Promise<Response & Disposable>;\n\n/**\n * Same shape as {@link BaseTypedHonoFetcher} but HTTP methods return\n * {@link RpcDisposableJsonResponse} and `websocket` returns `Response & Disposable`\n * so `using` on RPC results type-checks for Durable Object clients.\n *\n * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/\n */\nexport type BaseDisposableTypedHonoFetcher<T extends Hono> = {\n\t[M in AvailableMethods<T>]: TypedDisposableMethodFetcher<T, M>;\n} & (keyof HonoSchema<T>[\"get\"] extends never\n\t? // biome-ignore lint/complexity/noBannedTypes: We really do want an empty object if the get method is not available\n\t\t{}\n\t: { websocket: TypedDisposableWebSocketFetcher<T> });\n\nconst createMethodFetcher = <T extends Hono, M extends HttpMethod>(\n\tfetcher: (\n\t\trequest: string,\n\t\tinit?: RequestInit,\n\t) => ReturnType<T[\"request\"]> | Promise<ReturnType<T[\"request\"]>>,\n\tmethod: M,\n): TypedMethodFetcher<T, M> => {\n\treturn (async (request) => {\n\t\tlet finalUrl: string = request.url;\n\n\t\tconst { init = {}, params, query } = request;\n\n\t\tif (params && typeof params === \"object\") {\n\t\t\tfinalUrl = Object.entries(params).reduce((acc, [key, value]) => {\n\t\t\t\treturn acc.replace(`:${key}`, value as string);\n\t\t\t}, finalUrl);\n\t\t}\n\n\t\tfinalUrl = appendQueryString(finalUrl, query);\n\n\t\tconst requestAsOptionalFormBody = request as {\n\t\t\tform?: unknown;\n\t\t\tbody?: unknown;\n\t\t};\n\n\t\tlet body: BodyInit | undefined;\n\t\tif (requestAsOptionalFormBody.form) {\n\t\t\tconst formData = new FormData();\n\t\t\tfor (const [key, value] of Object.entries(\n\t\t\t\trequestAsOptionalFormBody.form,\n\t\t\t)) {\n\t\t\t\tformData.append(key, value as string);\n\t\t\t}\n\t\t\tbody = formData;\n\t\t} else if (requestAsOptionalFormBody.body) {\n\t\t\tbody = JSON.stringify(requestAsOptionalFormBody.body) as BodyInit;\n\t\t}\n\n\t\tconst newHeaders = new Headers(\n\t\t\tinit.headers as unknown as ConstructorParameters<typeof Headers>[0],\n\t\t);\n\n\t\tif (body && !requestAsOptionalFormBody.form) {\n\t\t\tnewHeaders.set(\"Content-Type\", \"application/json\");\n\t\t}\n\n\t\ttry {\n\t\t\treturn await fetcher(finalUrl, {\n\t\t\t\t...restOfRequestInit(init),\n\t\t\t\tmethod: method.toUpperCase(),\n\t\t\t\theaders: newHeaders,\n\t\t\t\t...(body ? { body } : {}),\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tconsole.error(`Error ${method}ing`, error);\n\t\t\tthrow new Error(`Failed to ${method} ${finalUrl}: ${error}`);\n\t\t}\n\t}) as TypedMethodFetcher<T, M>;\n};\n\nconst createWebSocketFetcher = <T extends Hono>(\n\tfetcher: (\n\t\trequest: string,\n\t\tinit?: RequestInit,\n\t) => ReturnType<T[\"request\"]> | Promise<ReturnType<T[\"request\"]>>,\n): TypedWebSocketFetcher<T> => {\n\treturn (async (request) => {\n\t\tlet finalUrl: string = request.url;\n\n\t\tconst { init = {}, params, query, config } = request;\n\t\tconst autoAccept = config?.autoAccept ?? true; // Default to true\n\n\t\tif (params && typeof params === \"object\") {\n\t\t\tfinalUrl = Object.entries(params).reduce((acc, [key, value]) => {\n\t\t\t\treturn acc.replace(`:${key}`, value as string);\n\t\t\t}, finalUrl);\n\t\t}\n\n\t\tfinalUrl = appendQueryString(finalUrl, query);\n\n\t\tconst newHeaders = new Headers(\n\t\t\tinit.headers as unknown as ConstructorParameters<typeof Headers>[0],\n\t\t);\n\t\tnewHeaders.set(\"Upgrade\", \"websocket\");\n\n\t\ttry {\n\t\t\tconst response = await fetcher(finalUrl, {\n\t\t\t\t...restOfRequestInit(init),\n\t\t\t\tmethod: \"GET\",\n\t\t\t\theaders: newHeaders,\n\t\t\t});\n\n\t\t\t// Auto-accept the WebSocket if configured (default: true)\n\t\t\tif (autoAccept && response.webSocket) {\n\t\t\t\tresponse.webSocket.accept();\n\t\t\t}\n\n\t\t\treturn response;\n\t\t} catch (error) {\n\t\t\tconsole.error(\"Error upgrading to WebSocket\", error);\n\t\t\tthrow new Error(`Failed to upgrade WebSocket at ${finalUrl}: ${error}`);\n\t\t}\n\t}) as TypedWebSocketFetcher<T>;\n};\n\nexport type TypedHonoFetcher<T extends Hono> = BaseTypedHonoFetcher<T>;\n\nexport const honoFetcher = <T extends Hono>(\n\tfetcher: (\n\t\trequest: string,\n\t\tinit?: RequestInit,\n\t) => ReturnType<T[\"request\"]> | Promise<ReturnType<T[\"request\"]>>,\n): TypedHonoFetcher<T> => {\n\tconst methods = [\"get\", \"post\", \"put\", \"delete\", \"patch\"] as const;\n\n\tconst result = methods.reduce(\n\t\t(acc, method) => {\n\t\t\t(\n\t\t\t\tacc as TypedHonoFetcher<T> & {\n\t\t\t\t\t[M in typeof method]: TypedMethodFetcher<T, M>;\n\t\t\t\t}\n\t\t\t)[method] = createMethodFetcher(fetcher, method) as TypedMethodFetcher<\n\t\t\t\tT,\n\t\t\t\ttypeof method\n\t\t\t>;\n\t\t\treturn acc;\n\t\t},\n\t\t{} as TypedHonoFetcher<T>,\n\t);\n\n\t// Add websocket method\n\t(\n\t\tresult as TypedHonoFetcher<T> & { websocket?: TypedWebSocketFetcher<T> }\n\t).websocket = createWebSocketFetcher(fetcher);\n\n\treturn result;\n};\n"]}

package/dist/chunk-YCTPXFUH.js

@@ -0,0 +1,12 @@
+import { honoFetcher } from './chunk-ULIZJ5OD.js';
+
+// src/honoDirectFetcher.ts
+var honoDirectFetcher = (baseUrl) => {
+  return honoFetcher((request, init) => {
+    return fetch(`${baseUrl}${request}`, init);
+  });
+};
+
+export { honoDirectFetcher };
+//# sourceMappingURL=chunk-YCTPXFUH.js.map
+//# sourceMappingURL=chunk-YCTPXFUH.js.map

package/dist/chunk-YCTPXFUH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/honoDirectFetcher.ts"],"names":[],"mappings":";;;AAGO,IAAM,iBAAA,GAAoB,CAChC,OAAA,KACyB;AACzB,EAAA,OAAO,WAAA,CAAe,CAAC,OAAA,EAAS,IAAA,KAAS;AACxC,IAAA,OAAO,MAAM,CAAA,EAAG,OAAO,CAAA,EAAG,OAAO,IAAI,IAAI,CAAA;AAAA,EAC1C,CAAC,CAAA;AACF","file":"chunk-YCTPXFUH.js","sourcesContent":["import type { Hono } from \"hono\";\nimport { honoFetcher, type TypedHonoFetcher } from \"./honoFetcher\";\n\nexport const honoDirectFetcher = <T extends Hono>(\n\tbaseUrl: string,\n): TypedHonoFetcher<T> => {\n\treturn honoFetcher<T>((request, init) => {\n\t\treturn fetch(`${baseUrl}${request}`, init) as ReturnType<T[\"request\"]>;\n\t});\n};\n"]}

package/dist/honoDirectFetcher.d.ts

@@ -0,0 +1,7 @@
+import { Hono } from 'hono';
+import { TypedHonoFetcher } from './honoFetcher.js';
+import 'hono/types';
+
+declare const honoDirectFetcher: <T extends Hono>(baseUrl: string) => TypedHonoFetcher<T>;
+
+export { honoDirectFetcher };

package/dist/honoDirectFetcher.js

@@ -0,0 +1,4 @@
+export { honoDirectFetcher } from './chunk-YCTPXFUH.js';
+import './chunk-ULIZJ5OD.js';
+//# sourceMappingURL=honoDirectFetcher.js.map
+//# sourceMappingURL=honoDirectFetcher.js.map

package/dist/honoDirectFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"honoDirectFetcher.js"}

package/dist/honoDoFetcher.d.ts

@@ -0,0 +1,50 @@
+import { Schema, Hono } from 'hono';
+import { ExtractSchema } from 'hono/types';
+import { BaseDisposableTypedHonoFetcher, TypedHonoFetcher } from './honoFetcher.js';
+
+type DOWithHonoApp<S extends Schema = Schema> = Rpc.DurableObjectBranded & {
+    app: Hono<any, S>;
+};
+type DOSchemaMap<T extends DOWithHonoApp> = T extends DOWithHonoApp ? ExtractSchema<T["app"]> : never;
+type DOSchemaKeys<T extends DOWithHonoApp> = string & keyof DOSchemaMap<T>;
+type DOStubSchema<T extends DurableObjectStub> = T extends DurableObjectStub<infer S> ? S extends DOWithHonoApp ? ExtractSchema<S["app"]> : never : never;
+/**
+ * Fetcher for a **real** `DurableObjectStub`: HTTP results are {@link RpcDisposableJsonResponse}
+ * and `websocket` returns `Response & Disposable`, matching Workers RPC when the runtime attaches
+ * disposers. Use with {@link honoDoFetcher} / {@link honoDoFetcherWithName} / {@link honoDoFetcherWithId}
+ * when `T` is a full stub—not with a minimal `Pick<stub, "fetch">` mock (that path uses plain
+ * {@link TypedHonoFetcher} responses instead).
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+type TypedDoFetcher<T extends DurableObjectStub> = BaseDisposableTypedHonoFetcher<Hono<any, DOStubSchema<T>>>;
+/**
+ * Argument to {@link honoDoFetcher}: a **full** {@link DurableObjectStub} (production) or a minimal
+ * **`{ fetch }`** mock. Only the full stub is typed as {@link TypedDoFetcher} with disposable RPC
+ * responses; **`Pick<stub, "fetch">`** is typed as {@link TypedHonoFetcher} for `Hono` with ordinary
+ * `JsonResponse` / `Response` (no `Disposable` on results—matches mocks without `Symbol.dispose`).
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+type HonoDoFetcherStubInput = DurableObjectStub<DOWithHonoApp> | Pick<DurableObjectStub<DOWithHonoApp>, "fetch">;
+/**
+ * Typed fetcher for a Durable Object stub.
+ *
+ * - **Full `DurableObjectStub`:** return type is {@link TypedDoFetcher} **`& Disposable`** — each
+ *   HTTP/WebSocket result is typed as disposable (`RpcDisposableJsonResponse` / `Response & Disposable`)
+ *   so **`using res = await …`** type-checks when `"ESNext.Disposable"` is in `lib`, matching Workers RPC
+ *   when the runtime attaches `[Symbol.dispose]` (see `@see` below).
+ * - **`Pick<stub, "fetch">` only (e.g. tests):** return type is **`TypedHonoFetcher<Hono> & Disposable`**
+ *   — same **`JsonResponse` / `Response`** shapes as {@link honoFetcher}; results are **not** typed as
+ *   `Disposable` so typings are not faked for mocks that lack RPC disposers.
+ *
+ * Disposing only the fetcher (`using api = …`) releases the **stub**; RPC **`Response`** disposal
+ * (when applicable) is separate — prefer **`using res`**, **`res[Symbol.dispose]()`**, or **`DisposableStack`**.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+declare const honoDoFetcher: <const T extends HonoDoFetcherStubInput>(durableObject: T) => T extends DurableObjectStub<DOWithHonoApp> ? TypedDoFetcher<T> & Disposable : TypedHonoFetcher<Hono> & Disposable;
+declare const honoDoFetcherWithName: <const T extends Rpc.DurableObjectBranded & DOWithHonoApp>(namespace: DurableObjectNamespace<T>, name: string) => TypedDoFetcher<DurableObjectStub<T>> & Disposable;
+declare const honoDoFetcherWithId: <const T extends Rpc.DurableObjectBranded & DOWithHonoApp>(namespace: DurableObjectNamespace<T>, id: string) => TypedDoFetcher<DurableObjectStub<T>> & Disposable;
+
+export { type DOSchemaKeys, type DOSchemaMap, type DOStubSchema, type DOWithHonoApp, type HonoDoFetcherStubInput, type TypedDoFetcher, honoDoFetcher, honoDoFetcherWithId, honoDoFetcherWithName };

package/dist/honoDoFetcher.js

@@ -0,0 +1,4 @@
+export { honoDoFetcher, honoDoFetcherWithId, honoDoFetcherWithName } from './chunk-EXAM5VFZ.js';
+import './chunk-ULIZJ5OD.js';
+//# sourceMappingURL=honoDoFetcher.js.map
+//# sourceMappingURL=honoDoFetcher.js.map

package/dist/honoDoFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"honoDoFetcher.js"}

package/dist/honoFetcher.d.ts

@@ -0,0 +1,113 @@
+import { Hono } from 'hono';
+import { ExtractSchema } from 'hono/types';
+
+type ParsePathParams<T extends string> = T extends `${infer _Start}/:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof ParsePathParams<`/${Rest}`>]: string;
+} : T extends `${infer _Start}/:${infer Param}` ? {
+    [K in Param]: string;
+} : never;
+type HttpMethod = "get" | "post" | "put" | "delete" | "patch";
+type HonoSchemaKeys<T extends Hono> = string & keyof ExtractSchema<T>;
+type FilterKeysByMethod<TApp extends ExtractSchema<unknown>, TMethod extends HttpMethod> = {
+    [K in keyof TApp as TApp[K] extends {
+        [key in `$${TMethod}`]: unknown;
+    } ? K : never]: TApp[K];
+};
+type HonoSchema<TApp extends Hono> = {
+    [M in HttpMethod]: FilterKeysByMethod<ExtractSchema<TApp>, M>;
+};
+type JsonResponse<T> = Omit<Response, "json"> & {
+    json: () => Promise<T>;
+};
+/**
+ * {@link JsonResponse} intersected with `Disposable` for Workers RPC: `Response`
+ * values from `DurableObjectStub#fetch()` may implement `[Symbol.dispose]` even
+ * though `Fetcher.fetch` is still typed as `Promise<Response>`. Use with
+ * {@link BaseDisposableTypedHonoFetcher} (and `TypedDoFetcher` from `./honoDoFetcher`) so
+ * `using resp = await api.get(...)` type-checks when `"ESNext.Disposable"` is in `lib`.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+type RpcDisposableJsonResponse<T> = JsonResponse<T> & Disposable;
+type HasPathParams<T extends string> = T extends `${string}:${string}` ? true : false;
+/**
+ * Values allowed in the optional `query` object on fetcher requests.
+ * `null` and `undefined` entries are omitted from the serialized query string.
+ */
+type HonoFetcherQueryParamValue = string | number | boolean;
+type HonoFetcherQueryParams = Record<string, HonoFetcherQueryParamValue | null | undefined>;
+type FetcherParams<SchemaPath extends string> = HasPathParams<SchemaPath> extends true ? {
+    params: ParsePathParams<SchemaPath>;
+    query?: HonoFetcherQueryParams;
+    init?: RequestInit;
+} : {
+    params?: never;
+    query?: HonoFetcherQueryParams;
+    init?: RequestInit;
+};
+type EmptyObject = {};
+type TypedMethodFetcher<T extends Hono, M extends HttpMethod> = <SchemaPath extends string & keyof HonoSchema<T>[M]>(request: {
+    url: SchemaPath;
+} & FetcherParams<SchemaPath> & (M extends "get" | "delete" ? EmptyObject : BodyParams<T, M, SchemaPath>)) => Promise<SchemaOutput<T, M, SchemaPath>>;
+type SchemaOutput<T extends Hono, M extends HttpMethod, SchemaPath extends string & keyof HonoSchema<T>[M], DollarM extends `$${M}` & keyof HonoSchema<T>[M][SchemaPath] = `$${M}` & keyof HonoSchema<T>[M][SchemaPath]> = "output" extends keyof HonoSchema<T>[M][SchemaPath][DollarM] ? JsonResponse<HonoSchema<T>[M][SchemaPath][DollarM]["output"]> : never;
+type DoSchemaOutput<T extends Hono, M extends HttpMethod, SchemaPath extends string & keyof HonoSchema<T>[M], DollarM extends `$${M}` & keyof HonoSchema<T>[M][SchemaPath] = `$${M}` & keyof HonoSchema<T>[M][SchemaPath]> = "output" extends keyof HonoSchema<T>[M][SchemaPath][DollarM] ? RpcDisposableJsonResponse<HonoSchema<T>[M][SchemaPath][DollarM]["output"]> : never;
+type BodyParams<TApp extends Hono, TMethod extends HttpMethod, SchemaPath extends string & keyof HonoSchema<TApp>[TMethod], DollarMethod extends `$${TMethod}` & keyof HonoSchema<TApp>[TMethod][SchemaPath] = `$${TMethod}` & keyof HonoSchema<TApp>[TMethod][SchemaPath]> = "input" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod] ? "json" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"] ? "form" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"] ? {
+    body: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"]["json"];
+} | {
+    form: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"]["form"];
+} : {
+    body: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"]["json"];
+} : "form" extends keyof HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"] ? {
+    form: HonoSchema<TApp>[TMethod][SchemaPath][DollarMethod]["input"]["form"];
+} : {
+    body?: unknown;
+} | {
+    form?: unknown;
+} : EmptyObject;
+type AvailableMethods<T extends Hono> = {
+    [M in HttpMethod]: keyof HonoSchema<T>[M] extends never ? never : M;
+}[HttpMethod];
+interface WebSocketConfig {
+    /**
+     * Whether to automatically call accept() on the WebSocket before returning.
+     * Defaults to true for convenience.
+     *
+     * In Cloudflare Workers, you must call accept() before using a WebSocket.
+     * Setting this to false allows you to call accept() manually if needed.
+     *
+     * @default true
+     */
+    autoAccept?: boolean;
+}
+type TypedWebSocketFetcher<T extends Hono> = <SchemaPath extends string & keyof HonoSchema<T>["get"]>(request: {
+    url: SchemaPath;
+    config?: WebSocketConfig;
+} & FetcherParams<SchemaPath>) => Promise<Response>;
+type BaseTypedHonoFetcher<T extends Hono> = {
+    [M in AvailableMethods<T>]: TypedMethodFetcher<T, M>;
+} & (keyof HonoSchema<T>["get"] extends never ? {} : {
+    websocket: TypedWebSocketFetcher<T>;
+});
+type TypedDisposableMethodFetcher<T extends Hono, M extends HttpMethod> = <SchemaPath extends string & keyof HonoSchema<T>[M]>(request: {
+    url: SchemaPath;
+} & FetcherParams<SchemaPath> & (M extends "get" | "delete" ? EmptyObject : BodyParams<T, M, SchemaPath>)) => Promise<DoSchemaOutput<T, M, SchemaPath>>;
+type TypedDisposableWebSocketFetcher<T extends Hono> = <SchemaPath extends string & keyof HonoSchema<T>["get"]>(request: {
+    url: SchemaPath;
+    config?: WebSocketConfig;
+} & FetcherParams<SchemaPath>) => Promise<Response & Disposable>;
+/**
+ * Same shape as {@link BaseTypedHonoFetcher} but HTTP methods return
+ * {@link RpcDisposableJsonResponse} and `websocket` returns `Response & Disposable`
+ * so `using` on RPC results type-checks for Durable Object clients.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+type BaseDisposableTypedHonoFetcher<T extends Hono> = {
+    [M in AvailableMethods<T>]: TypedDisposableMethodFetcher<T, M>;
+} & (keyof HonoSchema<T>["get"] extends never ? {} : {
+    websocket: TypedDisposableWebSocketFetcher<T>;
+});
+type TypedHonoFetcher<T extends Hono> = BaseTypedHonoFetcher<T>;
+declare const honoFetcher: <T extends Hono>(fetcher: (request: string, init?: RequestInit) => ReturnType<T["request"]> | Promise<ReturnType<T["request"]>>) => TypedHonoFetcher<T>;
+
+export { type BaseDisposableTypedHonoFetcher, type BaseTypedHonoFetcher, type HonoFetcherQueryParamValue, type HonoFetcherQueryParams, type HonoSchemaKeys, type HttpMethod, type JsonResponse, type ParsePathParams, type RpcDisposableJsonResponse, type TypedDisposableWebSocketFetcher, type TypedHonoFetcher, type TypedWebSocketFetcher, type WebSocketConfig, honoFetcher };

package/dist/honoFetcher.js

@@ -0,0 +1,3 @@
+export { honoFetcher } from './chunk-ULIZJ5OD.js';
+//# sourceMappingURL=honoFetcher.js.map
+//# sourceMappingURL=honoFetcher.js.map

package/dist/honoFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"honoFetcher.js"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { honoDirectFetcher } from './honoDirectFetcher.js';
+export { DOSchemaKeys, DOSchemaMap, DOStubSchema, DOWithHonoApp, HonoDoFetcherStubInput, TypedDoFetcher, honoDoFetcher, honoDoFetcherWithId, honoDoFetcherWithName } from './honoDoFetcher.js';
+export { BaseDisposableTypedHonoFetcher, BaseTypedHonoFetcher, HonoFetcherQueryParamValue, HonoFetcherQueryParams, HonoSchemaKeys, HttpMethod, JsonResponse, ParsePathParams, RpcDisposableJsonResponse, TypedDisposableWebSocketFetcher, TypedHonoFetcher, TypedWebSocketFetcher, WebSocketConfig, honoFetcher } from './honoFetcher.js';
+import 'hono';
+import 'hono/types';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { honoDirectFetcher } from './chunk-YCTPXFUH.js';
+export { honoDoFetcher, honoDoFetcherWithId, honoDoFetcherWithName } from './chunk-EXAM5VFZ.js';
+export { honoFetcher } from './chunk-ULIZJ5OD.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/package.json

@@ -1,28 +1,32 @@
 {
 	"name": "@firtoz/hono-fetcher",
-	"version": "2.5.0",
+	"version": "2.7.0",
 	"description": "Type-safe Hono API client with full TypeScript inference for routes, params, and payloads",
-	"main": "./src/index.ts",
-	"module": "./src/index.ts",
-	"types": "./src/index.ts",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
-			"import": "./src/index.ts",
-			"require": "./src/index.ts"
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
 		},
 		"./honoDoFetcher": {
-			"types": "./src/honoDoFetcher.ts",
-			"import": "./src/honoDoFetcher.ts",
-			"require": "./src/honoDoFetcher.ts"
+			"types": "./dist/honoDoFetcher.d.ts",
+			"import": "./dist/honoDoFetcher.js"
 		}
 	},
 	"files": [
+		"dist/**/*.js",
+		"dist/**/*.js.map",
+		"dist/**/*.d.ts",
 		"src/**/*.ts",
 		"!src/**/*.test.ts",
 		"README.md"
 	],
 	"scripts": {
+		"build": "tsup",
+		"prepack": "bun run build",
 		"typecheck": "tsgo --noEmit -p ./tsconfig.json",
 		"lint": "biome check --write src",
 		"lint:ci": "biome ci src",

package/src/honoDoFetcher.ts

@@ -1,6 +1,10 @@
 import type { Hono, Schema } from "hono";
 import type { ExtractSchema } from "hono/types";
-import { honoFetcher, type TypedHonoFetcher } from "./honoFetcher";
+import {
+	honoFetcher,
+	type BaseDisposableTypedHonoFetcher,
+	type TypedHonoFetcher,
+} from "./honoFetcher";
 
 const DUMMY_URL = "http://dummy-url";
 
@@ -24,12 +28,29 @@ export type DOStubSchema<T extends DurableObjectStub> =
 			: never
 		: never;
 
-export type TypedDoFetcher<T extends DurableObjectStub> = TypedHonoFetcher<
-	// biome-ignore lint/suspicious/noExplicitAny: Generic parameter needs flexibility
-	Hono<any, DOStubSchema<T>>
->;
+/**
+ * Fetcher for a **real** `DurableObjectStub`: HTTP results are {@link RpcDisposableJsonResponse}
+ * and `websocket` returns `Response & Disposable`, matching Workers RPC when the runtime attaches
+ * disposers. Use with {@link honoDoFetcher} / {@link honoDoFetcherWithName} / {@link honoDoFetcherWithId}
+ * when `T` is a full stub—not with a minimal `Pick<stub, "fetch">` mock (that path uses plain
+ * {@link TypedHonoFetcher} responses instead).
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+export type TypedDoFetcher<T extends DurableObjectStub> =
+	BaseDisposableTypedHonoFetcher<
+		// biome-ignore lint/suspicious/noExplicitAny: Generic parameter needs flexibility
+		Hono<any, DOStubSchema<T>>
+	>;
 
-/** Shape honoDoFetcher uses at runtime; full stubs or minimal mocks (e.g. tests) with only `fetch`. */
+/**
+ * Argument to {@link honoDoFetcher}: a **full** {@link DurableObjectStub} (production) or a minimal
+ * **`{ fetch }`** mock. Only the full stub is typed as {@link TypedDoFetcher} with disposable RPC
+ * responses; **`Pick<stub, "fetch">`** is typed as {@link TypedHonoFetcher} for `Hono` with ordinary
+ * `JsonResponse` / `Response` (no `Disposable` on results—matches mocks without `Symbol.dispose`).
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
 export type HonoDoFetcherStubInput =
 	| DurableObjectStub<DOWithHonoApp>
 	| Pick<DurableObjectStub<DOWithHonoApp>, "fetch">;
@@ -62,6 +83,22 @@ function withStubDispose<
 	});
 }
 
+/**
+ * Typed fetcher for a Durable Object stub.
+ *
+ * - **Full `DurableObjectStub`:** return type is {@link TypedDoFetcher} **`& Disposable`** — each
+ *   HTTP/WebSocket result is typed as disposable (`RpcDisposableJsonResponse` / `Response & Disposable`)
+ *   so **`using res = await …`** type-checks when `"ESNext.Disposable"` is in `lib`, matching Workers RPC
+ *   when the runtime attaches `[Symbol.dispose]` (see `@see` below).
+ * - **`Pick<stub, "fetch">` only (e.g. tests):** return type is **`TypedHonoFetcher<Hono> & Disposable`**
+ *   — same **`JsonResponse` / `Response`** shapes as {@link honoFetcher}; results are **not** typed as
+ *   `Disposable` so typings are not faked for mocks that lack RPC disposers.
+ *
+ * Disposing only the fetcher (`using api = …`) releases the **stub**; RPC **`Response`** disposal
+ * (when applicable) is separate — prefer **`using res`**, **`res[Symbol.dispose]()`**, or **`DisposableStack`**.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
 export const honoDoFetcher = <const T extends HonoDoFetcherStubInput>(
 	durableObject: T,
 ): T extends DurableObjectStub<DOWithHonoApp>

package/src/honoFetcher.ts

@@ -29,6 +29,17 @@ export type JsonResponse<T> = Omit<Response, "json"> & {
 	json: () => Promise<T>;
 };
 
+/**
+ * {@link JsonResponse} intersected with `Disposable` for Workers RPC: `Response`
+ * values from `DurableObjectStub#fetch()` may implement `[Symbol.dispose]` even
+ * though `Fetcher.fetch` is still typed as `Promise<Response>`. Use with
+ * {@link BaseDisposableTypedHonoFetcher} (and `TypedDoFetcher` from `./honoDoFetcher`) so
+ * `using resp = await api.get(...)` type-checks when `"ESNext.Disposable"` is in `lib`.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+export type RpcDisposableJsonResponse<T> = JsonResponse<T> & Disposable;
+
 type HasPathParams<T extends string> = T extends `${string}:${string}`
 	? true
 	: false;
@@ -111,6 +122,16 @@ type SchemaOutput<
 	? JsonResponse<HonoSchema<T>[M][SchemaPath][DollarM]["output"]>
 	: never;
 
+type DoSchemaOutput<
+	T extends Hono,
+	M extends HttpMethod,
+	SchemaPath extends string & keyof HonoSchema<T>[M],
+	DollarM extends `$${M}` & keyof HonoSchema<T>[M][SchemaPath] = `$${M}` &
+		keyof HonoSchema<T>[M][SchemaPath],
+> = "output" extends keyof HonoSchema<T>[M][SchemaPath][DollarM]
+	? RpcDisposableJsonResponse<HonoSchema<T>[M][SchemaPath][DollarM]["output"]>
+	: never;
+
 type BodyParams<
 	TApp extends Hono,
 	TMethod extends HttpMethod,
@@ -171,6 +192,38 @@ export type BaseTypedHonoFetcher<T extends Hono> = {
 		{}
 	: { websocket: TypedWebSocketFetcher<T> });
 
+type TypedDisposableMethodFetcher<T extends Hono, M extends HttpMethod> = <
+	SchemaPath extends string & keyof HonoSchema<T>[M],
+>(
+	request: {
+		url: SchemaPath;
+	} & FetcherParams<SchemaPath> &
+		(M extends "get" | "delete" ? EmptyObject : BodyParams<T, M, SchemaPath>),
+) => Promise<DoSchemaOutput<T, M, SchemaPath>>;
+
+export type TypedDisposableWebSocketFetcher<T extends Hono> = <
+	SchemaPath extends string & keyof HonoSchema<T>["get"],
+>(
+	request: {
+		url: SchemaPath;
+		config?: WebSocketConfig;
+	} & FetcherParams<SchemaPath>,
+) => Promise<Response & Disposable>;
+
+/**
+ * Same shape as {@link BaseTypedHonoFetcher} but HTTP methods return
+ * {@link RpcDisposableJsonResponse} and `websocket` returns `Response & Disposable`
+ * so `using` on RPC results type-checks for Durable Object clients.
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+ */
+export type BaseDisposableTypedHonoFetcher<T extends Hono> = {
+	[M in AvailableMethods<T>]: TypedDisposableMethodFetcher<T, M>;
+} & (keyof HonoSchema<T>["get"] extends never
+	? // biome-ignore lint/complexity/noBannedTypes: We really do want an empty object if the get method is not available
+		{}
+	: { websocket: TypedDisposableWebSocketFetcher<T> });
+
 const createMethodFetcher = <T extends Hono, M extends HttpMethod>(
 	fetcher: (
 		request: string,

package/src/index.ts

@@ -6,6 +6,7 @@ export {
 	type DOSchemaMap,
 	type DOStubSchema,
 	type DOWithHonoApp,
+	type HonoDoFetcherStubInput,
 	honoDoFetcher,
 	honoDoFetcherWithId,
 	honoDoFetcherWithName,
@@ -13,6 +14,7 @@ export {
 } from "./honoDoFetcher";
 // Core fetcher functionality
 export {
+	type BaseDisposableTypedHonoFetcher,
 	type BaseTypedHonoFetcher,
 	type HonoFetcherQueryParamValue,
 	type HonoFetcherQueryParams,
@@ -21,6 +23,8 @@ export {
 	honoFetcher,
 	type JsonResponse,
 	type ParsePathParams,
+	type RpcDisposableJsonResponse,
+	type TypedDisposableWebSocketFetcher,
 	type TypedHonoFetcher,
 	type TypedWebSocketFetcher,
 	type WebSocketConfig,