rpc4next 0.3.9 → 0.4.9

package/dist/rpc/lib/headers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Normalizes various `HeadersInit` formats into a plain object
+ * with lower-cased header names.
+ *
+ * This utility converts `Headers`, an array of `[key, value]` tuples,
+ * or a plain object into a `Record<string, string>`.
+ *
+ * All header names are converted to lowercase to ensure
+ * case-insensitive consistency when accessing header values.
+ *
+ * @param headers - A `HeadersInit` value (`Headers`, `[string, string][]`, or `Record<string, string>`).
+ *                  If `undefined`, an empty object is returned.
+ *
+ * @returns A plain object whose keys are lower-cased header names
+ *          and whose values are header strings.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers({
+ *   "Content-Type": "application/json",
+ *   "Authorization": "Bearer token",
+ * });
+ *
+ * const normalized = normalizeHeaders(headers);
+ * // {
+ * //   "content-type": "application/json",
+ * //   "authorization": "Bearer token"
+ * // }
+ * ```
+ *
+ * @remarks
+ * - If duplicate header names exist (ignoring case),
+ *   the last encountered value will overwrite previous ones.
+ * - This function does not merge multiple values for the same header.
+ */
+export declare const normalizeHeaders: (headers?: HeadersInit) => Record<string, string>;

package/dist/rpc/lib/headers.js

@@ -0,0 +1 @@
+const n=t=>{const r={};return t?t instanceof Headers?(t.forEach((o,e)=>{r[e.toLowerCase()]=o}),r):Array.isArray(t)?(t.forEach(([o,e])=>{r[o.toLowerCase()]=e}),r):(Object.entries(t).forEach(([o,e])=>{r[o.toLowerCase()]=e}),r):r};export{n as normalizeHeaders};

package/dist/rpc/lib/http-request-headers-types.d.ts

@@ -6,6 +6,7 @@ import type { ContentType } from "../server";
 export type HttpRequestHeaders = Partial<{
     Accept: string;
     "Accept-Charset": string;
+    "Accept-Datetime": string;
     "Accept-Encoding": string;
     "Accept-Language": string;
     Authorization: string;
@@ -26,24 +27,28 @@ export type HttpRequestHeaders = Partial<{
     "If-Unmodified-Since": string;
     "Max-Forwards": string;
     Origin: string;
-    Pragma: string;
     Range: string;
     Referer: string;
     TE: string;
     Trailer: string;
     "Transfer-Encoding": string;
     Upgrade: string;
+    "Upgrade-Insecure-Requests": string;
     "User-Agent": string;
     Via: string;
-    Warning: string;
     "Access-Control-Request-Method": string;
     "Access-Control-Request-Headers": string;
-    DNT: string;
     "Sec-Fetch-Dest": string;
     "Sec-Fetch-Mode": string;
     "Sec-Fetch-Site": string;
     "Sec-Fetch-User": string;
-    "Sec-CH-UA": string;
-    "Sec-CH-UA-Platform": string;
-    "Sec-CH-UA-Mobile": string;
+    "Sec-Purpose": string;
+    "Device-Memory": string;
+    Priority: string;
+    "Origin-Agent-Cluster": string;
+    "Service-Worker": string;
+    "Service-Worker-Allowed": string;
+    "Service-Worker-Navigation-Preload": string;
+    "Set-Login": string;
+    SourceMap: string;
 }>;

package/dist/rpc/lib/http-response-headers-types.d.ts

@@ -10,26 +10,29 @@ export type HttpResponseHeaders<TContentType extends ContentType> = Partial<{
     Expires: string;
     ETag: string;
     "Last-Modified": string;
+    Age: string;
     "Content-Type": TContentType;
     "Content-Length": string;
     "Content-Encoding": string;
     "Content-Language": string;
     "Content-Location": string;
     "Content-Disposition": string;
+    "Content-Range": string;
+    "Content-Digest": string;
+    "Content-Security-Policy": string;
+    "Content-Security-Policy-Report-Only": string;
     "Access-Control-Allow-Origin": string;
     "Access-Control-Allow-Credentials": string;
     "Access-Control-Allow-Headers": string;
     "Access-Control-Allow-Methods": string;
     "Access-Control-Expose-Headers": string;
+    "Access-Control-Max-Age": string;
     "WWW-Authenticate": string;
-    Authorization: string;
+    "Proxy-Authenticate": string;
     "Strict-Transport-Security": string;
-    "Content-Security-Policy": string;
     "X-Content-Type-Options": string;
     "X-Frame-Options": string;
-    "X-XSS-Protection": string;
     "Referrer-Policy": string;
-    "Permissions-Policy": string;
     "Cross-Origin-Opener-Policy": string;
     "Cross-Origin-Embedder-Policy": string;
     "Cross-Origin-Resource-Policy": string;
@@ -40,7 +43,27 @@ export type HttpResponseHeaders<TContentType extends ContentType> = Partial<{
     "Transfer-Encoding": string;
     Upgrade: string;
     Vary: string;
+    Trailer: string;
+    "Upgrade-Insecure-Requests": string;
     Date: string;
     Server: string;
-    "X-Powered-By": string;
+    "Accept-CH": string;
+    "Accept-Patch": string;
+    "Accept-Post": string;
+    "Accept-Ranges": string;
+    Allow: string;
+    "Alt-Svc": string;
+    "Alt-Used": string;
+    "Clear-Site-Data": string;
+    Link: string;
+    "Origin-Agent-Cluster": string;
+    "Preference-Applied": string;
+    Priority: string;
+    "Reporting-Endpoints": string;
+    "Retry-After": string;
+    "Server-Timing": string;
+    SourceMap: string;
+    "Timing-Allow-Origin": string;
+    "Want-Content-Digest": string;
+    "Want-Repr-Digest": string;
 }>;

package/dist/rpc/lib/search-params.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Converts a `URLSearchParams` instance into a plain object.
+ *
+ * This utility aggregates query parameters into an object where:
+ * - The first occurrence of a key becomes a `string`
+ * - If the same key appears multiple times, the value becomes a `string[]`
+ *
+ * The returned object is cast to the generic type `T`. This is a **type-level**
+ * convenience: the runtime output only contains `string` or `string[]` values
+ * (no `undefined` keys are produced).
+ *
+ * @typeParam T - The desired return shape. Must be a record of `string` keys
+ * with values `string | string[] | undefined`. Note: `undefined` is allowed in
+ * the type to support downstream optional fields, but is not produced at runtime.
+ *
+ * @param searchParams - The `URLSearchParams` to convert.
+ * @returns A plain object containing the query parameters.
+ *
+ * @example
+ * ```ts
+ * const sp = new URLSearchParams("q=chatgpt&tag=a&tag=b");
+ * const obj = searchParamsToObject(sp);
+ * // => { q: "chatgpt", tag: ["a", "b"] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Params = { q?: string; tag?: string[] };
+ * const sp = new URLSearchParams("q=hello&tag=a&tag=b");
+ * const obj = searchParamsToObject<Params>(sp);
+ * // obj.q is typed as string | undefined
+ * // obj.tag is typed as string[] | undefined
+ * ```
+ */
+export declare const searchParamsToObject: <T extends Record<string, string | string[] | undefined>>(searchParams: URLSearchParams) => T;

package/dist/rpc/lib/types.d.ts

@@ -1,2 +1 @@
-import type { HTTP_METHODS } from "./constants";
-export type HttpMethod = (typeof HTTP_METHODS)[number];
+export type { HttpMethod } from "rpc4next-shared";

package/dist/rpc/server/handler.d.ts

@@ -1,4 +1,4 @@
 import type { ValidationSchema, RouteResponse, Handler } from "./route-types";
 import type { Params, Query } from "./types";
-import type { HttpMethod } from "../lib/types";
+import type { HttpMethod } from "rpc4next-shared";
 export declare const createHandler: <THttpMethod extends HttpMethod, TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>() => <TRouteResponse extends RouteResponse>(handler: Handler<THttpMethod, TParams, TQuery, TValidationSchema, TRouteResponse>) => Handler<THttpMethod, TParams, TQuery, TValidationSchema, TRouteResponse>;

package/dist/rpc/server/route-context.js

@@ -1 +1 @@
-import{NextResponse as a}from"next/server";import{searchParamsToObject as p}from"./server-utils";const d=(s,o)=>{const n={};return{req:Object.assign(s,{query:()=>p(s.nextUrl.searchParams),params:()=>o.params,valid:t=>n[t],addValidatedData:(t,e)=>{n[t]=e}}),body:(t,e)=>new a(t,e),json:(t,e)=>a.json(t,e),text:(t,e)=>new a(t,{...e,headers:{"Content-Type":"text/plain",...e?.headers}}),redirect:(t,e)=>a.redirect(t,e)}};export{d as createRouteContext};
+import{NextResponse as n}from"next/server";import{normalizeHeaders as T}from"../lib/headers";import{searchParamsToObject as i}from"../lib/search-params";const p=t=>typeof t=="number"&&!Number.isNaN(t),o=t=>{if(!t)return t;if(p(t))return{status:t};const r=t.headers??T(t.headersInit),{headers:d,headersInit:a,...e}=t;return{...e,headers:r}},S=(t,r)=>{const d={};return{req:Object.assign(t,{query:()=>i(t.nextUrl.searchParams),params:()=>r.params,valid:a=>d[a],addValidatedData:(a,e)=>{d[a]=e}}),body:(a,e)=>new n(a,o(e)),json:(a,e)=>n.json(a,o(e)),text:(a,e)=>{const s=o(e);return new n(a,{...s,headers:{...s?.headers,"Content-Type":"text/plain"}})},redirect:(a,e)=>{const s=p(e)?e:o(e);return n.redirect(a,s)}}};export{S as createRouteContext};

package/dist/rpc/server/route-handler-factory.js

@@ -1,4 +1,4 @@
 /*!
  * Inspired by Hono (https://github.com/honojs/hono),
  * particularly its routing design and handler interface.
- */import{createRouteContext as d}from"./route-context";const i=(o,e)=>async(n,s)=>{const a=d(n,s);try{for(const t of o){const r=await t(a);if(r instanceof Response)return r}throw new Error("No handler returned a response")}catch(t){return await e(t,a)}},T=o=>()=>{const e=n=>(...s)=>{const t=i(s,o??((r,p)=>{throw r}));return{[n]:t}};return{get:e("GET"),post:e("POST"),put:e("PUT"),delete:e("DELETE"),patch:e("PATCH"),head:e("HEAD"),options:e("OPTIONS")}};export{T as routeHandlerFactory};
+ */import{createRouteContext as d}from"./route-context";const i=(o,e)=>async(n,s)=>{const a=d(n,s);try{for(const r of o){const t=await r(a);if(t instanceof Response)return t}throw new Error("No handler returned a response")}catch(r){return await e(r,a)}},T=o=>()=>{const e=n=>((...s)=>{const r=i(s,o??((t,p)=>{throw t}));return{[n]:r}});return{get:e("GET"),post:e("POST"),put:e("PUT"),delete:e("DELETE"),patch:e("PATCH"),head:e("HEAD"),options:e("OPTIONS")}};export{T as routeHandlerFactory};

package/dist/rpc/server/route-types.d.ts

@@ -7,8 +7,8 @@
  * Hono is licensed under the MIT License.
  */
 import type { TypedNextResponse, Query, RouteContext, Params } from "./types";
-import type { HttpMethod } from "../lib/types";
 import type { NextRequest } from "next/server";
+import type { HttpMethod } from "rpc4next-shared";
 export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | void>;
 export type RequiredRouteResponse = TypedNextResponse | Promise<TypedNextResponse>;
 export interface RouteBindings {

package/dist/rpc/server/types.d.ts

@@ -2,8 +2,8 @@ import type { ValidationSchema } from "./route-types";
 import type { ContentType } from "../lib/content-type-types";
 import type { HttpResponseHeaders } from "../lib/http-response-headers-types";
 import type { HttpStatusCode, RedirectionHttpStatusCode, SuccessfulHttpStatusCode } from "../lib/http-status-code-types";
-import type { HttpMethod } from "../lib/types";
 import type { NextResponse, NextRequest } from "next/server";
+import type { HttpMethod } from "rpc4next-shared";
 /**
  * Represents the result of an HTTP response status check.
  *
@@ -28,10 +28,15 @@ type HttpStatus<T extends HttpStatusCode> = T extends SuccessfulHttpStatusCode ?
  * @template TStatus - The HTTP status code.
  * @template TContentType - The content type of the response.
  */
-export interface TypedResponseInit<TStatus extends HttpStatusCode, TContentType extends ContentType> extends ResponseInit {
-    headers?: HttpResponseHeaders<TContentType> | HeadersInit;
+export type TypedResponseInit<TStatus extends HttpStatusCode, TContentType extends ContentType> = ({
+    headers?: HttpResponseHeaders<TContentType> & Record<string, string>;
+    headersInit?: never;
+} & Omit<ResponseInit, "headers">) | (({
+    headers?: never;
+    headersInit?: HeadersInit;
+} & Omit<ResponseInit, "headers">) & {
     status?: TStatus;
-}
+});
 /**
  * A strongly typed wrapper around the standard Next.js `NextResponse` object,
  * with additional type information for status code, content type, and response body.
@@ -118,7 +123,7 @@ export interface RouteContext<TParams = Params, TQuery = Query, TValidationSchem
      * @param init - Optional response init.
      * @returns A typed response.
      */
-    body: <TData extends BodyInit | null, TContentType extends ContentType, TStatus extends HttpStatusCode = 200>(data: TData, init?: TypedResponseInit<TStatus, TContentType>) => TypedNextResponse<TData, TStatus, TContentType>;
+    body: <TData extends BodyInit | null, TContentType extends ContentType, TStatus extends HttpStatusCode = 200>(data: TData, init?: TStatus | TypedResponseInit<TStatus, TContentType>) => TypedNextResponse<TData, TStatus, TContentType>;
     /**
      * Creates a typed JSON response using `NextResponse.json(...)`.
      *
@@ -126,7 +131,7 @@ export interface RouteContext<TParams = Params, TQuery = Query, TValidationSchem
      * @param init - Optional response init.
      * @returns A JSON response.
      */
-    json: <TData, TStatus extends HttpStatusCode = 200>(data: TData, init?: TypedResponseInit<TStatus, "application/json">) => TypedNextResponse<TData, TStatus, "application/json">;
+    json: <TData, TStatus extends HttpStatusCode = 200>(data: TData, init?: TStatus | TypedResponseInit<TStatus, "application/json">) => TypedNextResponse<TData, TStatus, "application/json">;
     /**
      * Creates a plain text response with `Content-Type: text/plain`.
      * Internally uses `new NextResponse(...)` with headers.
@@ -135,16 +140,16 @@ export interface RouteContext<TParams = Params, TQuery = Query, TValidationSchem
      * @param init - Optional response init.
      * @returns A plain text response.
      */
-    text: <TData extends string, TStatus extends HttpStatusCode = 200>(data: TData, init?: TypedResponseInit<TStatus, "text/plain">) => TypedNextResponse<TData, TStatus, "text/plain">;
+    text: <TData extends string, TStatus extends HttpStatusCode = 200>(data: TData, init?: TStatus | TypedResponseInit<TStatus, "text/plain">) => TypedNextResponse<TData, TStatus, "text/plain">;
     /**
      * Issues a redirect response.
      * Internally wraps `NextResponse.redirect(...)`.
      *
      * @param url - The URL to redirect to.
-     * @param init - Optional redirect status code (default: 302).
+     * @param init - Optional redirect status code (default: 307).
      * @returns A redirect response.
      */
-    redirect: <TStatus extends RedirectionHttpStatusCode = 302>(url: string, init?: TStatus | TypedResponseInit<TStatus, "">) => TypedNextResponse<undefined, TStatus, "">;
+    redirect: <TStatus extends RedirectionHttpStatusCode = 307>(url: string, init?: TStatus | TypedResponseInit<TStatus, "">) => TypedNextResponse<undefined, TStatus, "">;
 }
 declare const __validatedBrand: unique symbol;
 export type ValidatedData = {

package/dist/rpc/server/validators/validator.d.ts

@@ -6,7 +6,7 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
-import type { HttpMethod } from "../../lib/types";
 import type { ValidationSchema } from "../route-types";
 import type { Params, Query, RouteContext, TypedNextResponse, ValidatedData, ValidationTarget } from "../types";
+import type { HttpMethod } from "rpc4next-shared";
 export declare const validator: <THttpMethod extends HttpMethod, TValidationTarget extends ValidationTarget<THttpMethod>, TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>() => <TTypedNextResponse extends TypedNextResponse>(target: TValidationTarget, validateHandler: (value: object, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => Promise<ValidatedData | TTypedNextResponse>) => import("../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<TTypedNextResponse | undefined>>;

package/dist/rpc/server/validators/validator.js

@@ -5,4 +5,4 @@
  * This code has been adapted and modified for this project.
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
- */import{createHandler as i}from"../handler";import{getCookiesObject as n,getHeadersObject as s}from"./validator-utils";const T=()=>(e,r)=>i()(async t=>{const o=await(async()=>{if(e==="params")return await t.req.params();if(e==="query")return t.req.query();if(e==="json")return t.req.json();if(e==="headers")return await s();if(e==="cookies")return await n();throw new Error(`Unexpected target: ${e}`)})(),a=await r(o,t);if(a instanceof Response)return a;t.req.addValidatedData(e,a)});export{T as validator};
+ */import{createHandler as n}from"../handler";import{getCookiesObject as i,getHeadersObject as s}from"./validator-utils";const T=()=>(e,r)=>n()(async t=>{const o=await(async()=>{if(e==="params")return await t.req.params();if(e==="query")return t.req.query();if(e==="json")return t.req.json();if(e==="headers")return await s();if(e==="cookies")return await i();throw new Error(`Unexpected target: ${e}`)})(),a=await r(o,t);if(a instanceof Response)return a;t.req.addValidatedData(e,a)});export{T as validator};

package/dist/rpc/server/validators/zod/zod-validator.d.ts

@@ -6,11 +6,11 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
-import type { HttpMethod } from "../../../lib/types";
 import type { ValidationSchema } from "../../route-types";
 import type { RouteContext, Params, Query, TypedNextResponse, ConditionalValidationInput, ValidationTarget } from "../../types";
+import type { HttpMethod } from "rpc4next-shared";
 import type { z, ZodSchema } from "zod";
 export declare const zValidator: <THttpMethod extends HttpMethod, TValidationTarget extends ValidationTarget<THttpMethod>, TSchema extends ZodSchema<any>, TParams extends ConditionalValidationInput<TValidationTarget, "params", TValidationSchema, Params> & Params, TQuery extends ConditionalValidationInput<TValidationTarget, "query", TValidationSchema, Query> & Query, TInput = z.input<TSchema>, TOutput = z.output<TSchema>, TValidationSchema extends ValidationSchema = {
     input: Record<TValidationTarget, TInput>;
     output: Record<TValidationTarget, TOutput>;
-}, THookReturn extends TypedNextResponse | void = TypedNextResponse<z.SafeParseError<TInput>, 400, "application/json"> | void>(target: TValidationTarget, schema: TSchema, hook?: (result: z.SafeParseReturnType<TInput, TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;
+}, THookReturn extends TypedNextResponse | void = TypedNextResponse<z.ZodSafeParseError<TInput>, 400, "application/json"> | void>(target: TValidationTarget, schema: TSchema, hook?: (result: z.ZodSafeParseResult<TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "rpc4next",
-  "version": "0.3.9",
   "description": "Inspired by Hono RPC and Pathpida, rpc4next brings a lightweight and intuitive RPC solution to Next.js, making server-client communication seamless",
   "author": "watanabe-1",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/watanabe-1/rpc4next"
+    "url": "git+https://github.com/watanabe-1/rpc4next.git",
+    "directory": "packages/rpc4next"
   },
   "homepage": "https://github.com/watanabe-1/rpc4next#readme",
   "bugs": {
     "url": "https://github.com/watanabe-1/rpc4next/issues"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "next.js",
     "rpc",
-    "typescript",
-    "cli"
+    "typescript"
   ],
   "type": "module",
   "module": "dist/index.js",
@@ -24,10 +26,17 @@
   "files": [
     "dist"
   ],
-  "bin": {
-    "rpc4next": "dist/rpc/cli/index.js"
-  },
   "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
     "./client": {
       "import": {
         "types": "./dist/rpc/client/index.d.ts",
@@ -57,46 +66,45 @@
         "types": "./dist/rpc/server/validators/zod/index.d.ts",
         "default": "./dist/rpc/server/validators/zod/index.js"
       }
+    },
+    "./lib/constants": {
+      "import": {
+        "types": "./dist/rpc/lib/constants.d.ts",
+        "default": "./dist/rpc/lib/constants.js"
+      },
+      "default": {
+        "types": "./dist/rpc/lib/constants.d.ts",
+        "default": "./dist/rpc/lib/constants.js"
+      }
+    },
+    "./lib/types": {
+      "import": {
+        "types": "./dist/rpc/lib/types.d.ts",
+        "default": "./dist/rpc/lib/types.js"
+      },
+      "default": {
+        "types": "./dist/rpc/lib/types.d.ts",
+        "default": "./dist/rpc/lib/types.js"
+      }
     }
   },
   "scripts": {
     "build": "bun run clean && bun build.ts && bun run build:types",
-    "build:types": "tsc -p tsconfig.build-types.json",
-    "clean": "bun -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build:types": "tsc -b --force tsconfig.build-types.json",
+    "clean": "bun -e \"const fs=require('fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('tsconfig.build-types.tsbuildinfo',{force:true}); fs.rmSync('tsconfig.tsbuildinfo',{force:true});\"",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage.enabled true",
     "test:ui": "vitest --ui --coverage.enabled true",
     "test:watch": "vitest --watch",
-    "lint": "eslint \"**/*.ts\"",
-    "lint:fix": "eslint \"**/*.ts\" --fix",
-    "typecheck": "tsc --noEmit"
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "typecheck": "tsc -b tsconfig.build.json --noEmit"
   },
   "dependencies": {
-    "chalk": "^5.4.1",
-    "chokidar": "^4.0.3",
-    "commander": "^13.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.15.2",
-    "@vitest/coverage-v8": "^3.1.2",
-    "@vitest/eslint-plugin": "^1.1.43",
-    "@vitest/ui": "^3.1.2",
-    "esbuild": "^0.25.3",
-    "eslint": "^9.25.1",
-    "eslint-config-prettier": "^10.1.2",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-unused-imports": "^4.1.4",
-    "mock-fs": "^5.5.0",
-    "msw": "^2.7.5",
-    "next": "15.3.1",
-    "prettier": "^3.5.3",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.31.0",
-    "vitest": "^3.1.2",
-    "zod": "^3.24.3"
+    "rpc4next-shared": "workspace:*"
   },
   "peerDependencies": {
     "next": "^14.0.0 || ^15.0.0"
-  }
+  },
+  "version": "0.4.9"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 watanabe-1
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,164 +0,0 @@
-# rpc4next
-
-Lightweight, type-safe RPC system for Next.js App Router projects.
-
-Inspired by Hono RPC and Pathpida, **rpc4next** automatically generates a type-safe client for your existing `route.ts` **and** `page.tsx` files, enabling seamless server-client communication with full type inference.
-
----
-
-## ✨ Features
-
-- ✅ ルート、パラメータ、クエリパラメータ、 リクエストボディ、レスポンスの型安全なクライアント生成
-- ✅ 既存の `app/**/route.ts` および `app/**/page.tsx` を活用するため、新たなハンドラファイルの作成は不要
-- ✅ 最小限のセットアップで、カスタムサーバー不要
-- ✅ 動的ルート（`[id]`、`[...slug]` など）に対応
-- ✅ CLI による自動クライアント用型定義生成
-
----
-
-## 🚀 Getting Started
-
-### 1. Install rpc4next
-
-```bash
-npm install rpc4next
-```
-
-### 2. Define API Routes in Next.js
-
-Next.js プロジェクト内の既存の `app/**/route.ts` と `app/**/page.tsx` ファイルをそのまま利用できます。
-さらに、クエリパラメータ（searchParams）の型安全性を有効にするには、対象のファイル内で `Query` または `OptionalQuery` 型を定義し、`export` してください。
-
-```ts
-// app/api/user/[id]/route.ts
-import { NextRequest, NextResponse } from "next/server";
-
-// searchParams用の型定義
-export type Query = {
-  q: string; // 必須
-  page?: number; // 任意
-};
-
-export async function GET(
-  req: NextRequest,
-  segmentData: { params: Promise<{ id: string }> }
-) {
-  const { id } = await segmentData.params;
-  const q = req.nextUrl.searchParams.get("q");
-  return NextResponse.json({ id, q });
-}
-```
-
-🚩 Query or OptionalQuery 型を export することで、searchParams の型も自動的にクライアントに反映されます。
-
-- **RPCとしてresponseの戻り値の推論が機能するのは、対象となる `route.ts` の HTTPメソッドハンドラ内で`NextResponse.json()` をしている関数のみになります**
-
----
-
-### 3. Generate Type Definitions with CLI
-
-CLI を利用して、Next.js のルート構造から型安全な RPC クライアントの定義を自動生成します。
-
-```bash
-npx rpc4next <baseDir> <outputPath>
-```
-
-- `<baseDir>`: Next.js の Appルータが配置されたベースディレクトリ
-- `<outputPath>`: 生成された型定義ファイルの出力先
-
-#### オプション
-
-- **ウォッチモード**  
-  ファイル変更を検知して自動的に再生成する場合は `--watch` or `-w` オプションを付けます。
-
-  ```bash
-  npx rpc4next <baseDir> <outputPath> --watch
-  ```
-
-- **パラメータ型ファイルの生成**  
-  各ルートに対して個別のパラメータ型定義ファイルを生成する場合は、`--params-file` or `-p` オプションにファイル名を指定します。
-
-  ```bash
-  npx rpc4next <baseDir> <outputPath> --generate-params-types <paramsFileName>
-  ```
-
----
-
-### 4. Create Your RPC Client
-
-生成された型定義ファイルを基に、RPC クライアントを作成します。
-
-```ts
-// lib/rpcClient.ts
-import { createClient } from "rpc4next/client";
-import type { PathStructure } from "あなたが生成した型定義ファイル";
-
-export const rpc = createClient<PathStructure>();
-```
-
----
-
-### 5. Use It in Your Components
-
-コンポーネント内で生成された RPC クライアントを使用します。
-
-```tsx
-// app/page.tsx
-import { rpc } from "@/lib/rpcClient";
-
-export default async function Page() {
-  const res = await rpc.api.user._id("123").$get({
-    query: { q: "hello", page: 1 },
-  });
-  const json = await res.json();
-  return <div>{json.q}</div>;
-}
-```
-
-- エディタの補完機能により、利用可能なエンドポイントが自動的に表示されます。
-- リクエストの構造（params, query）はサーバーコードから推論され、レスポンスも型安全に扱えます。
-
----
-
-## ✅ さらに型安全にしたい場合 `honolike` + `createRouteHandler` による Next.js の型安全強化
-
-さらに `honolike` をベースとした `createRouteHandler()` を組み合わせることで、
-
-### 📌 主なメリット
-
-1. **レスポンス型安全**
-
-   - ステータス、Content-Type、Body がすべて型で保証される
-   - クライアントは受け取るレスポンス型を完全に推論可能
-
-2. **クライアント側補完強化**
-
-   - `status`, `content-type`, `json()`, `text()` などが適切に補完される
-
-3. **サーバー側 params / query も型安全**
-   - `routeHandlerFactory()` を使えば、`params`, `query` も型推論可能
-
----
-
-### ✅ 基本的な使い方
-
-```ts
-const createRouteHandler = routeHandlerFactory((err, rc) =>
-  rc.text("error", { status: 400 })
-);
-
-const { POST } = createRouteHandler().post(async (rc) => rc.text("plain text"));
-```
-
-これだけで、POST リクエストの返り値が、responseの内容(json,textなど)、status,contenttypeが型付けされるようになります。
-
-## 🚧 Requirements
-
-- Next.js 14+ (App Router 使用)
-- Node.js 18+
-
----
-
-## 💼 License
-
-MIT