@lenne.tech/nuxt-extensions 1.0.0 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 lenne.Tech GmbH
+Copyright (c) 2026 lenne.Tech GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/module.d.mts

@@ -1,6 +1,9 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { LtExtensionsModuleOptions } from '../dist/runtime/types/index.js';
-export { LtExtensionsModuleOptions } from '../dist/runtime/types/index.js';
+export { LtAuthClientConfig, LtAuthMode, LtAuthResponse, LtAuthState, LtPasskeyAuthResult, LtPasskeyRegisterResult, LtUser, UseLtAuthReturn } from '../dist/runtime/types/auth.js';
+export { LtFileInfo, LtUploadItem, LtUploadOptions, LtUploadProgress, LtUploadStatus, UseLtFileReturn, UseLtTusUploadReturn } from '../dist/runtime/types/upload.js';
+export { LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtTusModuleOptions } from '../dist/runtime/types/module.js';
+export { LtErrorTranslationResponse, LtParsedError, UseLtErrorTranslationReturn } from '../dist/runtime/types/error.js';
 
 declare const name = "@lenne.tech/nuxt-extensions";
 declare const version = "1.0.0";

package/dist/module.mjs

@@ -18,6 +18,10 @@ const defaultOptions = {
     loginPath: "/auth/login",
     twoFactorRedirectPath: "/auth/2fa"
   },
+  errorTranslation: {
+    enabled: true,
+    defaultLocale: "de"
+  },
   i18n: {
     autoMerge: true
   },
@@ -38,6 +42,7 @@ const module$1 = defineNuxtModule({
     const { resolve } = createResolver(import.meta.url);
     const resolvedOptions = {
       auth: { ...defaultOptions.auth, ...options.auth },
+      errorTranslation: { ...defaultOptions.errorTranslation, ...options.errorTranslation },
       i18n: { ...defaultOptions.i18n, ...options.i18n },
       tus: { ...defaultOptions.tus, ...options.tus }
     };
@@ -56,6 +61,10 @@ const module$1 = defineNuxtModule({
         loginPath: resolvedOptions.auth?.loginPath || "/auth/login",
         twoFactorRedirectPath: resolvedOptions.auth?.twoFactorRedirectPath || "/auth/2fa"
       },
+      errorTranslation: {
+        enabled: resolvedOptions.errorTranslation?.enabled ?? true,
+        defaultLocale: resolvedOptions.errorTranslation?.defaultLocale || "de"
+      },
       tus: {
         defaultChunkSize: resolvedOptions.tus?.defaultChunkSize || 5 * 1024 * 1024,
         defaultEndpoint: resolvedOptions.tus?.defaultEndpoint || "/files/upload"
@@ -66,6 +75,10 @@ const module$1 = defineNuxtModule({
       { name: "useLtAuth", from: resolve("./runtime/composables/auth/use-lt-auth") },
       { name: "useLtAuthClient", from: resolve("./runtime/composables/use-lt-auth-client") },
       { name: "ltAuthClient", from: resolve("./runtime/composables/use-lt-auth-client") },
+      {
+        name: "useLtErrorTranslation",
+        from: resolve("./runtime/composables/use-lt-error-translation")
+      },
       { name: "useLtFile", from: resolve("./runtime/composables/use-lt-file") },
       { name: "useLtTusUpload", from: resolve("./runtime/composables/use-lt-tus-upload") },
       { name: "useLtShare", from: resolve("./runtime/composables/use-lt-share") },
@@ -102,16 +115,22 @@ const module$1 = defineNuxtModule({
     if (resolvedOptions.auth?.enabled && resolvedOptions.auth?.interceptor?.enabled) {
       addPlugin(resolve("./runtime/plugins/auth-interceptor.client"));
     }
+    if (resolvedOptions.errorTranslation?.enabled) {
+      addPlugin(resolve("./runtime/plugins/error-translation.client"));
+    }
     if (resolvedOptions.i18n?.autoMerge) {
-      nuxt.hook("i18n:registerModule", (register) => {
-        register({
-          langDir: resolve("./runtime/locales"),
-          locales: [
-            { code: "en", file: "en.json" },
-            { code: "de", file: "de.json" }
-          ]
-        });
-      });
+      nuxt.hook(
+        "i18n:registerModule",
+        (register) => {
+          register({
+            langDir: resolve("./runtime/locales"),
+            locales: [
+              { code: "en", file: "en.json" },
+              { code: "de", file: "de.json" }
+            ]
+          });
+        }
+      );
     }
     nuxt.options.build.transpile.push(resolve("./runtime"));
     nuxt.options.build.transpile.push("tus-js-client");

package/dist/runtime/components/transition/LtTransitionFade.vue

@@ -6,7 +6,9 @@ const props = defineProps({
 </script>
 
 <template>
-  <div :style="`--start-duration: ${props.startDuration}ms; --leave-duration: ${props.leaveDuration}ms;`">
+  <div
+    :style="`--start-duration: ${props.startDuration}ms; --leave-duration: ${props.leaveDuration}ms;`"
+  >
     <Transition
       enter-active-class="transition ease-out duration-[--start-duration]"
       enter-from-class="transform opacity-0"

package/dist/runtime/components/transition/LtTransitionFadeScale.vue

@@ -6,7 +6,9 @@ const props = defineProps({
 </script>
 
 <template>
-  <div :style="`--start-duration: ${props.startDuration}ms; --leave-duration: ${props.leaveDuration}ms;`">
+  <div
+    :style="`--start-duration: ${props.startDuration}ms; --leave-duration: ${props.leaveDuration}ms;`"
+  >
     <Transition
       enter-active-class="transition ease-out duration-[--start-duration]"
       enter-from-class="transform opacity-0 scale-95"

package/dist/runtime/composables/auth/use-lt-auth.d.ts

@@ -9,7 +9,7 @@
  * - If session cookie works -> use cookies
  * - If cookies fail (401) -> switch to JWT mode
  */
-import type { UseLtAuthReturn } from '../../types/index.js';
+import type { UseLtAuthReturn } from "../../types/index.js";
 /**
  * Better Auth composable with Cookie/JWT dual-mode authentication
  *

package/dist/runtime/composables/auth/use-lt-auth.js

@@ -81,7 +81,13 @@ export function useLtAuth() {
       const maxAge = 60 * 60 * 24 * 7;
       document.cookie = `lt-auth-state=${encodeURIComponent(JSON.stringify(clearedState))}; path=/; max-age=${maxAge}; samesite=lax`;
       document.cookie = `lt-jwt-token=; path=/; max-age=0`;
-      const sessionCookieNames = ["better-auth.session_token", "better-auth.session", "__Secure-better-auth.session_token", "session_token", "session"];
+      const sessionCookieNames = [
+        "better-auth.session_token",
+        "better-auth.session",
+        "__Secure-better-auth.session_token",
+        "session_token",
+        "session"
+      ];
       for (const name of sessionCookieNames) {
         document.cookie = `${name}=; path=/; max-age=0`;
         document.cookie = `${name}=; path=/api; max-age=0`;
@@ -244,11 +250,17 @@ export function useLtAuth() {
     isLoading.value = true;
     try {
       const apiBase = getApiBase();
-      const optionsResponse = await fetchWithAuth(`${apiBase}/passkey/generate-authenticate-options`, {
-        method: "GET"
-      });
+      const optionsResponse = await fetchWithAuth(
+        `${apiBase}/passkey/generate-authenticate-options`,
+        {
+          method: "GET"
+        }
+      );
       if (!optionsResponse.ok) {
-        return { success: false, error: t("lt.auth.passkeyError", "Konnte Passkey-Optionen nicht laden") };
+        return {
+          success: false,
+          error: t("lt.auth.passkeyError", "Konnte Passkey-Optionen nicht laden")
+        };
       }
       const options = await optionsResponse.json();
       const challengeBuffer = ltBase64UrlToUint8Array(options.challenge).buffer;
@@ -284,7 +296,10 @@ export function useLtAuth() {
       });
       const result = await authResponse.json();
       if (!authResponse.ok) {
-        return { success: false, error: result.message || t("lt.auth.passkeyFailed", "Passkey-Anmeldung fehlgeschlagen") };
+        return {
+          success: false,
+          error: result.message || t("lt.auth.passkeyFailed", "Passkey-Anmeldung fehlgeschlagen")
+        };
       }
       if (result.user) {
         setUser(result.user, "cookie");
@@ -300,9 +315,15 @@ export function useLtAuth() {
       return { success: true, user: result.user, session: result.session };
     } catch (err) {
       if (err instanceof Error && err.name === "NotAllowedError") {
-        return { success: false, error: t("lt.auth.passkeyAborted", "Passkey-Authentifizierung wurde abgebrochen") };
+        return {
+          success: false,
+          error: t("lt.auth.passkeyAborted", "Passkey-Authentifizierung wurde abgebrochen")
+        };
       }
-      return { success: false, error: err instanceof Error ? err.message : t("lt.auth.passkeyFailed", "Passkey-Anmeldung fehlgeschlagen") };
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : t("lt.auth.passkeyFailed", "Passkey-Anmeldung fehlgeschlagen")
+      };
     } finally {
       isLoading.value = false;
     }
@@ -316,7 +337,10 @@ export function useLtAuth() {
       });
       if (!optionsResponse.ok) {
         const error = await optionsResponse.json().catch(() => ({}));
-        return { success: false, error: error.message || t("lt.auth.registerOptionsError", "Konnte Registrierungsoptionen nicht laden") };
+        return {
+          success: false,
+          error: error.message || t("lt.auth.registerOptionsError", "Konnte Registrierungsoptionen nicht laden")
+        };
       }
       const options = await optionsResponse.json();
       const challengeBuffer = ltBase64UrlToUint8Array(options.challenge).buffer;
@@ -341,7 +365,10 @@ export function useLtAuth() {
         }
       });
       if (!credential) {
-        return { success: false, error: t("lt.auth.passkeyCreationAborted", "Passkey-Erstellung abgebrochen") };
+        return {
+          success: false,
+          error: t("lt.auth.passkeyCreationAborted", "Passkey-Erstellung abgebrochen")
+        };
       }
       const attestationResponse = credential.response;
       const credentialBody = {
@@ -367,14 +394,23 @@ export function useLtAuth() {
       });
       const result = await registerResponse.json();
       if (!registerResponse.ok) {
-        return { success: false, error: result.message || t("lt.auth.passkeyRegisterFailed", "Passkey-Registrierung fehlgeschlagen") };
+        return {
+          success: false,
+          error: result.message || t("lt.auth.passkeyRegisterFailed", "Passkey-Registrierung fehlgeschlagen")
+        };
       }
       return { success: true, passkey: result };
     } catch (err) {
       if (err instanceof Error && err.name === "NotAllowedError") {
-        return { success: false, error: t("lt.auth.passkeyCreationAborted", "Passkey-Erstellung wurde abgebrochen") };
+        return {
+          success: false,
+          error: t("lt.auth.passkeyCreationAborted", "Passkey-Erstellung wurde abgebrochen")
+        };
       }
-      return { success: false, error: err instanceof Error ? err.message : t("lt.auth.passkeyRegisterFailed", "Passkey-Registrierung fehlgeschlagen") };
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : t("lt.auth.passkeyRegisterFailed", "Passkey-Registrierung fehlgeschlagen")
+      };
     } finally {
       isLoading.value = false;
     }

package/dist/runtime/composables/index.d.ts

@@ -1,5 +1,6 @@
-export { useLtAuth } from './auth/use-lt-auth.js';
-export { useLtAuthClient, ltAuthClient } from './use-lt-auth-client.js';
-export { useLtTusUpload } from './use-lt-tus-upload.js';
-export { useLtFile } from './use-lt-file.js';
-export { useLtShare, type UseLtShareReturn } from './use-lt-share.js';
+export { useLtAuth } from "./auth/use-lt-auth.js";
+export { useLtAuthClient, ltAuthClient } from "./use-lt-auth-client.js";
+export { useLtTusUpload } from "./use-lt-tus-upload.js";
+export { useLtFile } from "./use-lt-file.js";
+export { useLtShare, type UseLtShareReturn } from "./use-lt-share.js";
+export { useLtErrorTranslation } from "./use-lt-error-translation.js";

package/dist/runtime/composables/index.js

@@ -3,3 +3,4 @@ export { useLtAuthClient, ltAuthClient } from "./use-lt-auth-client.js";
 export { useLtTusUpload } from "./use-lt-tus-upload.js";
 export { useLtFile } from "./use-lt-file.js";
 export { useLtShare } from "./use-lt-share.js";
+export { useLtErrorTranslation } from "./use-lt-error-translation.js";

package/dist/runtime/composables/use-lt-auth-client.d.ts

@@ -16,12 +16,20 @@
  * await authClient.passkey.listUserPasskeys();
  * ```
  */
-import { type LtAuthClient } from '../lib/auth-client.js';
+import { type LtAuthClient } from "../lib/auth-client.js";
+/**
+ * Reset the auth client singleton (useful for testing or config changes)
+ */
+export declare function resetLtAuthClient(): void;
 /**
  * Returns the Better-Auth client singleton
  *
  * The client is created once and reused across all calls.
  * Configuration is read from RuntimeConfig on first call.
+ *
+ * IMPORTANT: In dev mode, the basePath is automatically prefixed with '/api'
+ * to leverage Nuxt's server proxy. This is required for WebAuthn/Passkey
+ * to work correctly (same-origin policy).
  */
 export declare function useLtAuthClient(): LtAuthClient;
 export declare const ltAuthClient: {

package/dist/runtime/composables/use-lt-auth-client.js

@@ -1,14 +1,38 @@
 import { useNuxtApp } from "#imports";
 import { createLtAuthClient } from "../lib/auth-client.js";
 let authClientInstance = null;
+export function resetLtAuthClient() {
+  authClientInstance = null;
+}
+function isDevMode() {
+  if (import.meta.server) {
+    return process.env.NODE_ENV !== "production";
+  }
+  if (typeof window !== "undefined") {
+    const buildId = window.__NUXT__?.config?.app?.buildId;
+    if (buildId === "dev") {
+      return true;
+    }
+    const hostname = window.location?.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return true;
+    }
+  }
+  return false;
+}
 export function useLtAuthClient() {
   if (!authClientInstance) {
     try {
       const nuxtApp = useNuxtApp();
       const config = nuxtApp.$config?.public?.ltExtensions?.auth || {};
+      const isDev = isDevMode();
+      let basePath = config.basePath || "/iam";
+      if (isDev && basePath && !basePath.startsWith("/api")) {
+        basePath = `/api${basePath}`;
+      }
       authClientInstance = createLtAuthClient({
-        baseURL: config.baseURL,
-        basePath: config.basePath,
+        baseURL: isDev ? "" : config.baseURL,
+        basePath,
         twoFactorRedirectPath: config.twoFactorRedirectPath,
         enableAdmin: config.enableAdmin,
         enableTwoFactor: config.enableTwoFactor,

package/dist/runtime/composables/use-lt-error-translation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Error Translation Composable
+ *
+ * Translates backend error codes to user-friendly messages.
+ * Works with or without @nuxtjs/i18n.
+ *
+ * Backend error format: "#LTNS_0100: Unauthorized - User is not logged in"
+ * Translations loaded from: GET /api/i18n/errors/:locale
+ */
+import type { UseLtErrorTranslationReturn } from "../types/error.js";
+/**
+ * Error Translation composable
+ *
+ * @returns Functions and state for error translation
+ *
+ * @example
+ * ```typescript
+ * const { translateError, showErrorToast, parseError } = useLtErrorTranslation();
+ *
+ * // Translate error from API response
+ * const message = translateError(error.message);
+ * // Input: "#LTNS_0100: Unauthorized - User is not logged in"
+ * // Output: "Sie sind nicht angemeldet." (when locale is 'de')
+ *
+ * // Show error as toast
+ * showErrorToast(error, 'Login fehlgeschlagen');
+ *
+ * // Parse error for custom handling
+ * const parsed = parseError(error.message);
+ * // { code: 'LTNS_0100', developerMessage: 'Unauthorized...', translatedMessage: '...' }
+ * ```
+ */
+export declare function useLtErrorTranslation(): UseLtErrorTranslationReturn;

package/dist/runtime/composables/use-lt-error-translation.js

@@ -0,0 +1,133 @@
+import { computed, ref, useState, useNuxtApp, useRuntimeConfig } from "#imports";
+const ERROR_CODE_REGEX = /^#([A-Z_]+_\d+):\s*(.+)$/;
+export function useLtErrorTranslation() {
+  const nuxtApp = useNuxtApp();
+  const runtimeConfig = useRuntimeConfig();
+  const translations = useState(
+    "lt-error-translations",
+    () => ({})
+  );
+  const isLoading = ref(false);
+  const config = runtimeConfig.public?.ltExtensions?.errorTranslation;
+  function t(key, germanFallback) {
+    const i18n = nuxtApp.$i18n;
+    if (!i18n?.t) {
+      return germanFallback;
+    }
+    return i18n.t(key);
+  }
+  function detectLocale() {
+    const i18n = nuxtApp.$i18n;
+    if (i18n?.locale?.value) {
+      return i18n.locale.value;
+    }
+    if (import.meta.client && navigator?.language) {
+      const browserLang = navigator.language.split("-")[0] ?? "de";
+      if (["de", "en"].includes(browserLang)) {
+        return browserLang;
+      }
+    }
+    return config?.defaultLocale || "de";
+  }
+  function getApiBase() {
+    return runtimeConfig.public?.ltExtensions?.auth?.baseURL || "";
+  }
+  async function loadTranslations(locale) {
+    const targetLocale = locale || detectLocale();
+    if (translations.value[targetLocale]) {
+      return;
+    }
+    if (isLoading.value) {
+      return;
+    }
+    isLoading.value = true;
+    try {
+      const apiBase = getApiBase();
+      const response = await $fetch(
+        `${apiBase}/api/i18n/errors/${targetLocale}`
+      );
+      if (response?.errors) {
+        translations.value = {
+          ...translations.value,
+          [targetLocale]: response.errors
+        };
+      }
+    } catch (error) {
+      console.warn(`[LtErrorTranslation] Failed to load translations for ${targetLocale}:`, error);
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  function extractMessage(errorOrMessage) {
+    if (typeof errorOrMessage === "string") {
+      return errorOrMessage;
+    }
+    if (errorOrMessage instanceof Error) {
+      return errorOrMessage.message;
+    }
+    if (typeof errorOrMessage === "object" && errorOrMessage !== null) {
+      const obj = errorOrMessage;
+      return obj.message || obj.error?.message || obj.data?.message || obj.statusMessage || String(obj);
+    }
+    return String(errorOrMessage);
+  }
+  function parseError(errorOrMessage) {
+    const message = extractMessage(errorOrMessage);
+    const match = message.match(ERROR_CODE_REGEX);
+    if (match) {
+      const code = match[1] || "";
+      const developerMessage = match[2] || "";
+      const locale = detectLocale();
+      const localeTranslations = translations.value[locale] || {};
+      const translatedMessage = localeTranslations[code] || developerMessage;
+      return {
+        code,
+        developerMessage,
+        translatedMessage
+      };
+    }
+    return {
+      code: null,
+      developerMessage: message,
+      translatedMessage: message
+    };
+  }
+  function translateError(errorOrMessage) {
+    const parsed = parseError(errorOrMessage);
+    return parsed.translatedMessage;
+  }
+  function showErrorToast(errorOrMessage, title) {
+    if (!import.meta.client) {
+      return;
+    }
+    const parsed = parseError(errorOrMessage);
+    try {
+      nuxtApp.runWithContext(() => {
+        const toastComposable = nuxtApp.useToast || globalThis.useToast;
+        if (typeof toastComposable === "function") {
+          const toast = toastComposable();
+          toast.add({
+            color: "error",
+            title: title || t("lt.error.title", "Fehler"),
+            description: parsed.translatedMessage
+          });
+        } else {
+          console.error("[LtErrorTranslation]", parsed.translatedMessage);
+        }
+      });
+    } catch {
+      console.error("[LtErrorTranslation]", parsed.translatedMessage);
+    }
+  }
+  const currentLocale = computed(() => detectLocale());
+  const isLoaded = computed(() => !!translations.value[currentLocale.value]);
+  return {
+    translateError,
+    parseError,
+    showErrorToast,
+    loadTranslations,
+    isLoaded,
+    isLoading,
+    currentLocale
+  };
+}

package/dist/runtime/composables/use-lt-file.d.ts

@@ -6,7 +6,7 @@
  * - URL generation for file access
  * - File size and duration formatting
  */
-import type { UseLtFileReturn } from '../types/index.js';
+import type { UseLtFileReturn } from "../types/index.js";
 /**
  * File utilities composable
  *

package/dist/runtime/composables/use-lt-share.js

@@ -32,7 +32,10 @@ export function useLtShare() {
             const toast = useToast();
             toast.add({
               color: "success",
-              description: t("lt.share.copiedDescription", "Der Link wurde in die Zwischenablage kopiert."),
+              description: t(
+                "lt.share.copiedDescription",
+                "Der Link wurde in die Zwischenablage kopiert."
+              ),
               title: t("lt.share.copied", "Link kopiert")
             });
           } catch {

package/dist/runtime/composables/use-lt-tus-upload.d.ts

@@ -6,7 +6,7 @@
  *
  * @see https://tus.io/
  */
-import type { LtUploadOptions, UseLtTusUploadReturn } from '../types/index.js';
+import type { LtUploadOptions, UseLtTusUploadReturn } from "../types/index.js";
 /**
  * TUS Upload composable with pause/resume support
  *

package/dist/runtime/composables/use-lt-tus-upload.js

@@ -135,7 +135,13 @@ export function useLtTusUpload(defaultOptions = {}) {
         file,
         id,
         metadata: defaultConfig.metadata,
-        progress: { bytesTotal: file.size, bytesUploaded: 0, percentage: 0, remainingTime: 0, speed: 0 },
+        progress: {
+          bytesTotal: file.size,
+          bytesUploaded: 0,
+          percentage: 0,
+          remainingTime: 0,
+          speed: 0
+        },
         status: "idle"
       };
       const newMap = new Map(uploadItems.value);

package/dist/runtime/lib/auth-client.d.ts

@@ -7,7 +7,7 @@
  * SECURITY: Passwords are hashed with SHA256 client-side to prevent
  * plain text password transmission over the network.
  */
-import type { LtAuthClientConfig } from '../types/index.js';
+import type { LtAuthClientConfig } from "../types/index.js";
 /**
  * Creates a configured Better-Auth client with password hashing
  *

package/dist/runtime/lib/auth-client.js

@@ -3,9 +3,9 @@ import { adminClient, twoFactorClient } from "better-auth/client/plugins";
 import { createAuthClient } from "better-auth/vue";
 import { navigateTo } from "#imports";
 import { ltSha256 } from "../utils/crypto.js";
-import { createLtAuthFetch } from "./auth-state.js";
+import { createLtAuthFetch, isLtDevMode } from "./auth-state.js";
 export function createLtAuthClient(config = {}) {
-  const isDev = import.meta.dev || process.env.NODE_ENV === "local";
+  const isDev = isLtDevMode();
   const defaultBaseURL = isDev ? "" : import.meta.env?.VITE_API_URL || process.env.API_URL || "http://localhost:3000";
   const defaultBasePath = isDev ? "/api/iam" : "/iam";
   const {
@@ -58,8 +58,14 @@ export function createLtAuthClient(config = {}) {
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     changePassword: async (params, options) => {
-      const [hashedCurrent, hashedNew] = await Promise.all([ltSha256(params.currentPassword), ltSha256(params.newPassword)]);
-      return baseClient.changePassword?.({ currentPassword: hashedCurrent, newPassword: hashedNew }, options);
+      const [hashedCurrent, hashedNew] = await Promise.all([
+        ltSha256(params.currentPassword),
+        ltSha256(params.newPassword)
+      ]);
+      return baseClient.changePassword?.(
+        { currentPassword: hashedCurrent, newPassword: hashedNew },
+        options
+      );
     },
     /**
      * Reset password with token (new password is hashed before sending)
@@ -67,7 +73,10 @@ export function createLtAuthClient(config = {}) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     resetPassword: async (params, options) => {
       const hashedPassword = await ltSha256(params.newPassword);
-      return baseClient.resetPassword?.({ newPassword: hashedPassword, token: params.token }, options);
+      return baseClient.resetPassword?.(
+        { newPassword: hashedPassword, token: params.token },
+        options
+      );
     },
     // Override signIn to hash password (keep passkey method from plugin)
     signIn: {
@@ -127,7 +136,10 @@ export function createLtAuthClient(config = {}) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       generateBackupCodes: async (params, options) => {
         const hashedPassword = await ltSha256(params.password);
-        return baseClient.twoFactor.generateBackupCodes({ password: hashedPassword }, options);
+        return baseClient.twoFactor.generateBackupCodes(
+          { password: hashedPassword },
+          options
+        );
       },
       /**
        * Verify TOTP code (pass through to base client)

package/dist/runtime/lib/auth-state.d.ts

@@ -11,7 +11,16 @@
  *
  * The state is persisted in cookies for SSR compatibility.
  */
-import type { LtAuthMode } from '../types/index.js';
+import type { LtAuthMode } from "../types/index.js";
+/**
+ * Detects if we're running in development mode at runtime.
+ *
+ * Note: `import.meta.dev` is evaluated at build time and doesn't work
+ * correctly for pre-built modules. This function uses runtime checks instead.
+ *
+ * @returns true if running in development mode
+ */
+export declare function isLtDevMode(): boolean;
 /**
  * Get the current auth mode from cookie
  */

package/dist/runtime/lib/auth-state.js

@@ -1,3 +1,19 @@
+export function isLtDevMode() {
+  if (import.meta.server) {
+    return process.env.NODE_ENV !== "production";
+  }
+  if (typeof window !== "undefined") {
+    const buildId = window.__NUXT__?.config?.app?.buildId;
+    if (buildId === "dev") {
+      return true;
+    }
+    const hostname = window.location?.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return true;
+    }
+  }
+  return false;
+}
 export function getLtAuthMode() {
   if (import.meta.server) return "cookie";
   try {
@@ -53,7 +69,7 @@ export function setLtAuthMode(mode) {
   }
 }
 export function getLtApiBase(basePath = "/iam") {
-  const isDev = import.meta.dev;
+  const isDev = isLtDevMode();
   if (isDev) {
     return `/api${basePath}`;
   }

package/dist/runtime/lib/index.d.ts

@@ -1,2 +1,2 @@
-export { attemptLtJwtSwitch, createLtAuthFetch, getLtApiBase, getLtAuthMode, getLtJwtToken, isLtAuthenticated, ltAuthFetch, setLtAuthMode, setLtJwtToken, } from './auth-state.js';
-export { createLtAuthClient, type LtAuthClient } from './auth-client.js';
+export { attemptLtJwtSwitch, createLtAuthFetch, getLtApiBase, getLtAuthMode, getLtJwtToken, isLtAuthenticated, ltAuthFetch, setLtAuthMode, setLtJwtToken, } from "./auth-state.js";
+export { createLtAuthClient, type LtAuthClient } from "./auth-client.js";