@gnosticdev/hono-actions 1.0.3 → 1.0.5

package/README.md

@@ -27,7 +27,7 @@ All other dependencies (`hono`, `valibot`, `@hono/valibot-validator`, etc.) are
 ```typescript
 // astro.config.ts
 import { defineConfig } from 'astro/config'
-import honoActions from '@gnosticdev/hono-actions'
+import honoActions from '@gnosticdev/hono-actions/integration'
 
 export default defineConfig({
   integrations: [
@@ -52,7 +52,7 @@ Create a file at one of these locations (the integration will auto-discover):
 
 ```typescript
 // src/server/actions.ts
-import { defineHonoAction, ActionError } from '@gnosticdev/hono-actions'
+import { defineHonoAction, HonoActionError } from '@gnosticdev/hono-actions'
 import * as v from 'valibot'
 
 // Define a simple action
@@ -88,7 +88,10 @@ export const errorAction = defineHonoAction({
   path: '/error',
   handler: async (input, ctx) => {
     if (someCondition) {
-      throw new ActionError('Custom error message', 'EXTERNAL_API_ERROR')
+      throw new HonoActionError({
+        message: 'Custom error message',
+        code: 'EXTERNAL_API_ERROR'
+      })
     }
     return { success: true }
   }
@@ -151,6 +154,17 @@ const handleSubmit = async (formData: FormData) => {
 }
 ```
 
+## Package Structure
+
+This package provides two main entry points:
+
+- **`@gnosticdev/hono-actions`** (default): Action definition utilities (`defineHonoAction`, `HonoActionError`, types)
+  - Safe for browser environments
+  - Used in your action files and client-side code
+- **`@gnosticdev/hono-actions/integration`**: Astro integration
+  - Uses Node.js built-ins (fs, path)
+  - Only used in `astro.config.ts`
+
 ## Configuration Options
 
 The integration accepts the following options:

package/dist/actions.d.ts

@@ -0,0 +1,138 @@
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_types from 'hono/utils/types';
+import * as hono_types from 'hono/types';
+import { Context } from 'hono';
+import * as v from 'valibot';
+
+interface Bindings {
+}
+/**
+ * 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`
+ */
+interface HonoEnv {
+    Bindings: Bindings;
+    Variables: Record<string, any>;
+}
+type HonoActionSchema = v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined> | v.NeverSchema<undefined>;
+interface HonoActionContext<TEnv extends HonoEnv, TPath extends string, TSchema extends HonoActionSchema> extends Context<TEnv, TPath, {
+    input: v.InferInput<TSchema>;
+    output: v.InferOutput<TSchema>;
+    outputFormat: 'json';
+}> {
+    env: TEnv['Bindings'];
+}
+type HonoActionParams<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv> = {
+    path: TPath;
+    schema?: TSchema;
+    handler: (params: v.InferOutput<TSchema>, context: HonoActionContext<TEnv, TPath, TSchema>) => Promise<TReturn>;
+};
+/**
+ * Defines a type-safe Hono action using Valibot for input validation.
+ *
+ * @param path - The path of the action.
+ * @param schema - The object schema for Valibot validation.
+ * @default never
+ * @param handler - The handler function for the action.
+ * @returns A Hono app instance with the defined route
+ */
+declare function defineHonoAction<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv>({ path, schema, handler }: HonoActionParams<TPath, TSchema, TReturn, TEnv>): hono_hono_base.HonoBase<TEnv, { [K in hono_types.MergePath<"/", TPath>]: {
+    $post: {
+        input: hono_types.AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_1 ? T_1 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_1 extends any ? T_1 : { [K2 in keyof T_1]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_2 ? T_2 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_2 extends any ? T_2 : { [K2_1 in keyof T_2]: any; } : never : never;
+        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_3 ? T_3 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_3 extends any ? T_3 : { [K2_2 in keyof T_3]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_4 ? T_4 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_4 extends any ? T_4 : { [K2_3 in keyof T_4]: any; } : never : never;
+        }, hono_types.MergePath<"/", TPath>>;
+        output: unknown extends ({
+            data: Awaited<TReturn>;
+            error: null;
+        } extends hono_utils_types.JSONValue ? { [K_2 in keyof {
+            data: Awaited<TReturn>;
+            error: null;
+        } as ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_5 ? T_5 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_5 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_6 ? T_6 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_6 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]> | undefined : hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]>; } : never) ? {} : {
+            data: Awaited<TReturn>;
+            error: null;
+        } extends hono_utils_types.JSONValue ? { [K_2 in keyof {
+            data: Awaited<TReturn>;
+            error: null;
+        } as ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_5 ? T_5 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_5 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] extends infer T_6 ? T_6 extends {
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2] ? T_6 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]> | undefined : hono_utils_types.JSONParsed<{
+            data: Awaited<TReturn>;
+            error: null;
+        }[K_2]>; } : never;
+        outputFormat: "json";
+        status: 200;
+    } | {
+        input: hono_types.AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_5 ? T_5 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_5 extends any ? T_5 : { [K2_4 in keyof T_5]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_6 ? T_6 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_6 extends any ? T_6 : { [K2_5 in keyof T_6]: any; } : never : never;
+        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
+            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_7 ? T_7 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_7 extends any ? T_7 : { [K2_6 in keyof T_7]?: any; } : never : never) | undefined;
+        } : {
+            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_8 ? T_8 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_8 extends any ? T_8 : { [K2_7 in keyof T_8]: any; } : never : never;
+        }, hono_types.MergePath<"/", TPath>>;
+        output: {
+            data: null;
+            error: {
+                message: string;
+                code: string;
+            };
+        };
+        outputFormat: "json";
+        status: 500;
+    };
+}; } extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never, "/">;
+
+/**
+ * Standard error codes for actions
+ */
+type ActionErrorCode = 'INPUT_VALIDATION_ERROR' | 'EXTERNAL_API_ERROR' | 'INTERNAL_SERVER_ERROR' | 'UNKNOWN_ERROR' | 'LOCATION_NOT_FOUND' | 'SESSION_NOT_FOUND';
+declare class HonoActionError<TSchema extends v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined>, TMessage extends string, TCode extends ActionErrorCode, TIssue extends v.InferIssue<TSchema>> extends Error {
+    code: TCode;
+    issue?: TIssue;
+    constructor({ message, code, issue }: {
+        message: TMessage;
+        code: TCode;
+        issue?: TIssue;
+    });
+}
+
+export { type ActionErrorCode, type Bindings, HonoActionError, type HonoEnv, defineHonoAction };

package/dist/actions.js

@@ -0,0 +1,88 @@
+// src/define-action.ts
+import { vValidator } from "@hono/valibot-validator";
+import { createFactory } from "hono/factory";
+import * as v from "valibot";
+
+// src/error.ts
+var HonoActionError = class extends Error {
+  code;
+  issue;
+  constructor({
+    message,
+    code,
+    issue
+  }) {
+    super(message);
+    this.name = "HonoActionError";
+    this.code = code;
+    this.issue = issue;
+  }
+};
+
+// src/define-action.ts
+function defineHonoAction({ path, schema, handler }) {
+  const factory = createFactory();
+  const app = factory.createApp();
+  const route = app.post(
+    path,
+    vValidator(
+      "json",
+      schema ?? v.union([v.never(), v.object({})]),
+      async (result, c) => {
+        if (!result.success) {
+          console.error(result.issues);
+          return c.json(
+            {
+              data: null,
+              error: new HonoActionError({
+                message: result.issues[0].message,
+                code: "INPUT_VALIDATION_ERROR",
+                issue: result.issues[0]
+              })
+            },
+            400
+          );
+        }
+      }
+    ),
+    async (c) => {
+      try {
+        const json = c.req.valid("json");
+        const result = await handler(
+          json,
+          c
+        );
+        return c.json(
+          {
+            data: result,
+            error: null
+          },
+          200
+        );
+      } catch (error) {
+        console.error(error);
+        let errorMessage = "Internal server error";
+        let errorCode = "INTERNAL_SERVER_ERROR";
+        if (error instanceof HonoActionError) {
+          errorMessage = error.message;
+          errorCode = error.code;
+        }
+        return c.json(
+          {
+            data: null,
+            error: {
+              message: errorMessage,
+              code: errorCode
+            }
+          },
+          500
+        );
+      }
+    }
+  );
+  return route;
+}
+export {
+  HonoActionError,
+  defineHonoAction
+};

