@kotodayori/fetch 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hidetaka Okamoto
+
+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,3 +1,125 @@
-# Temporary Holding Version
+# @kotodayori/fetch
 
-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.
+[![npm version](https://img.shields.io/npm/v/%40kotodayori%2Ffetch.svg?logo=npm&label=npm)](https://www.npmjs.com/package/@kotodayori/fetch)
+[![license](https://img.shields.io/npm/l/%40kotodayori%2Ffetch.svg)](https://www.npmjs.com/package/@kotodayori/fetch)
+
+Web-standard fetch adapter for Kotodayori webhook router.
+
+## Overview
+
+`@kotodayori/fetch` turns a Kotodayori router into a `(request: Request) => Promise<Response>` handler. Any runtime or framework that hands you a standard `Request` can use it without a dedicated adapter:
+
+- Cloudflare Workers (without Hono)
+- Bun / Deno
+- Next.js App Router route handlers
+- React Router v7 / Remix actions
+- Netlify Functions (`export default async (req: Request, context: Context) => ...` style)
+
+Handlers that receive Node-style `(req, res)` objects (Express, Next.js Pages Router `pages/api`, Netlify's legacy `handler(event, context)` signature) are **not** supported — use `@kotodayori/express` or `@kotodayori/lambda` instead.
+
+## Installation
+
+```bash
+pnpm add @kotodayori/fetch @kotodayori/core
+# The Stripe example below also needs:
+pnpm add @kotodayori/stripe stripe
+```
+
+## Quick Start
+
+Build the handler from the secrets your runtime provides. Cloudflare Workers passes secrets to `fetch` as the `env` binding, so the handler is created per request there; elsewhere `process.env` works.
+
+```typescript
+import Stripe from 'stripe';
+import { StripeWebhookRouter, createStripeVerifier } from '@kotodayori/stripe';
+import { fetchAdapter } from '@kotodayori/fetch';
+
+const router = new StripeWebhookRouter();
+
+router.on('payment_intent.succeeded', async (event) => {
+  console.log('Payment succeeded:', event.data.object.id);
+});
+
+export const createHandler = (apiKey: string, webhookSecret: string) =>
+  fetchAdapter(router, {
+    verifier: createStripeVerifier(new Stripe(apiKey), webhookSecret),
+  });
+```
+
+### Cloudflare Workers
+
+Secrets are read from the `env` binding (set with `wrangler secret put STRIPE_API_KEY` / `STRIPE_WEBHOOK_SECRET`), not from `process.env`:
+
+```typescript
+export default {
+  fetch: (request: Request, env: { STRIPE_API_KEY: string; STRIPE_WEBHOOK_SECRET: string }) =>
+    createHandler(env.STRIPE_API_KEY, env.STRIPE_WEBHOOK_SECRET)(request),
+};
+```
+
+### Bun / Deno
+
+```typescript
+const handle = createHandler(process.env.STRIPE_API_KEY!, process.env.STRIPE_WEBHOOK_SECRET!);
+
+export default { fetch: handle };
+```
+
+### Next.js App Router (`app/webhook/route.ts`)
+
+```typescript
+export const POST = createHandler(process.env.STRIPE_API_KEY!, process.env.STRIPE_WEBHOOK_SECRET!);
+```
+
+### React Router v7 / Remix
+
+```typescript
+export const action = ({ request }: { request: Request }) =>
+  createHandler(process.env.STRIPE_API_KEY!, process.env.STRIPE_WEBHOOK_SECRET!)(request);
+```
+
+## API
+
+```typescript
+function fetchAdapter<TEvent extends WebhookEvent>(
+  router: WebhookDispatcher<TEvent>,
+  options: {
+    verifier: Verifier<TEvent>;
+    onError?: (error: Error, event: TEvent) => Promise<void> | void;
+    logger?: Logger; // defaults to consoleLogger
+  }
+): (request: Request) => Promise<Response>
+```
+
+- **verifier** — Required. Verifies the request and returns the event (e.g. `createStripeVerifier`).
+- **onError** — Optional. Called when a handler throws; errors thrown by `onError` itself are ignored and the response stays 500.
+- **logger** — Optional. Receives adapter diagnostics, currently verification failures (`logger.error('Webhook verification failed:', err)`). Defaults to `consoleLogger`, which writes to `console`.
+
+The raw body is read with `request.text()` and passed to the verifier untouched, so signature verification sees the exact bytes that were signed.
+
+| Situation | Status | Body |
+|-----------|--------|------|
+| Non-POST method | 405 (`Allow: POST`) | `{ "error": "Method not allowed" }` |
+| Empty or whitespace-only body | 400 | `{ "error": "Request body cannot be empty" }` |
+| Verification failed | 400 | `{ "error": "Verification failed" }` |
+| Handler threw | 500 | `{ "error": "Internal server error" }` |
+| Success | 200 | `{ "received": true }` |
+
+### Custom logger
+
+Route verification failures to your own logger, or silence them:
+
+```typescript
+import { silentLogger } from '@kotodayori/core';
+
+const handle = fetchAdapter(router, {
+  verifier,
+  logger: silentLogger, // or any object with `warn` and `error` methods
+});
+```
+
+Unlike the Hono adapter, non-POST requests are rejected with 405 because the handler may be mounted directly (e.g. `export default { fetch: handle }`) with no router in front of it.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WebhookRouter: () => import_core2.WebhookRouter,
+  fetchAdapter: () => fetchAdapter
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@kotodayori/core");
+var import_core2 = require("@kotodayori/core");
+function jsonResponse(body, status, headers = {}) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json", ...headers }
+  });
+}
+function fetchAdapter(router, options) {
+  return async (request) => {
+    if (request.method !== "POST") {
+      return jsonResponse({ error: "Method not allowed" }, 405, { allow: "POST" });
+    }
+    const rawBody = await request.text();
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    const { status, body } = await (0, import_core.handleWebhook)(router, options, rawBody, headers);
+    return jsonResponse(body, status);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebhookRouter,
+  fetchAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  handleWebhook,\n  type WebhookDispatcher,\n  type WebhookEvent,\n  type WebhookHandlerOptions,\n} from '@kotodayori/core';\n\n/**\n * Options for the fetch adapter\n */\nexport type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;\n\nfunction jsonResponse(body: unknown, status: number, headers: Record<string, string> = {}): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json', ...headers },\n  });\n}\n\n/**\n * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler\n *\n * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,\n * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.\n * The raw body is read with `request.text()` and passed to the verifier untouched.\n * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted\n * without a router in front of it.\n *\n * @example\n * ```typescript\n * import { fetchAdapter } from '@kotodayori/fetch';\n * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';\n *\n * const router = new StripeWebhookRouter();\n * const handle = fetchAdapter(router, {\n *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n * });\n *\n * // Cloudflare Workers / Bun / Deno\n * export default { fetch: handle };\n *\n * // Next.js App Router (app/webhook/route.ts)\n * export const POST = handle;\n *\n * // React Router v7 / Remix\n * export const action = ({ request }) => handle(request);\n * ```\n *\n * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)\n * @param options - Adapter options including a verifier function\n * @returns Fetch handler function\n */\nexport function fetchAdapter<\n  TEvent extends WebhookEvent = WebhookEvent,\n>(\n  router: WebhookDispatcher<TEvent>,\n  options: FetchAdapterOptions<TEvent>\n): (request: Request) => Promise<Response> {\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== 'POST') {\n      return jsonResponse({ error: 'Method not allowed' }, 405, { allow: 'POST' });\n    }\n\n    // Get raw body text for signature verification\n    const rawBody = await request.text();\n\n    const headers: Record<string, string> = {};\n    request.headers.forEach((value, key) => {\n      headers[key] = value;\n    });\n\n    const { status, body } = await handleWebhook(router, options, rawBody, headers);\n    return jsonResponse(body, status);\n  };\n}\n\n// Re-export core types\nexport { WebhookRouter, type WebhookDispatcher, type WebhookEvent, type EventHandler, type Middleware, type Verifier, type VerifyResult } from '@kotodayori/core';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAKO;AAwEP,IAAAA,eAA+I;AAjE/I,SAAS,aAAa,MAAe,QAAgB,UAAkC,CAAC,GAAa;AACnG,SAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACxC;AAAA,IACA,SAAS,EAAE,gBAAgB,oBAAoB,GAAG,QAAQ;AAAA,EAC5D,CAAC;AACH;AAmCO,SAAS,aAGd,QACA,SACyC;AACzC,SAAO,OAAO,YAAwC;AACpD,QAAI,QAAQ,WAAW,QAAQ;AAC7B,aAAO,aAAa,EAAE,OAAO,qBAAqB,GAAG,KAAK,EAAE,OAAO,OAAO,CAAC;AAAA,IAC7E;AAGA,UAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAM,UAAkC,CAAC;AACzC,YAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAQ;AACtC,cAAQ,GAAG,IAAI;AAAA,IACjB,CAAC;AAED,UAAM,EAAE,QAAQ,KAAK,IAAI,UAAM,2BAAc,QAAQ,SAAS,SAAS,OAAO;AAC9E,WAAO,aAAa,MAAM,MAAM;AAAA,EAClC;AACF;","names":["import_core"]}

package/dist/index.d.cts

@@ -0,0 +1,43 @@
+import { WebhookEvent, WebhookHandlerOptions, WebhookDispatcher } from '@kotodayori/core';
+export { EventHandler, Middleware, Verifier, VerifyResult, WebhookDispatcher, WebhookEvent, WebhookRouter } from '@kotodayori/core';
+
+/**
+ * Options for the fetch adapter
+ */
+type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;
+/**
+ * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler
+ *
+ * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,
+ * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.
+ * The raw body is read with `request.text()` and passed to the verifier untouched.
+ * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted
+ * without a router in front of it.
+ *
+ * @example
+ * ```typescript
+ * import { fetchAdapter } from '@kotodayori/fetch';
+ * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';
+ *
+ * const router = new StripeWebhookRouter();
+ * const handle = fetchAdapter(router, {
+ *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),
+ * });
+ *
+ * // Cloudflare Workers / Bun / Deno
+ * export default { fetch: handle };
+ *
+ * // Next.js App Router (app/webhook/route.ts)
+ * export const POST = handle;
+ *
+ * // React Router v7 / Remix
+ * export const action = ({ request }) => handle(request);
+ * ```
+ *
+ * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)
+ * @param options - Adapter options including a verifier function
+ * @returns Fetch handler function
+ */
+declare function fetchAdapter<TEvent extends WebhookEvent = WebhookEvent>(router: WebhookDispatcher<TEvent>, options: FetchAdapterOptions<TEvent>): (request: Request) => Promise<Response>;
+
+export { type FetchAdapterOptions, fetchAdapter };

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { WebhookEvent, WebhookHandlerOptions, WebhookDispatcher } from '@kotodayori/core';
+export { EventHandler, Middleware, Verifier, VerifyResult, WebhookDispatcher, WebhookEvent, WebhookRouter } from '@kotodayori/core';
+
+/**
+ * Options for the fetch adapter
+ */
+type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;
+/**
+ * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler
+ *
+ * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,
+ * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.
+ * The raw body is read with `request.text()` and passed to the verifier untouched.
+ * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted
+ * without a router in front of it.
+ *
+ * @example
+ * ```typescript
+ * import { fetchAdapter } from '@kotodayori/fetch';
+ * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';
+ *
+ * const router = new StripeWebhookRouter();
+ * const handle = fetchAdapter(router, {
+ *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),
+ * });
+ *
+ * // Cloudflare Workers / Bun / Deno
+ * export default { fetch: handle };
+ *
+ * // Next.js App Router (app/webhook/route.ts)
+ * export const POST = handle;
+ *
+ * // React Router v7 / Remix
+ * export const action = ({ request }) => handle(request);
+ * ```
+ *
+ * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)
+ * @param options - Adapter options including a verifier function
+ * @returns Fetch handler function
+ */
+declare function fetchAdapter<TEvent extends WebhookEvent = WebhookEvent>(router: WebhookDispatcher<TEvent>, options: FetchAdapterOptions<TEvent>): (request: Request) => Promise<Response>;
+
+export { type FetchAdapterOptions, fetchAdapter };

package/dist/index.js

@@ -0,0 +1,30 @@
+// src/index.ts
+import {
+  handleWebhook
+} from "@kotodayori/core";
+import { WebhookRouter } from "@kotodayori/core";
+function jsonResponse(body, status, headers = {}) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json", ...headers }
+  });
+}
+function fetchAdapter(router, options) {
+  return async (request) => {
+    if (request.method !== "POST") {
+      return jsonResponse({ error: "Method not allowed" }, 405, { allow: "POST" });
+    }
+    const rawBody = await request.text();
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    const { status, body } = await handleWebhook(router, options, rawBody, headers);
+    return jsonResponse(body, status);
+  };
+}
+export {
+  WebhookRouter,
+  fetchAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  handleWebhook,\n  type WebhookDispatcher,\n  type WebhookEvent,\n  type WebhookHandlerOptions,\n} from '@kotodayori/core';\n\n/**\n * Options for the fetch adapter\n */\nexport type FetchAdapterOptions<T extends WebhookEvent = WebhookEvent> = WebhookHandlerOptions<T>;\n\nfunction jsonResponse(body: unknown, status: number, headers: Record<string, string> = {}): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'content-type': 'application/json', ...headers },\n  });\n}\n\n/**\n * Creates a Web-standard `(request: Request) => Promise<Response>` webhook handler\n *\n * Works anywhere the runtime hands you a standard `Request`: Cloudflare Workers,\n * Bun, Deno, Next.js App Router route handlers, React Router / Remix actions, etc.\n * The raw body is read with `request.text()` and passed to the verifier untouched.\n * Non-POST requests get `405 Method Not Allowed`, since the handler may be mounted\n * without a router in front of it.\n *\n * @example\n * ```typescript\n * import { fetchAdapter } from '@kotodayori/fetch';\n * import { createStripeVerifier, StripeWebhookRouter } from '@kotodayori/stripe';\n *\n * const router = new StripeWebhookRouter();\n * const handle = fetchAdapter(router, {\n *   verifier: createStripeVerifier(stripe, env.STRIPE_WEBHOOK_SECRET),\n * });\n *\n * // Cloudflare Workers / Bun / Deno\n * export default { fetch: handle };\n *\n * // Next.js App Router (app/webhook/route.ts)\n * export const POST = handle;\n *\n * // React Router v7 / Remix\n * export const action = ({ request }) => handle(request);\n * ```\n *\n * @param router - A WebhookDispatcher (any object with a `dispatch(event)` method, e.g. WebhookRouter)\n * @param options - Adapter options including a verifier function\n * @returns Fetch handler function\n */\nexport function fetchAdapter<\n  TEvent extends WebhookEvent = WebhookEvent,\n>(\n  router: WebhookDispatcher<TEvent>,\n  options: FetchAdapterOptions<TEvent>\n): (request: Request) => Promise<Response> {\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== 'POST') {\n      return jsonResponse({ error: 'Method not allowed' }, 405, { allow: 'POST' });\n    }\n\n    // Get raw body text for signature verification\n    const rawBody = await request.text();\n\n    const headers: Record<string, string> = {};\n    request.headers.forEach((value, key) => {\n      headers[key] = value;\n    });\n\n    const { status, body } = await handleWebhook(router, options, rawBody, headers);\n    return jsonResponse(body, status);\n  };\n}\n\n// Re-export core types\nexport { WebhookRouter, type WebhookDispatcher, type WebhookEvent, type EventHandler, type Middleware, type Verifier, type VerifyResult } from '@kotodayori/core';\n"],"mappings":";AAAA;AAAA,EACE;AAAA,OAIK;AAwEP,SAAS,qBAAsI;AAjE/I,SAAS,aAAa,MAAe,QAAgB,UAAkC,CAAC,GAAa;AACnG,SAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACxC;AAAA,IACA,SAAS,EAAE,gBAAgB,oBAAoB,GAAG,QAAQ;AAAA,EAC5D,CAAC;AACH;AAmCO,SAAS,aAGd,QACA,SACyC;AACzC,SAAO,OAAO,YAAwC;AACpD,QAAI,QAAQ,WAAW,QAAQ;AAC7B,aAAO,aAAa,EAAE,OAAO,qBAAqB,GAAG,KAAK,EAAE,OAAO,OAAO,CAAC;AAAA,IAC7E;AAGA,UAAM,UAAU,MAAM,QAAQ,KAAK;AAEnC,UAAM,UAAkC,CAAC;AACzC,YAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAQ;AACtC,cAAQ,GAAG,IAAI;AAAA,IACjB,CAAC;AAED,UAAM,EAAE,QAAQ,KAAK,IAAI,MAAM,cAAc,QAAQ,SAAS,SAAS,OAAO;AAC9E,WAAO,aAAa,MAAM,MAAM;AAAA,EAClC;AACF;","names":[]}

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@kotodayori/fetch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Web-standard fetch (Request/Response) adapter for Kotodayori Webhook Router",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@kotodayori/core": "^1.4.0"
+  },
+  "devDependencies": {
+    "stripe": "^23.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.8",
+    "@kotodayori/stripe": "^1.5.0"
+  },
+  "keywords": [
+    "webhook",
+    "router",
+    "fetch",
+    "cloudflare-workers",
+    "bun",
+    "deno",
+    "nextjs",
+    "react-router",
+    "typescript"
+  ],
+  "author": {
+    "name": "Hidetaka Okamoto",
+    "url": "https://github.com/hideokamoto"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hideokamoto/kotodayori.git",
+    "directory": "packages/fetch"
+  },
+  "homepage": "https://github.com/hideokamoto/kotodayori#readme",
+  "bugs": "https://github.com/hideokamoto/kotodayori/issues",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }