@gnosticdev/hono-actions 2.0.11 → 2.1.1

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+import z from "astro/zod";
+import * as _$astro from "astro";
+
+//#region src/integration.d.ts
+declare const optionsSchema: z.ZodOptional<z.ZodObject<{
+  basePath: z.ZodOptional<z.ZodString>;
+  actionsPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+type IntegrationOptions = z.output<typeof optionsSchema>;
+/**
+ * Astro integration for Hono Actions
+ *
+ * This integration automatically discovers action files in your project,
+ * generates type-safe client code, and sets up API routes.
+ *
+ * Supprted Adapters:
+ * - @astrojs/cloudflare
+ * - @astrojs/node
+ * - @astrojs/vercel
+ * - @astrojs/netlify
+ *
+ *
+ * @param options - Configuration options for the integration
+ * @param options.basePath - Base path for API routes (default: '/api')
+ * @param options.actionsPath - Custom path to actions file (optional, auto-discovered by default)
+ */
+declare const _default: (options?: {
+  basePath?: string | undefined;
+  actionsPath?: string | undefined;
+} | undefined) => _$astro.AstroIntegration & {};
+//#endregion
+export { type IntegrationOptions, _default as default };

package/dist/index.mjs

@@ -0,0 +1,418 @@
+import { createRequire } from "node:module";
+import z from "astro/zod";
+import { addVirtualImports, createResolver, defineIntegration } from "astro-integration-kit";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { glob } from "tinyglobby";
+
+//#region src/integration-files.ts
+/**
+* Generate router using the buildRouter pattern for better type inference
+* @param opts - The options for generating the router
+* @param opts.basePath - The base path for the router
+* @param opts.relativeActionsPath - The relative path to the actions file
+* @param opts.adapter - The adapter to use for generating the router
+* @returns The generated router code
+*
+* **Supported Adapters:**
+* - `@astrojs/cloudflare`
+* - `@astrojs/node`
+* - `@astrojs/vercel`
+* - `@astrojs/netlify`
+*/
+function generateRouter(opts) {
+	const { basePath, relativeActionsPath, adapter } = opts;
+	let exportedApp = "export default app";
+	if (adapter === "@astrojs/netlify") exportedApp = "export default handle(app)";
+	return `import type { HonoEnv, MergeActionKeyIntoPath } from '@gnosticdev/hono-actions/actions'
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { showRoutes } from 'hono/dev'
+import { logger } from 'hono/logger'
+import { prettyJSON } from 'hono/pretty-json'
+import type { ExtractSchema, MergeSchemaPath } from 'hono/types'
+${adapter === "@astrojs/netlify" ? "import { handle } from 'hono/netlify'" : ""}
+
+async function buildRouter(){
+    type ActionsWithKeyedPaths = MergeActionKeyIntoPath<typeof honoActions>
+    type ActionSchema = ExtractSchema<ActionsWithKeyedPaths[keyof ActionsWithKeyedPaths]>
+    const { honoActions} = await import('${relativeActionsPath}')
+    const app = new Hono<HonoEnv, MergeSchemaPath<ActionSchema, '${basePath}'>>().basePath('${basePath}')
+
+    app.use('*', cors(), logger(), prettyJSON())
+
+    for (const [routeName, action] of Object.entries(honoActions)) {
+        app.route(\`/\${routeName}\`, action)
+    }
+
+    return app
+}
+
+export type HonoRouter = Awaited<ReturnType<typeof buildRouter>>
+
+const app = await buildRouter()
+console.log('------- Hono Routes -------')
+showRoutes(app)
+console.log('---------------------------')
+${exportedApp}`;
+}
+/**
+* Injects the Hono router into the Astro API route handler at `src/pages/api/[...slug].ts`
+*
+* @param adapter - The adapter in use from the astro config
+*
+* For use with `@astrojs/cloudflare` adapter only (for now).a
+*/
+const generateAstroHandler = (adapter, astroMajorVersion = 5) => {
+	switch (adapter) {
+		case "@astrojs/cloudflare":
+			if (astroMajorVersion >= 6) return `
+/// <reference types="./types.d.ts" />
+// Generated by Hono Actions Integration
+// adapter: ${adapter}
+import { env } from 'cloudflare:workers'
+import type { APIContext, APIRoute } from 'astro'
+import router from './router.js'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return router.fetch(
+        ctx.request,
+        {
+            ...env,
+            ASTRO_LOCALS: ctx.locals,
+        },
+        ctx.locals.cfContext,
+    )
+}
+
+export { handler as ALL }
+`;
+			return `
+/// <reference types="./types.d.ts" />
+// Generated by Hono Actions Integration
+// adapter: ${adapter}
+import type { APIContext, APIRoute } from 'astro'
+import router from './router.js'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return router.fetch(
+        ctx.request,
+        {
+            ...ctx.locals.runtime.env,
+            ASTRO_LOCALS: ctx.locals,
+        },
+        ctx.locals.runtime.ctx, // required for cloudflare adapter
+    )
+}
+
+export { handler as ALL }
+`;
+		case "@astrojs/node":
+		case "@astrojs/vercel": return `
+/// <reference types="./types.d.ts" />
+// Generated by Hono Actions Integration
+// adapter: ${adapter}
+import type { APIContext, APIRoute } from 'astro'
+import router from './router.js'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return router.fetch(
+        ctx.request,
+    )
+}
+
+export { handler as ALL }
+`;
+		case "@astrojs/netlify": return `
+/// <reference types="./types.d.ts" />
+// Generated by Hono Actions Integration
+// adapter: ${adapter}
+import type { APIContext, APIRoute } from 'astro'
+import netlifyHandler from './router.js'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return netlifyHandler(ctx.request, ctx)
+}
+
+export { handler as ALL }
+`;
+		default: throw new Error(`Unsupported adapter: ${adapter}`);
+	}
+};
+/**
+* Generate Hono client code
+*
+* @param port - The port number for the dev server
+*/
+const generateHonoClient = (port) => `
+// Generated by Hono Actions Integration
+import type { HonoRouter } from './router.js'
+import { parseResponse, hc } from 'hono/client'
+import type { DetailedError, ClientRequestOptions } from 'hono/client'
+
+function getBaseUrl() {
+    // client side can just use the origin
+    if (typeof window !== 'undefined') {
+        return window.location.origin
+    }
+
+    // dev server (dev server) needs to know the port
+    if (import.meta.env.DEV) {
+        return 'http://localhost:${port}'
+    }
+
+    // server side (production) needs full url
+    if (import.meta.env.SITE) {
+        return import.meta.env.SITE
+    }
+
+    return '/'
+}
+
+export { parseResponse }
+export type { DetailedError, ClientRequestOptions, HonoRouter }
+export const honoClient = createHonoClient<HonoRouter>(getBaseUrl())
+export function createHonoClient<T extends HonoRouter = HonoRouter>(basePath: string, fetchOptions?: ClientRequestOptions) {
+    return hc<T>(basePath, fetchOptions)
+}
+`;
+/**
+* Emits `actions.d.ts` / client module declarations for the active adapter.
+*
+* For `@astrojs/cloudflare` on Astro 5 and below, appends `App.Locals` + `Runtime` so `ASTRO_LOCALS` matches
+* `ctx.locals`. From Astro 6 onward the Cloudflare adapter already declares `App.Locals`, so that block is omitted.
+*/
+const generateIntegrationTypes = (adapter, astroMajorVersion = 5) => {
+	let actionTypes = `
+    // Generated by Hono Actions Integration
+    declare module '@gnosticdev/hono-actions/actions' {
+        interface Bindings { [key: string]: unknown }
+        interface Variables { [key: string]: unknown }
+        interface HonoEnv { Bindings: Bindings, Variables: Variables }
+    }
+    export {}
+    `;
+	let clientTypes = `
+// Generated by Hono Actions Integration
+declare module '@gnosticdev/hono-actions/client' {
+    /**
+     * Default hono client using the base url from the environment
+     * **Note** if running in production, the \`siteUrl\` option from the astro config will be used.
+     * If customization is needed, use the \`createHonoClient\` function instead.
+     */
+    export const honoClient: typeof import('./client').honoClient
+    /**
+     * Helper function to parse the response from the Hono client
+     */
+    export const parseResponse: typeof import('./client').parseResponse
+    /**
+     * Create a new hono client with custom base url + fetch options
+     */
+    export const createHonoClient: typeof import('./client').createHonoClient
+    export type DetailedError = import('./client').DetailedError
+    export type ClientRequestOptions = import('./client').ClientRequestOptions
+    /**
+     * The hono actions routes. for use in the hono client
+     */
+    export type HonoRouter = import('./client').HonoRouter
+}
+`;
+	switch (adapter) {
+		case "@astrojs/cloudflare":
+			actionTypes = `
+// Generated by Hono Actions Integration
+// keeping separate from the main types.d.ts to avoid clobbering package exports
+declare module '@gnosticdev/hono-actions/actions' {
+    interface Bindings extends Env { ASTRO_LOCALS: App.Locals }
+    interface Variables { [key: string]: unknown }
+    interface HonoEnv { Bindings: Bindings, Variables: Variables }
+}
+export {}
+`;
+			if (astroMajorVersion < 6) clientTypes += `
+type Runtime = import('@astrojs/cloudflare').Runtime<Env>
+
+declare namespace App {
+    interface Locals extends Runtime {}
+}
+`;
+			break;
+		default: break;
+	}
+	return {
+		actionTypes,
+		clientTypes
+	};
+};
+
+//#endregion
+//#region src/lib/utils.ts
+/**
+* Reserved routes that are not allowed to be used for actions.
+* @see https://docs.astro.build/en/guides/routing/#reserved-routes
+*/
+const reservedRoutes = [
+	"_astro",
+	"_actions",
+	"_server_islands"
+];
+const SUPPORTED_ADAPTERS = [
+	"@astrojs/cloudflare",
+	"@astrojs/node",
+	"@astrojs/netlify",
+	"@astrojs/vercel"
+];
+function isSupportedAdapter(adapter) {
+	return SUPPORTED_ADAPTERS.includes(adapter);
+}
+function parseAstroMajorVersion(version) {
+	const majorVersion = Number.parseInt(version, 10);
+	if (Number.isNaN(majorVersion)) if (process.env.PACKAGE_VERSION) return Number.parseInt(process.env.PACKAGE_VERSION, 10);
+	else throw new Error(`Invalid Astro version: ${version}`);
+	return majorVersion;
+}
+function getInstalledAstroVersion() {
+	const astroPackage = createRequire(import.meta.url)("astro/package.json");
+	if (!astroPackage.version) throw new Error("Could not determine installed Astro version");
+	return astroPackage.version;
+}
+function getInstalledAstroMajorVersion() {
+	return parseAstroMajorVersion(getInstalledAstroVersion());
+}
+
+//#endregion
+//#region src/integration.ts
+const optionsSchema = z.object({
+	basePath: z.string().optional(),
+	actionsPath: z.string().optional()
+}).optional();
+const VIRTUAL_MODULE_ID_CLIENT = "@gnosticdev/hono-actions/client";
+const VIRTUAL_MODULE_ID_ROUTER = "virtual:hono-actions/router";
+const ACTION_PATTERNS = [
+	"src/server/actions.ts",
+	"src/hono/actions.ts",
+	"src/hono/index.ts",
+	"src/hono.ts",
+	"src/hono-actions.ts"
+];
+/**
+* Astro integration for Hono Actions
+*
+* This integration automatically discovers action files in your project,
+* generates type-safe client code, and sets up API routes.
+*
+* Supprted Adapters:
+* - @astrojs/cloudflare
+* - @astrojs/node
+* - @astrojs/vercel
+* - @astrojs/netlify
+*
+*
+* @param options - Configuration options for the integration
+* @param options.basePath - Base path for API routes (default: '/api')
+* @param options.actionsPath - Custom path to actions file (optional, auto-discovered by default)
+*/
+var integration_default = defineIntegration({
+	name: "@gnosticdev/hono-actions",
+	optionsSchema,
+	setup: ({ options = {}, name }) => {
+		const basePath = options.basePath ?? "/api";
+		if (reservedRoutes.includes(basePath)) throw new Error(`Base path ${basePath} is reserved by Astro; pick another (e.g. /api2).`);
+		const { resolve } = createResolver(import.meta.url);
+		const IS_DEBUG = process.env.__DEBUG__ === "true";
+		const astroMajorVersion = getInstalledAstroMajorVersion();
+		return {
+			name,
+			hooks: {
+				"astro:config:setup": async (params) => {
+					const { logger, injectRoute, createCodegenDir, config } = params;
+					logger.info(`using astro major version: ${astroMajorVersion}`);
+					const root = config.root.pathname;
+					const files = await glob(ACTION_PATTERNS.map((p) => path.join(root, p)), {
+						expandDirectories: false,
+						absolute: true
+					});
+					if (IS_DEBUG) {
+						logger.info(`DEBUG: Detected Astro major version: ${astroMajorVersion}`);
+						logger.info(`DEBUG: Found actions: ${files.join("\n")}`);
+					}
+					const actionsPath = options.actionsPath ?? files[0];
+					if (!actionsPath || actionsPath.includes("node_modules")) {
+						logger.warn(`No actions found. Create one of:\n${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`);
+						return;
+					}
+					const resolvedActionsPath = resolve(actionsPath);
+					params.addWatchFile(resolvedActionsPath);
+					logger.info(`Found actions: ${path.relative(root, resolvedActionsPath)}`);
+					const codeGenDir = createCodegenDir();
+					const routerPathAbs = path.join(codeGenDir.pathname, "router.ts");
+					const relFromGenToActions = path.relative(codeGenDir.pathname, resolvedActionsPath).split(path.sep).join("/");
+					const adapter = params.config.adapter?.name;
+					if (!adapter) {
+						logger.error(`No Astro adapter found. Add one of:
+                                - ${SUPPORTED_ADAPTERS.join("\n - ")} to your astro.config.mjs`);
+						return;
+					}
+					if (!isSupportedAdapter(adapter)) {
+						logger.error(`Unsupported adapter: ${adapter}. Only ${SUPPORTED_ADAPTERS.join("\n - ")} are supported`);
+						return;
+					}
+					const routerContent = generateRouter({
+						basePath,
+						relativeActionsPath: relFromGenToActions,
+						adapter
+					});
+					await fs.writeFile(routerPathAbs, routerContent, "utf-8");
+					const astroHandlerPathAbs = path.join(codeGenDir.pathname, "api.ts");
+					const astroHandlerContent = generateAstroHandler(adapter, astroMajorVersion);
+					await fs.writeFile(astroHandlerPathAbs, astroHandlerContent, "utf-8");
+					const clientPathAbs = path.join(codeGenDir.pathname, "client.ts");
+					if (!config.site) logger.warn("No site url found in astro config, add one if you want to use the hono client with SSR");
+					const clientContent = generateHonoClient(config.server.port);
+					await fs.writeFile(clientPathAbs, clientContent, "utf-8");
+					addVirtualImports(params, {
+						name,
+						imports: {
+							[VIRTUAL_MODULE_ID_CLIENT]: `export * from '${clientPathAbs}';`,
+							[VIRTUAL_MODULE_ID_ROUTER]: `export * from '${routerPathAbs}';`
+						}
+					});
+					logger.info("✅ Hono Actions virtual imports added");
+					injectRoute({
+						pattern: `${basePath}/[...slug]`,
+						entrypoint: astroHandlerPathAbs,
+						prerender: false
+					});
+					logger.info(`✅ Hono Actions route mounted at ${basePath}/[...slug]`);
+				},
+				"astro:config:done": async ({ injectTypes, config, logger }) => {
+					const adapter = config.adapter?.name;
+					if (!adapter) {
+						logger.warn("No adapter found...");
+						return;
+					}
+					if (!isSupportedAdapter(adapter)) {
+						logger.warn(`Unsupported adapter: ${adapter}. Only ${SUPPORTED_ADAPTERS.join("\n - ")} are supported`);
+						return;
+					}
+					const { actionTypes, clientTypes } = generateIntegrationTypes(adapter, astroMajorVersion);
+					injectTypes({
+						filename: "actions.d.ts",
+						content: actionTypes
+					});
+					injectTypes({
+						filename: "types.d.ts",
+						content: clientTypes
+					});
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/index.ts
+var src_default = integration_default;
+
+//#endregion
+export { src_default as default };

package/package.json

@@ -5,8 +5,8 @@
   },
   "dependencies": {
     "@hono/standard-validator": "^0.2.0",
-    "@hono/zod-validator": "^0.2.2",
-    "astro-integration-kit": "^0.19.0",
+    "@hono/zod-validator": "^0.7.6",
+    "astro-integration-kit": "^0.20.0",
     "tinyglobby": "^0.2.15"
   },
   "description": "Define server actions with built-in validation, error handling, and a pre-built hono client for calling the routes.",
@@ -16,19 +16,15 @@
     "@astrojs/node": "catalog:",
     "@astrojs/vercel": "catalog:",
     "@biomejs/biome": "catalog:",
+    "@standard-schema/spec": "^1.1.0",
     "astro": "catalog:",
-    "tsup": "^8.5.0",
+    "tsdown": "^0.21.7",
     "typescript": "catalog:"
   },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
-    }
+    ".": "./dist/index.mjs",
+    "./actions": "./dist/actions.mjs",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist"
@@ -45,21 +41,26 @@
     "cloudflare"
   ],
   "license": "MIT",
-  "main": "./dist/index.js",
   "name": "@gnosticdev/hono-actions",
   "peerDependencies": {
-    "astro": "^5.13.0",
+    "astro": "^5.13.0 || ^6.0.0",
     "hono": "^4.10.6"
   },
+  "optionalDependencies": {
+    "zod": "^4.3.6"
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "typecheck": "tsc --noEmit"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "2.0.11"
+  "version": "2.1.1",
+  "inlinedDependencies": {
+    "@standard-schema/spec": "1.1.0"
+  }
 }

package/dist/actions.d.ts

@@ -1,160 +0,0 @@
-import * as hono_hono_base from 'hono/hono-base';
-import * as hono_utils_types from 'hono/utils/types';
-import { z } from 'astro/zod';
-import { Hono, Context } from 'hono';
-import { MergeSchemaPath } from 'hono/types';
-
-/**
- * Standard error codes for actions
- */
-type ActionErrorCode = 'INPUT_VALIDATION_ERROR' | 'EXTERNAL_API_ERROR' | 'INTERNAL_SERVER_ERROR' | 'UNKNOWN_ERROR' | 'LOCATION_NOT_FOUND' | 'SESSION_NOT_FOUND' | (string & {});
-declare class HonoActionError<TMessage extends string, TCode extends ActionErrorCode, TIssue = any> extends Error {
-    code: TCode;
-    issue?: TIssue;
-    constructor({ message, code, issue, }: {
-        message: TMessage;
-        code: TCode;
-        issue?: TIssue;
-    });
-}
-
-interface Bindings {
-}
-interface Variables {
-    /** Variables */
-    [key: string]: unknown;
-}
-/**
- * HonoEnv is passed to the Hono context to provide types on `ctx.env`.
- *
- * We are using `HonoEnv` to avoid confusion with the Cloudflare types on `Env` -> which cooresponds to `Bindings`
- *
- *  * **NOTE** For Cloudflare users, you can declare this in your src/env.d.ts file to get strong
- *  typing for `ctx.env`.
- *
- * ```ts
- * declare namespace App {
- *   interface Locals extends Runtime {}
- * }
- * ```
- */
-interface HonoEnv {
-    Bindings: Bindings;
-    Variables: Variables;
-}
-type HonoActionSchema = z.ZodType<any, z.ZodTypeDef, any>;
-/**
- * Merge each action key into its route path.
- *
- * Given a map of actions where each `Hono` app defines handlers at `"/"`, this
- * transforms the schema so each action's path becomes `"/${key}"`.
- *
- * Example:
- * ```ts
- * const honoActions: {
- *   myAction: Hono<HonoEnv, { '/': { $post: any } }, '/'>
- *   anotherAction: Hono<HonoEnv, { '/': { $post: any } }, '/'>
- * }
- *
- * type ActionsWithKeyedPaths = MergeActionKeyIntoPath<typeof honoActions>
- * // => {
- * //   myAction: Hono<HonoEnv, { '/myAction': { $post: any } }, '/'>
- * //   anotherAction: Hono<HonoEnv, { '/anotherAction': { $post: any } }, '/'>
- * // }
- * ```
- */
-type MergeActionKeyIntoPath<TActions extends Record<string, Hono<any, any, any>>> = {
-    [K in keyof TActions]: TActions[K] extends Hono<infer TEnv, infer TSchema, infer TBase> ? Hono<TEnv, MergeSchemaPath<TSchema, `/${Extract<K, string>}`>, TBase> : never;
-};
-type HonoActionParams<TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv, TContext extends Context<TEnv, any, any>> = {
-    schema?: TSchema;
-    handler: (params: z.output<TSchema>, context: TContext extends infer Ctx ? Ctx : never) => Promise<TReturn>;
-};
-/**
- * Defines a POST route with Zod validation for the request body.
- *
- * @param schema - The Zod schema for validation (optional).
- * @param handler - The handler function for the action.
- * @returns A Hono app instance with the defined route
- */
-declare function defineHonoAction<TEnv extends HonoEnv, TSchema extends HonoActionSchema, TReturn, TContext extends Context<TEnv, any, any>>({ schema, handler }: HonoActionParams<TSchema, TReturn, TEnv, TContext>): hono_hono_base.HonoBase<TEnv, {
-    "/": {
-        $post: {
-            input: unknown extends ((undefined extends z.input<TSchema> ? true : false) extends true ? {
-                json?: z.input<TSchema> | undefined;
-            } : {
-                json: z.input<TSchema>;
-            }) ? {} : (undefined extends z.input<TSchema> ? true : false) extends true ? {
-                json?: z.input<TSchema> | undefined;
-            } : {
-                json: z.input<TSchema>;
-            };
-            output: {
-                data: null;
-                error: {
-                    message: string;
-                    code: string;
-                };
-            };
-            outputFormat: "json";
-            status: 500;
-        } | {
-            input: unknown extends ((undefined extends z.input<TSchema> ? true : false) extends true ? {
-                json?: z.input<TSchema> | undefined;
-            } : {
-                json: z.input<TSchema>;
-            }) ? {} : (undefined extends z.input<TSchema> ? true : false) extends true ? {
-                json?: z.input<TSchema> | undefined;
-            } : {
-                json: z.input<TSchema>;
-            };
-            output: unknown extends (Awaited<TReturn> | null extends bigint | readonly bigint[] ? never : { [K in keyof {
-                data: Awaited<TReturn>;
-                error: null;
-            } as ({
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] extends infer T ? T extends {
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] ? T extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K]: boolean extends ({
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] extends infer T_1 ? T_1 extends {
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] ? T_1 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
-                data: Awaited<TReturn>;
-                error: null;
-            }[K], bigint | readonly bigint[]> | undefined : hono_utils_types.JSONParsed<{
-                data: Awaited<TReturn>;
-                error: null;
-            }[K], bigint | readonly bigint[]>; }) ? {} : Awaited<TReturn> | null extends bigint | readonly bigint[] ? never : { [K in keyof {
-                data: Awaited<TReturn>;
-                error: null;
-            } as ({
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] extends infer T ? T extends {
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] ? T extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K]: boolean extends ({
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] extends infer T_1 ? T_1 extends {
-                data: Awaited<TReturn>;
-                error: null;
-            }[K] ? T_1 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
-                data: Awaited<TReturn>;
-                error: null;
-            }[K], bigint | readonly bigint[]> | undefined : hono_utils_types.JSONParsed<{
-                data: Awaited<TReturn>;
-                error: null;
-            }[K], bigint | readonly bigint[]>; };
-            outputFormat: "json";
-            status: 200;
-        };
-    };
-}, "/", "/">;
-
-export { type Bindings, HonoActionError, type HonoEnv, type MergeActionKeyIntoPath, type Variables, defineHonoAction };