package/dist/index.d.ts

@@ -1,144 +1,6 @@
-import * as hono_hono_base from 'hono/hono-base';
-import * as hono_utils_types from 'hono/utils/types';
-import * as hono_types from 'hono/types';
-import { Context } from 'hono';
-import * as v from 'valibot';
-import * as astro from 'astro';
-
-interface Bindings {
-}
-/**
- * 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`
- */
-interface HonoEnv {
-    Bindings: Bindings;
-    Variables: Record<string, any>;
-}
-type HonoActionSchema = v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined> | v.NeverSchema<undefined>;
-interface HonoActionContext<TEnv extends HonoEnv, TPath extends string, TSchema extends HonoActionSchema> extends Context<TEnv, TPath, {
-    input: v.InferInput<TSchema>;
-    output: v.InferOutput<TSchema>;
-    outputFormat: 'json';
-}> {
-    env: TEnv['Bindings'];
-}
-type HonoActionParams<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv> = {
-    path: TPath;
-    schema?: TSchema;
-    handler: (params: v.InferOutput<TSchema>, context: HonoActionContext<TEnv, TPath, TSchema>) => Promise<TReturn>;
-};
-/**
- * Defines a type-safe Hono action using Valibot for input validation.
- *
- * @param path - The path of the action.
- * @param schema - The object schema for Valibot validation.
- * @default never
- * @param handler - The handler function for the action.
- * @returns A Hono app instance with the defined route
- */
-declare function defineHonoAction<TPath extends string, TSchema extends HonoActionSchema, TReturn, TEnv extends HonoEnv = HonoEnv>({ path, schema, handler }: HonoActionParams<TPath, TSchema, TReturn, TEnv>): hono_hono_base.HonoBase<TEnv, { [K in hono_types.MergePath<"/", TPath>]: {
-    $post: {
-        input: hono_types.AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_1 ? T_1 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_1 extends any ? T_1 : { [K2 in keyof T_1]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_2 ? T_2 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_2 extends any ? T_2 : { [K2_1 in keyof T_2]: any; } : never : never;
-        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_3 ? T_3 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_3 extends any ? T_3 : { [K2_2 in keyof T_3]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_4 ? T_4 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_4 extends any ? T_4 : { [K2_3 in keyof T_4]: any; } : never : never;
-        }, hono_types.MergePath<"/", TPath>>;
-        output: unknown extends ({
-            data: Awaited<TReturn>;
-            error: null;
-        } extends hono_utils_types.JSONValue ? { [K_2 in keyof {
-            data: Awaited<TReturn>;
-            error: null;
-        } as ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_5 ? T_5 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_5 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_6 ? T_6 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_6 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]> | undefined : hono_utils_types.JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]>; } : never) ? {} : {
-            data: Awaited<TReturn>;
-            error: null;
-        } extends hono_utils_types.JSONValue ? { [K_2 in keyof {
-            data: Awaited<TReturn>;
-            error: null;
-        } as ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_5 ? T_5 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_5 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K_2]: boolean extends ({
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] extends infer T_6 ? T_6 extends {
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2] ? T_6 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]> | undefined : hono_utils_types.JSONParsed<{
-            data: Awaited<TReturn>;
-            error: null;
-        }[K_2]>; } : never;
-        outputFormat: "json";
-        status: 200;
-    } | {
-        input: hono_types.AddParam<unknown extends ((undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_5 ? T_5 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_5 extends any ? T_5 : { [K2_4 in keyof T_5]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_6 ? T_6 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_6 extends any ? T_6 : { [K2_5 in keyof T_6]: any; } : never : never;
-        }) ? {} : (undefined extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? true : false) extends true ? {
-            json?: (v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_7 ? T_7 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_7 extends any ? T_7 : { [K2_6 in keyof T_7]?: any; } : never : never) | undefined;
-        } : {
-            json: v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> extends infer T_8 ? T_8 extends v.InferInput<TSchema | v.UnionSchema<[v.NeverSchema<undefined>, v.ObjectSchema<{}, undefined>], undefined>> ? T_8 extends any ? T_8 : { [K2_7 in keyof T_8]: any; } : never : never;
-        }, hono_types.MergePath<"/", TPath>>;
-        output: {
-            data: null;
-            error: {
-                message: string;
-                code: string;
-            };
-        };
-        outputFormat: "json";
-        status: 500;
-    };
-}; } extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never, "/">;
-
-/**
- * Standard error codes for actions
- */
-type ActionErrorCode = 'INPUT_VALIDATION_ERROR' | 'EXTERNAL_API_ERROR' | 'INTERNAL_SERVER_ERROR' | 'UNKNOWN_ERROR' | 'LOCATION_NOT_FOUND' | 'SESSION_NOT_FOUND';
-declare class HonoActionError<TSchema extends v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined>, TMessage extends string, TCode extends ActionErrorCode, TIssue extends v.InferIssue<TSchema>> extends Error {
-    code: TCode;
-    issue?: TIssue;
-    constructor({ message, code, issue, }: {
-        message: TMessage;
-        code: TCode;
-        issue?: TIssue;
-    });
-}
-
-declare const _default: (options?: {
-    basePath?: string | undefined;
-    actionsPath?: string | undefined;
-} | undefined) => astro.AstroIntegration & {};
-
-export { type Bindings, HonoActionError, type HonoEnv, _default as default, defineHonoAction };
+export { ActionErrorCode, Bindings, HonoActionError, HonoEnv, defineHonoAction } from './actions.js';
+import 'hono/hono-base';
+import 'hono/utils/types';
+import 'hono/types';
+import 'hono';
+import 'valibot';

package/dist/index.js

@@ -20,11 +20,11 @@ var HonoActionError = class extends Error {
 };
 
 // src/define-action.ts
-function defineHonoAction({ path: path2, schema, handler }) {
+function defineHonoAction({ path, schema, handler }) {
   const factory = createFactory();
   const app = factory.createApp();
   const route = app.post(
-    path2,
+    path,
     vValidator(
       "json",
       schema ?? v.union([v.never(), v.object({})]),
@@ -82,225 +82,7 @@ function defineHonoAction({ path: path2, schema, handler }) {
   );
   return route;
 }
-
-// src/integration.ts
-import fs from "fs/promises";
-import path from "path";
-import { z } from "astro/zod";
-import {
-  addVirtualImports,
-  createResolver,
-  defineIntegration
-} from "astro-integration-kit";
-import fg from "fast-glob";
-
-// src/integration-files.ts
-function generateRouter(opts) {
-  const { basePath, relativeActionsPath } = opts;
-  return `import type { HonoEnv } from '@gnosticdev/hono-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'
-
-export async function buildRouter(){
-    type ActionSchema = ExtractSchema<typeof honoActions[keyof typeof honoActions]>
-    const { honoActions} = await import('${relativeActionsPath}')
-    const app = new Hono<HonoEnv, MergeSchemaPath<ActionSchema, '${basePath}'>>().basePath('${basePath}')
-
-    app.use('*', cors(), logger(), prettyJSON())
-
-    for (const [path, action] of Object.entries(honoActions)) {
-        app.route(path, action)
-    }
-
-    showRoutes(app)
-    return app
-}
-
-export type HonoRouter = Awaited<ReturnType<typeof buildRouter>>
-
-const app = await buildRouter()
-export default app`;
-}
-var getAstroHandler = (adapter) => {
-  switch (adapter) {
-    case "cloudflare":
-      return `
-// Generated by Hono Actions Integration
-import router from './router.js'
-import type { APIContext, APIRoute } from 'astro'
-
-const handler: APIRoute<APIContext> = async (ctx) => {
-    return router.fetch(
-        ctx.request,
-        ctx.locals.runtime.env,
-        ctx.locals.runtime.ctx,
-    )
-}
-
-export { handler as ALL }
-`;
-    default:
-      throw new Error(`Unsupported adapter: ${adapter}`);
-  }
-};
-var getHonoClient = (port) => `
-// Generated by Hono Actions Integration
-import type { HonoRouter } from './router.js'
-import { hc } from 'hono/client'
-
-export function getBaseUrl() {
-    // client side can just use the base path
-    if (typeof window !== 'undefined') {
-        return '/'
-    }
-
-    // dev server (dev server) needs to know the port
-    if (import.meta.env.DEV) {
-        return \`http://localhost:\${${port}}\`
-    }
-
-    // server side (production) needs full url
-    return import.meta.env.SITE
-}
-
-export const honoClient = hc<HonoRouter>(getBaseUrl())
-`;
-
-// src/lib/utils.ts
-var reservedRoutes = ["_astro", "_actions", "_server_islands"];
-
-// src/integration.ts
-var optionsSchema = z.object({
-  basePath: z.string().optional(),
-  actionsPath: z.string().optional()
-}).optional();
-var VIRTUAL_MODULE_ID_CLIENT = "@gnostic/hono-actions/client";
-var VIRTUAL_MODULE_ID_ROUTER = "virtual:hono-actions/router";
-var ACTION_PATTERNS = [
-  "src/**/server/actions.ts",
-  "src/**/hono/actions.ts",
-  "src/**/hono/index.ts",
-  "src/**/hono.ts"
-];
-var integration_default = defineIntegration({
-  name: "@gnostic/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);
-    return {
-      name,
-      hooks: {
-        "astro:config:setup": async (params) => {
-          const { logger, injectRoute, createCodegenDir, config } = params;
-          const root = config.root.pathname;
-          const files = await fg(ACTION_PATTERNS, {
-            cwd: root,
-            absolute: true
-          });
-          const actionsPath = options.actionsPath ?? files[0];
-          if (!actionsPath) {
-            throw new Error(
-              `No actions found. Create one of:
-${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
-            );
-          }
-          const resolvedActionsPath = path.isAbsolute(actionsPath) ? actionsPath : path.join(root, 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 routerContent = generateRouter({
-            basePath,
-            relativeActionsPath: relFromGenToActions
-          });
-          await fs.writeFile(routerPathAbs, routerContent, "utf-8");
-          const astroHandlerPathAbs = path.join(
-            codeGenDir.pathname,
-            "api.ts"
-          );
-          if (!params.config.adapter?.name)
-            throw new Error("No Astro adapter found");
-          const astroHandlerContent = getAstroHandler("cloudflare");
-          await fs.writeFile(
-            astroHandlerPathAbs,
-            astroHandlerContent,
-            "utf-8"
-          );
-          const clientPathAbs = path.join(
-            codeGenDir.pathname,
-            "client.ts"
-          );
-          const clientContent = getHonoClient(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}';`
-            }
-          });
-          injectRoute({
-            pattern: `${basePath}/[...slug]`,
-            entrypoint: astroHandlerPathAbs,
-            prerender: false
-          });
-          logger.info(
-            `\u2705 Hono Actions route mounted at ${basePath}/[...slug]`
-          );
-        },
-        "astro:config:done": async ({ injectTypes }) => {
-          injectTypes({
-            filename: "actions.d.ts",
-            content: `
-  declare module '@gnosticdev/hono-actions' {
-    interface Bindings extends Env { ASTRO_LOCALS: App.Locals }
-    interface HonoEnv { Bindings: Bindings }
-  }
-  export {}
-  `
-          });
-          injectTypes({
-            filename: "types.d.ts",
-            content: `
-  // Generated by Hono Actions Integration
-
-  declare module 'virtual:hono-actions/router' {
-    export type HonoRouter = import('./router.ts').HonoRouter
-    const app: typeof import('./router.ts').default
-    export default app
-  }
-
-  declare module '@gnostic/hono-actions/client' {
-    export const honoClient: typeof import('./client').honoClient
-  }
-  `
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/index.ts
-var index_default = integration_default;
 export {
   HonoActionError,
-  index_default as default,
   defineHonoAction
 };

package/dist/integration.d.ts

@@ -0,0 +1,20 @@
+import * as astro from 'astro';
+import { z } from 'astro/zod';
+
+declare const optionsSchema: z.ZodOptional<z.ZodObject<{
+    basePath: z.ZodOptional<z.ZodString>;
+    actionsPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    basePath?: string | undefined;
+    actionsPath?: string | undefined;
+}, {
+    basePath?: string | undefined;
+    actionsPath?: string | undefined;
+}>>;
+type IntegrationOptions = z.infer<typeof optionsSchema>;
+declare const _default: (options?: {
+    basePath?: string | undefined;
+    actionsPath?: string | undefined;
+} | undefined) => astro.AstroIntegration & {};
+
+export { type IntegrationOptions, _default as default };

package/dist/integration.js

@@ -0,0 +1,216 @@
+// src/integration.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "astro/zod";
+import {
+  addVirtualImports,
+  createResolver,
+  defineIntegration
+} from "astro-integration-kit";
+import fg from "fast-glob";
+
+// src/integration-files.ts
+function generateRouter(opts) {
+  const { basePath, relativeActionsPath } = opts;
+  return `import type { HonoEnv } from '@gnosticdev/hono-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'
+
+export async function buildRouter(){
+    type ActionSchema = ExtractSchema<typeof honoActions[keyof typeof honoActions]>
+    const { honoActions} = await import('${relativeActionsPath}')
+    const app = new Hono<HonoEnv, MergeSchemaPath<ActionSchema, '${basePath}'>>().basePath('${basePath}')
+
+    app.use('*', cors(), logger(), prettyJSON())
+
+    for (const [path, action] of Object.entries(honoActions)) {
+        app.route(path, action)
+    }
+
+    showRoutes(app)
+    return app
+}
+
+export type HonoRouter = Awaited<ReturnType<typeof buildRouter>>
+
+const app = await buildRouter()
+export default app`;
+}
+var getAstroHandler = (adapter) => {
+  switch (adapter) {
+    case "cloudflare":
+      return `
+// Generated by Hono Actions Integration
+import router from './router.js'
+import type { APIContext, APIRoute } from 'astro'
+
+const handler: APIRoute<APIContext> = async (ctx) => {
+    return router.fetch(
+        ctx.request,
+        ctx.locals.runtime.env,
+        ctx.locals.runtime.ctx,
+    )
+}
+
+export { handler as ALL }
+`;
+    default:
+      throw new Error(`Unsupported adapter: ${adapter}`);
+  }
+};
+var getHonoClient = (port) => `
+// Generated by Hono Actions Integration
+import type { HonoRouter } from './router.js'
+import { hc } from 'hono/client'
+
+export function getBaseUrl() {
+    // client side can just use the base path
+    if (typeof window !== 'undefined') {
+        return '/'
+    }
+
+    // dev server (dev server) needs to know the port
+    if (import.meta.env.DEV) {
+        return \`http://localhost:\${${port}}\`
+    }
+
+    // server side (production) needs full url
+    return import.meta.env.SITE
+}
+
+export const honoClient = hc<HonoRouter>(getBaseUrl())
+`;
+
+// src/lib/utils.ts
+var reservedRoutes = ["_astro", "_actions", "_server_islands"];
+
+// src/integration.ts
+var optionsSchema = z.object({
+  basePath: z.string().optional(),
+  actionsPath: z.string().optional()
+}).optional();
+var VIRTUAL_MODULE_ID_CLIENT = "@gnostic/hono-actions/client";
+var VIRTUAL_MODULE_ID_ROUTER = "virtual:hono-actions/router";
+var ACTION_PATTERNS = [
+  "src/**/server/actions.ts",
+  "src/**/hono/actions.ts",
+  "src/**/hono/index.ts",
+  "src/**/hono.ts"
+];
+var integration_default = defineIntegration({
+  name: "@gnostic/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);
+    return {
+      name,
+      hooks: {
+        "astro:config:setup": async (params) => {
+          const { logger, injectRoute, createCodegenDir, config } = params;
+          const root = config.root.pathname;
+          const files = await fg(ACTION_PATTERNS, {
+            cwd: root,
+            absolute: true
+          });
+          const actionsPath = options.actionsPath ?? files[0];
+          if (!actionsPath) {
+            throw new Error(
+              `No actions found. Create one of:
+${ACTION_PATTERNS.map((p) => ` - ${p}`).join("\n")}`
+            );
+          }
+          const resolvedActionsPath = path.isAbsolute(actionsPath) ? actionsPath : path.join(root, 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 routerContent = generateRouter({
+            basePath,
+            relativeActionsPath: relFromGenToActions
+          });
+          await fs.writeFile(routerPathAbs, routerContent, "utf-8");
+          const astroHandlerPathAbs = path.join(
+            codeGenDir.pathname,
+            "api.ts"
+          );
+          if (!params.config.adapter?.name)
+            throw new Error("No Astro adapter found");
+          const astroHandlerContent = getAstroHandler("cloudflare");
+          await fs.writeFile(
+            astroHandlerPathAbs,
+            astroHandlerContent,
+            "utf-8"
+          );
+          const clientPathAbs = path.join(
+            codeGenDir.pathname,
+            "client.ts"
+          );
+          const clientContent = getHonoClient(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}';`
+            }
+          });
+          injectRoute({
+            pattern: `${basePath}/[...slug]`,
+            entrypoint: astroHandlerPathAbs,
+            prerender: false
+          });
+          logger.info(
+            `\u2705 Hono Actions route mounted at ${basePath}/[...slug]`
+          );
+        },
+        "astro:config:done": async ({ injectTypes }) => {
+          injectTypes({
+            filename: "actions.d.ts",
+            content: `
+  declare module '@gnosticdev/hono-actions' {
+    interface Bindings extends Env { ASTRO_LOCALS: App.Locals }
+    interface HonoEnv { Bindings: Bindings }
+  }
+  export {}
+  `
+          });
+          injectTypes({
+            filename: "types.d.ts",
+            content: `
+  // Generated by Hono Actions Integration
+
+  declare module 'virtual:hono-actions/router' {
+    export type HonoRouter = import('./router.ts').HonoRouter
+    const app: typeof import('./router.ts').default
+    export default app
+  }
+
+  declare module '@gnostic/hono-actions/client' {
+    export const honoClient: typeof import('./client').honoClient
+  }
+  `
+          });
+        }
+      }
+    };
+  }
+});
+export {
+  integration_default as default
+};

package/package.json

@@ -8,24 +8,28 @@
     "astro-integration-kit": "^0.19.0",
     "fast-glob": "^3.3.3",
     "hono": "^4.9.4",
-    "release-it": "^19.0.4",
     "valibot": "^1.1.0"
   },
   "description": "Type-safe Hono server actions with build-in validation",
   "devDependencies": {
     "@biomejs/biome": "^2.2.2",
     "@types/bun": "^1.2.20",
+    "release-it": "^19.0.4",
     "tsup": "^8.5.0",
     "typescript": "5.9.2"
   },
-  "engineStrict": true,
   "engines": {
     "node": ">=22.0.0"
   },
+  "engineStrict": true,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/actions.d.ts",
+      "default": "./dist/actions.js"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.ts",
+      "default": "./dist/integration.js"
     },
     "./*": {
       "types": "./dist/*.d.ts",
@@ -43,7 +47,7 @@
     "server actions"
   ],
   "license": "MIT",
-  "main": "dist/index.js",
+  "main": "dist/actions.js",
   "name": "@gnosticdev/hono-actions",
   "packageManager": "bun@1.2.21",
   "peerDependencies": {
@@ -56,13 +60,13 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "prepublishOnly": "bun run build",
+    "publish": "bun run release",
     "release": "release-it",
-    "release:patch": "release-it patch",
-    "release:minor": "release-it minor",
     "release:major": "release-it major",
-    "publish": "bun run release"
+    "release:minor": "release-it minor",
+    "release:patch": "release-it patch"
   },
   "type": "module",
-  "types": "dist/index.d.ts",
-  "version": "1.0.3"
+  "types": "dist/actions.d.ts",
+  "version": "1.0.5"
 }