@onderwijsin/nuxt-turnstile 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stichting Onderwijs in
+
+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

@@ -0,0 +1,139 @@
+# @onderwijsin/nuxt-turnstile
+
+Nuxt 4 integration for action-aware Cloudflare Turnstile protection. The module registers
+`@nuxtjs/turnstile` and `@nuxt/ui`, exposes the auto-imported `useTurnstile()` composable, and
+provides server helpers for validating single-use Turnstile tokens before a protected operation.
+
+## Installation and configuration
+
+```sh
+pnpm add @onderwijsin/nuxt-turnstile
+```
+
+```ts
+export default defineNuxtConfig({
+  modules: ["@onderwijsin/nuxt-turnstile"],
+  turnstile: {
+    siteKey: process.env.TURNSTILE_SITE_KEY ?? "",
+    secretKey: process.env.TURNSTILE_SECRET_KEY ?? ""
+  }
+});
+```
+
+The module's options are:
+
+| Option            | Default           | Purpose                                           |
+| ----------------- | ----------------- | ------------------------------------------------- |
+| `enabled`         | `true`            | Enables or disables module setup                  |
+| `siteKey`         | `""`              | Public key used by the Turnstile widget           |
+| `secretKey`       | `""`              | Server-only key used for verification             |
+| `adminToken`      | `""`              | Optional trusted token that bypasses verification |
+| `adminHeaderName` | `"x-admin-token"` | Header accepted for `adminToken`                  |
+
+`siteKey` is public and is also passed to `@nuxtjs/turnstile`. Keep `secretKey` and `adminToken`
+private. In production, prefer `NUXT_TURNSTILE_SECRET_KEY` for the private runtime value. The
+module's dependency registration also requires the consuming app's normal Nuxt UI stylesheet setup.
+
+## Protecting a form
+
+Render `NuxtTurnstile`, choose a stable action for the operation, wait for a token, and forward it
+in `x-turnstile-token`. `useTurnstile()` is auto-imported and provides token lifecycle helpers plus
+Nuxt UI toast feedback.
+
+```vue
+<script setup lang="ts">
+import { TURNSTILE_TOKEN_HEADER } from "@onderwijsin/nuxt-turnstile/runtime";
+
+const token = ref<string>();
+const widget = useTemplateRef<{ reset: () => void }>("turnstile");
+const { getTokenWithRetry, isEnabled, showMissingTokenErrorHint, captureTurnstileError } =
+  useTurnstile();
+
+async function onSubmit() {
+  const currentToken = await getTokenWithRetry();
+  if (isEnabled.value && !currentToken) {
+    showMissingTokenErrorHint();
+    return;
+  }
+
+  try {
+    await $fetch("/api/user/session", {
+      method: "POST",
+      body: { email: "user@example.com" },
+      headers: currentToken ? { [TURNSTILE_TOKEN_HEADER]: currentToken } : undefined
+    });
+  } catch (error) {
+    if (!captureTurnstileError(error)) throw error;
+  } finally {
+    widget.value?.reset();
+  }
+}
+</script>
+
+<template>
+  <form @submit.prevent="onSubmit">
+    <NuxtTurnstile
+      ref="turnstile"
+      v-model="token"
+      :options="{ action: 'magic-link', appearance: 'interaction-only' }"
+    />
+    <UButton type="submit" label="Send magic link" />
+  </form>
+</template>
+```
+
+Use `getToken()` when the widget is already ready, or `getTokenWithRetry()` when submission may race
+with widget initialization. Reset the widget after every processed submission because Turnstile
+tokens are single-use.
+
+## Protecting a server route
+
+Call `assertTurnstileToken` before application validation, persistence, delivery, or other protected
+work. The expected action must match the widget action.
+
+```ts
+import { z } from "zod";
+import { assertTurnstileToken } from "@onderwijsin/nuxt-turnstile/runtime";
+
+export default defineEventHandler(async (event) => {
+  await assertTurnstileToken(event, "magic-link");
+  const body = await readValidatedBody(event, z.object({ email: z.email() }).parse);
+
+  return await sendMagicLink(body.email);
+});
+```
+
+The helper reads `x-turnstile-token` and verifies it through `@nuxtjs/turnstile`. It rejects
+missing, failed, unavailable, or mismatched-action tokens. In development, an absent secret leaves
+local forms usable; in production, it produces `TURNSTILE_SERVER_MISCONFIGURED`.
+
+## Trusted administrator bypass
+
+Configure `adminToken` for trusted server-to-server or administrative requests. The configured
+`adminHeaderName` and `Authorization: Bearer <token>` are both accepted. This bypass is checked
+before Turnstile verification; do not expose the token in public runtime config, client code, logs,
+or application aliases.
+
+## Runtime exports
+
+The `@onderwijsin/nuxt-turnstile/runtime` subpath is the explicit runtime API and does not require
+loading the Nuxt module entrypoint. It exports:
+
+- `TURNSTILE_TOKEN_HEADER` (`"x-turnstile-token"`)
+- `assertTurnstileToken`
+- `createTurnstileError`
+- `createTurnstileErrorData`
+- `isErrorWithStatusCode`
+- `TurnstileErrorCode` and `TurnstileErrorData` types
+
+Stable error codes are `TURNSTILE_TOKEN_MISSING`, `TURNSTILE_VALIDATION_FAILED`,
+`TURNSTILE_ACTION_MISMATCH`, `TURNSTILE_VALIDATION_UNAVAILABLE`, and
+`TURNSTILE_SERVER_MISCONFIGURED`. Apply authorization and business validation in the consuming route
+after Turnstile succeeds; the module does not replace the route's existing submit or business logic.
+
+## Compatibility
+
+- Nuxt 4
+- Node.js 22+
+- Node and Cloudflare Workers-compatible server runtime
+- No Sentry dependency or telemetry is included

package/dist/module.d.mts

@@ -0,0 +1,19 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    /** Whether the module is enabled. @default true */
+    enabled?: boolean;
+    /** Public site key consumed by the Turnstile widget. @default "" */
+    siteKey?: string;
+    /** Secret key used by server-side Turnstile verification. @default "" */
+    secretKey?: string;
+    /** Optional administrator token that bypasses Turnstile verification. @default "" */
+    adminToken?: string;
+    /** Header accepted for the administrator token. @default "x-admin-token" */
+    adminHeaderName?: string;
+}
+
+/** Registers shared Turnstile configuration, client helpers, and server validation. */
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@onderwijsin/nuxt-turnstile",
+  "configKey": "turnstile",
+  "version": "0.2.0",
+  "compatibility": {
+    "nuxt": "^4.0.0"
+  },
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,149 @@
+import { defineNuxtModule, useLogger, createResolver, addTypeTemplate, addImportsDir, addServerScanDir } from '@nuxt/kit';
+import { defu } from 'defu';
+import { z } from 'zod';
+
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) {
+    return void 0;
+  }
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = STR_SPLITTERS;
+  const parts = [];
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join("-") : "";
+}
+var enabled = z.boolean().default(true);
+function resolveModuleName(moduleKey) {
+  return `@onderwijsin/nuxt-${kebabCase(moduleKey)}`;
+}
+function resolveLoggerScope(moduleKey) {
+  return kebabCase(moduleKey);
+}
+function transpileRuntime(nuxt, runtimeDir) {
+  nuxt.options.build.transpile.push(runtimeDir);
+}
+function moduleSetup(MODULE_NAME, options, log) {
+  const start = () => log.start(`Loading module ${MODULE_NAME}`);
+  const end = () => log.success(`Module ${MODULE_NAME} Loaded`);
+  const isEnabled = () => {
+    if ("enabled" in options && options.enabled === false) {
+      log.info(`Module ${MODULE_NAME} is disabled. Skipping setup...`);
+      return false;
+    }
+    return true;
+  };
+  return { start, end, isEnabled };
+}
+function validateModuleOptions(options, schema, log) {
+  const result = schema.safeParse(options);
+  if (result.success) {
+    return result.data;
+  }
+  log.info(z.prettifyError(result.error));
+  throw new Error("Invalid module options \u261D. Exiting.");
+}
+
+const version = "0.2.0";
+
+const turnstileOptionsSchema = z.object({
+  enabled,
+  siteKey: z.string(),
+  secretKey: z.string(),
+  adminToken: z.string(),
+  adminHeaderName: z.string().min(1)
+});
+
+const MODULE_KEY = "turnstile";
+const MODULE_NAME = resolveModuleName(MODULE_KEY);
+const DEFAULTS = {
+  enabled: true,
+  siteKey: "",
+  secretKey: "",
+  adminToken: "",
+  adminHeaderName: "x-admin-token"
+};
+const module$1 = defineNuxtModule({
+  meta: {
+    name: MODULE_NAME,
+    configKey: MODULE_KEY,
+    version,
+    compatibility: { nuxt: "^4.0.0" }
+  },
+  defaults: DEFAULTS,
+  moduleDependencies: {
+    "@nuxt/ui": { version: ">=4.0.0" },
+    "@nuxtjs/turnstile": { version: ">=1.1.3" }
+  },
+  setup(rawOptions, nuxt) {
+    const log = useLogger(resolveLoggerScope(MODULE_KEY));
+    const { start, end, isEnabled } = moduleSetup(MODULE_NAME, rawOptions, log);
+    start();
+    const options = validateModuleOptions(rawOptions, turnstileOptionsSchema, log);
+    const resolver = createResolver(import.meta.url);
+    const runtimeDir = resolver.resolve("./runtime");
+    addTypeTemplate({
+      filename: "types/turnstile-config.d.ts",
+      src: resolver.resolve(runtimeDir, "types/config.d.ts")
+    });
+    if (!isEnabled()) return;
+    nuxt.options.runtimeConfig.turnstile = defu(nuxt.options.runtimeConfig.turnstile, {
+      secretKey: options.secretKey,
+      adminToken: options.adminToken,
+      adminHeaderName: options.adminHeaderName
+    });
+    nuxt.options.runtimeConfig.public.turnstile = defu(
+      nuxt.options.runtimeConfig.public.turnstile,
+      {
+        siteKey: options.siteKey
+      }
+    );
+    if (!nuxt.options.turnstile) {
+      nuxt.options.turnstile = {};
+    }
+    nuxt.options.turnstile.siteKey ??= options.siteKey;
+    transpileRuntime(nuxt, runtimeDir);
+    addImportsDir(resolver.resolve(runtimeDir, "app", "composables"));
+    addServerScanDir(resolver.resolve(runtimeDir, "server"));
+    end();
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/app/composables/turnstile.d.ts

@@ -0,0 +1,19 @@
+/** Minimal template-ref contract exposed by `NuxtTurnstile`. */
+export interface TurnstileResetInstance {
+    reset: () => void;
+}
+/**
+ * Provides token lifecycle, retry, reset, and Nuxt UI feedback helpers.
+ * @returns Turnstile state and lifecycle helpers.
+ */
+export declare function useTurnstile(): {
+    token: import("vue").Ref<string | undefined, string | undefined>;
+    isEnabled: import("vue").ComputedRef<boolean>;
+    getToken: () => string | undefined;
+    getTokenWithRetry: (retries?: number, delayMs?: number) => Promise<string | undefined>;
+    isReady: () => boolean;
+    reset: (instance?: TurnstileResetInstance) => void;
+    showPendingHint: () => void;
+    showMissingTokenErrorHint: () => void;
+    captureTurnstileError: (error: unknown) => boolean;
+};

package/dist/runtime/app/composables/turnstile.js

@@ -0,0 +1,59 @@
+import { computed, ref } from "vue";
+import { useRuntimeConfig, useToast } from "#imports";
+import { turnstileErrorDataSchema } from "../../types/errors.js";
+export function useTurnstile() {
+  const runtimeConfig = useRuntimeConfig();
+  const token = ref();
+  const toast = useToast();
+  const isEnabled = computed(() => Boolean(runtimeConfig.public.turnstile?.siteKey?.trim()));
+  const getToken = () => token.value?.trim() || void 0;
+  async function getTokenWithRetry(retries = 12, delayMs = 250) {
+    if (!isEnabled.value) return void 0;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+      const current = getToken();
+      if (current) return current;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    return void 0;
+  }
+  function reset(instance) {
+    token.value = void 0;
+    if (isEnabled.value) instance?.reset();
+  }
+  function showPendingHint() {
+    toast.add({
+      title: "Please wait",
+      description: "Security check in progress",
+      color: "warning"
+    });
+  }
+  function showMissingTokenErrorHint() {
+    toast.add({
+      title: "Security check failed",
+      description: "Refresh the page and try again",
+      color: "error"
+    });
+  }
+  function captureTurnstileError(error) {
+    const data = extractErrorData(error);
+    if (!turnstileErrorDataSchema.safeParse(data).success) return false;
+    showMissingTokenErrorHint();
+    return true;
+  }
+  return {
+    token,
+    isEnabled,
+    getToken,
+    getTokenWithRetry,
+    isReady: () => !isEnabled.value || Boolean(getToken()),
+    reset,
+    showPendingHint,
+    showMissingTokenErrorHint,
+    captureTurnstileError
+  };
+}
+function extractErrorData(error) {
+  if (!error || typeof error !== "object" || !("data" in error)) return void 0;
+  const data = error.data;
+  return data && typeof data === "object" && "data" in data ? data.data : data;
+}

package/dist/runtime/constants.d.ts

@@ -0,0 +1,2 @@
+/** Header used to forward a browser Turnstile token to a protected API route. */
+export declare const TURNSTILE_TOKEN_HEADER = "x-turnstile-token";

package/dist/runtime/constants.js

@@ -0,0 +1 @@
+export const TURNSTILE_TOKEN_HEADER = "x-turnstile-token";

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { TURNSTILE_TOKEN_HEADER } from "./constants.js";
+export { assertTurnstileToken, createTurnstileError, createTurnstileErrorData, isErrorWithStatusCode } from "./server/utils/turnstile.js";
+export type { TurnstileErrorCode, TurnstileErrorData } from "./types/errors.js";

package/dist/runtime/index.js

@@ -0,0 +1,7 @@
+export { TURNSTILE_TOKEN_HEADER } from "./constants.js";
+export {
+  assertTurnstileToken,
+  createTurnstileError,
+  createTurnstileErrorData,
+  isErrorWithStatusCode
+} from "./server/utils/turnstile.js";

package/dist/runtime/server/utils/turnstile.d.ts

@@ -0,0 +1,32 @@
+import type { H3Event } from "h3";
+import type { TurnstileErrorCode, TurnstileErrorData } from "../../types/errors.js";
+/**
+ * Validates the Turnstile token from a protected request.
+ * @param event - H3 request event.
+ * @param expectedAction - Action expected from the Turnstile response.
+ * @returns Resolves when the token is valid.
+ */
+export declare function assertTurnstileToken(event: H3Event, expectedAction: string): Promise<void>;
+/** Creates a stable H3 error for Turnstile failures.
+ * @param statusCode - HTTP status code.
+ * @param statusMessage - Human-readable status message.
+ * @param code - Stable Turnstile error code.
+ * @param expectedAction - Optional expected action.
+ * @returns An H3 error with normalized Turnstile data.
+ */
+export declare function createTurnstileError(statusCode: number, statusMessage: string, code: TurnstileErrorCode, expectedAction?: string): Error;
+/**
+ * Creates the serializable Turnstile error payload.
+ * @param code - Stable Turnstile error code.
+ * @param expectedAction - Optional expected action.
+ * @returns Serializable error data.
+ */
+export declare function createTurnstileErrorData(code: TurnstileErrorCode, expectedAction?: string): TurnstileErrorData;
+/**
+ * Narrows unknown exceptions to errors carrying an HTTP status code.
+ * @param error - Unknown exception.
+ * @returns Whether the exception has a numeric status code.
+ */
+export declare function isErrorWithStatusCode(error: unknown): error is {
+    statusCode: number;
+};

package/dist/runtime/server/utils/turnstile.js

@@ -0,0 +1,71 @@
+import { createError, getRequestHeader } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { verifyTurnstileToken } from "@nuxtjs/turnstile/runtime/server/utils/verify.js";
+import { isAdmin } from "module-utils/server";
+import { attempt } from "module-utils/shared";
+import { TURNSTILE_TOKEN_HEADER } from "../../constants.js";
+export async function assertTurnstileToken(event, expectedAction) {
+  const config = useRuntimeConfig(event);
+  const turnstileConfig = config.turnstile;
+  if (isAdmin(event, turnstileConfig?.adminToken, turnstileConfig?.adminHeaderName ?? "x-admin-token"))
+    return;
+  const secretKey = turnstileConfig?.secretKey?.trim();
+  if (!secretKey) {
+    if (!import.meta.dev)
+      throw createTurnstileError(
+        500,
+        "Turnstile secret key is missing",
+        "TURNSTILE_SERVER_MISCONFIGURED",
+        expectedAction
+      );
+    return;
+  }
+  const token = getRequestHeader(event, TURNSTILE_TOKEN_HEADER)?.trim();
+  if (!token)
+    throw createTurnstileError(
+      400,
+      "Turnstile token is missing",
+      "TURNSTILE_TOKEN_MISSING",
+      expectedAction
+    );
+  const result = await attempt(() => verifyTurnstileToken(token));
+  if (result.error !== null) {
+    if (isErrorWithStatusCode(result.error)) throw result.error;
+    throw createError({
+      statusCode: 502,
+      statusMessage: "Turnstile validation could not be performed",
+      data: createTurnstileErrorData("TURNSTILE_VALIDATION_UNAVAILABLE", expectedAction),
+      cause: result.error
+    });
+  }
+  const verification = result.data;
+  if (!verification.success)
+    throw createTurnstileError(
+      403,
+      "Turnstile validation failed",
+      "TURNSTILE_VALIDATION_FAILED",
+      expectedAction
+    );
+  if (verification.action && verification.action !== expectedAction)
+    throw createTurnstileError(
+      403,
+      "Turnstile action does not match",
+      "TURNSTILE_ACTION_MISMATCH",
+      expectedAction
+    );
+}
+export function createTurnstileError(statusCode, statusMessage, code, expectedAction) {
+  return createError({
+    statusCode,
+    statusMessage,
+    data: createTurnstileErrorData(code, expectedAction)
+  });
+}
+export function createTurnstileErrorData(code, expectedAction) {
+  return expectedAction ? { code, expectedAction } : { code };
+}
+export function isErrorWithStatusCode(error) {
+  return Boolean(
+    error && typeof error === "object" && "statusCode" in error && typeof error.statusCode === "number"
+  );
+}

package/dist/runtime/types/config.d.ts

@@ -0,0 +1,15 @@
+declare module "nuxt/schema" {
+  interface RuntimeConfig {
+    turnstile: {
+      secretKey: string;
+      adminToken: string;
+      adminHeaderName: string;
+    };
+  }
+
+  interface PublicRuntimeConfig {
+    turnstile: { siteKey: string };
+  }
+}
+
+export {};

package/dist/runtime/types/errors.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const turnstileErrorCodeSchema: z.ZodEnum<{
+    TURNSTILE_TOKEN_MISSING: "TURNSTILE_TOKEN_MISSING";
+    TURNSTILE_VALIDATION_FAILED: "TURNSTILE_VALIDATION_FAILED";
+    TURNSTILE_ACTION_MISMATCH: "TURNSTILE_ACTION_MISMATCH";
+    TURNSTILE_VALIDATION_UNAVAILABLE: "TURNSTILE_VALIDATION_UNAVAILABLE";
+    TURNSTILE_SERVER_MISCONFIGURED: "TURNSTILE_SERVER_MISCONFIGURED";
+}>;
+export declare const turnstileErrorDataSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        TURNSTILE_TOKEN_MISSING: "TURNSTILE_TOKEN_MISSING";
+        TURNSTILE_VALIDATION_FAILED: "TURNSTILE_VALIDATION_FAILED";
+        TURNSTILE_ACTION_MISMATCH: "TURNSTILE_ACTION_MISMATCH";
+        TURNSTILE_VALIDATION_UNAVAILABLE: "TURNSTILE_VALIDATION_UNAVAILABLE";
+        TURNSTILE_SERVER_MISCONFIGURED: "TURNSTILE_SERVER_MISCONFIGURED";
+    }>;
+    expectedAction: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TurnstileErrorCode = z.infer<typeof turnstileErrorCodeSchema>;
+export type TurnstileErrorData = z.infer<typeof turnstileErrorDataSchema>;

package/dist/runtime/types/errors.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const turnstileErrorCodeSchema = z.enum([
+  "TURNSTILE_TOKEN_MISSING",
+  "TURNSTILE_VALIDATION_FAILED",
+  "TURNSTILE_ACTION_MISMATCH",
+  "TURNSTILE_VALIDATION_UNAVAILABLE",
+  "TURNSTILE_SERVER_MISCONFIGURED"
+]);
+export const turnstileErrorDataSchema = z.object({
+  code: turnstileErrorCodeSchema,
+  expectedAction: z.string().optional()
+});

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@onderwijsin/nuxt-turnstile",
+  "version": "0.2.0",
+  "description": "Nuxt Turnstile integration with client helpers and server-side validation.",
+  "homepage": "https://github.com/onderwijsin/nuxt-modules#readme",
+  "bugs": {
+    "url": "https://github.com/onderwijsin/nuxt-modules/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onderwijsin/nuxt-modules.git",
+    "directory": "modules/turnstile"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nuxt/kit": "4.5.2",
+    "@nuxt/schema": "4.5.2",
+    "@nuxt/ui": "4.10.0",
+    "@nuxtjs/turnstile": "1.1.3",
+    "defu": "6.1.7",
+    "h3": "1.15.11",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "1.0.3",
+    "@nuxt/test-utils": "4.1.0",
+    "nuxt": "4.5.2",
+    "typescript": "5.9.3",
+    "unbuild": "3.6.1",
+    "module-utils": "0.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "typecheck": "tsc --noEmit --project tsconfig.json",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt-module-build build && nuxt prepare playground"
+  }
+}