@lenne.tech/nuxt-extensions 1.11.2 → 1.13.0

package/CLAUDE.md

@@ -76,6 +76,14 @@ export default defineNuxtConfig({
       enabled: true,
       basePath: '/ai',               // Must match the nest-server AI controller
     },
+    formLabelAssociation: {
+      enabled: true,                 // repair <label for> broken by an SSR/client useId() divergence
+      maxRepairMs: 1500,             // how long to keep repairing deferred subtrees
+    },
+    preHydrationInput: {
+      enabled: true,                 // keep text typed before hydration instead of losing it
+      maxRestoreMs: 1500,            // how long to keep repairing deferred subtrees
+    },
   },
 });
 ```
@@ -171,6 +179,61 @@ export default defineNuxtRouteMiddleware((to) => {
 });
 ```
 
+## Form Label Repair
+
+**The defect:** Nuxt UI's `FormField` derives the label's `for` and the control's `id` from one
+`useId()` call. When `useId()` diverges between server and client, the control's `id` is
+force-patched on hydration (vuejs/core#9083) while the label's `for` — a prop on reka-ui's
+`Label` component — is not. The label keeps the stale value and the association breaks.
+
+**What this module adds:** `runtime/plugins/form-label-association.client.ts` re-points
+dangling Nuxt UI field labels at the control in their own field, at `app:mounted` and for a
+bounded window afterwards (`maxRepairMs`, default 1500 ms).
+
+**What this means when you debug a consuming project:**
+
+- **A `for` attribute that changes after mount is this plugin, not a bug.** It logs a
+  `console.warn` in development naming how many labels it repaired.
+- **It refuses to guess.** The repair only fires when the field holds exactly one eligible
+  control. Radio and checkbox groups, hidden form-value proxies, `aria-hidden`/`disabled`
+  controls and button-only fields are skipped on purpose — binding a group caption to its
+  first option would submit a value the user never chose.
+- **Only Nuxt UI's own field labels are touched** (`label[data-slot="label"][for]`). Labels
+  your application wrote are never rewritten.
+- **Do not "fix" a skipped group by loosening the rule.** Inert beats wrong here; the correct
+  fix for a group is an SSR-stable id at the source.
+- This is a **stopgap** for a framework-level divergence. Opt out with
+  `ltExtensions.formLabelAssociation.enabled: false`.
+
+## Pre-Hydration Input Preservation
+
+**The defect:** until Vue hydrates a server-rendered `<input>`, it carries no framework
+listener. Text typed in that window goes into the DOM node, the `input` event reaches nothing,
+and `v-model`'s mounted hook then overwrites it. The entry is **erased, not delayed**. It is
+load-dependent, so it hides in development.
+
+**Vue already fixes most of it.** Since 3.5.41 (vuejs/core#14411) Vue adopts the typed value
+into the model on hydration — but only for `type="text"` and `textarea`. `email`, `password`,
+`tel`, `url`, `search` and `number` are still erased. Upstream tracking: vuejs/core#15210.
+
+**What this module adds:** `runtime/plugins/pre-hydration-input.client.ts` snapshots edited
+fields at `app:beforeMount` and restores them at `app:mounted`, dispatching a synthetic
+`input` event so `v-model` adopts the value.
+
+**What this means when you debug a consuming project:**
+
+- **Do not add a `readonly`-until-mounted guard to inputs.** It was tried and removed: it makes
+  the field look usable while silently refusing, suppresses browser autofill (`readonly` is the
+  documented technique for exactly that), makes screen readers announce "read only" with no
+  announcement when it flips back, and stops mobile browsers raising the on-screen keyboard.
+- A field is treated as edited when `value !== defaultValue`, so server-pre-filled values are
+  never restored over a legitimate change made during hydration.
+- Each field is restored at most once; a later programmatic clear is not undone.
+- This is a **stopgap**. When Vue widens its gate, delete the plugin —
+  `test/pre-hydration-input.test.ts` pins the current behaviour and will fail on the types Vue
+  takes over.
+- Opt out with `ltExtensions.preHydrationInput.enabled: false`.
+
 ## Development Rules
 
 1. **ALWAYS read source code** in `dist/runtime/` to understand available composables and components

package/README.md

@@ -41,6 +41,8 @@ npm install tus-js-client
 - **Transition Components** - Ready-to-use Vue transition wrappers
 - **i18n Support** - English and German translations (works without i18n too)
 - **Auto-imports** - All composables and components are auto-imported
+- **Pre-hydration input preservation** - text typed before hydration is kept, not erased
+- **Form label repair** - restores `<label for>` associations that hydration breaks
 
 ## Environment Variables
 
@@ -156,6 +158,141 @@ export default defineNuxtConfig({
 });
 ```
 
+## Form Label Repair
+
+Restores `<label for>` associations that hydration breaks. Active by default.
+
+### The problem
+
+Nuxt UI's `FormField` derives the label's `for` and the control's `id` from a single
+`useId()` call, so they cannot disagree — unless `useId()` itself returns different values on
+server and client, which happens when the two walk a different number of async boundaries.
+
+Measured against `@nuxt/ui` 4.11.x:
+
+| | label `for` | control `id` |
+|---|---|---|
+| SSR payload | `v-0-4-2` | `v-0-4-2` |
+| after hydration | `v-0-4-2` | `v-0-1-2` |
+
+Vue 3.5.39 did not cause this, it exposed it
+([vuejs/core#9083](https://github.com/vuejs/core/pull/9083) force-patches an element's
+dynamic props on hydration). The control's `id` is such a prop; the label's `for`, passed
+through reka-ui's `Label` component, is not — so only the label keeps the stale value.
+
+### What it costs when it breaks
+
+The control loses its programmatic label. Without a placeholder it has no accessible name at
+all and a screen reader announces "edit text, blank"; **with** a placeholder that becomes the
+name instead, so the visible label is no longer part of it and speech input stops working.
+Clicking the label focuses nothing either — which on a checkbox or radio is the primary hit
+target, not a convenience. Tests using `getByRole('textbox', { name })` stop finding fields.
+
+### What the repair does
+
+After mount, and for a bounded window afterwards, every Nuxt UI field label whose target does
+not resolve is re-pointed at the control in its own field.
+
+**It refuses to guess.** A repair that fires where it should not is worse than the defect: a
+dangling label is inert and visible, a mis-pointed one is confidently wrong and silent, and
+on a radio or checkbox a click on the caption would change a value the user never chose. So
+the repair only fires when the field contains exactly **one** eligible control. Skipped
+deliberately:
+
+| Case | Why |
+|------|-----|
+| Radio / checkbox groups | One field root, many controls — binding every caption to the first option would submit a value nobody picked |
+| Hidden form-value proxies, `aria-hidden`, `disabled` | Not the user's control; pointing at one restores neither the name nor the click |
+| Fields whose only visible control is a `button` | Nothing safe to point at |
+| Labels your application wrote | Only Nuxt UI's own field labels (`data-slot="label"`) are touched |
+
+`for` is repaired rather than `aria-labelledby` added, because `for` carries **both** the
+accessible name and click-to-focus.
+
+**This is a repair, not a cure.** The real fix is for the id not to diverge; this exists
+because the divergence sits in the framework stack rather than in any one application.
+
+### Opting out
+
+```ts
+export default defineNuxtConfig({
+  ltExtensions: {
+    formLabelAssociation: {
+      enabled: false,
+      // or keep it on and only change how long deferred subtrees are waited for:
+      // maxRepairMs: 3000,
+    },
+  },
+});
+```
+
+Two real reasons to: your application assigns `for` itself and depends on those exact values,
+or your tests assert on literal `for` / `id` strings rather than on the accessible name.
+
+## Pre-Hydration Input Preservation
+
+Text typed before a page has hydrated is kept instead of being silently thrown away.
+
+### The problem
+
+Until Vue hydrates a server-rendered `<input>`, the element carries **no framework listener**.
+Text typed in that window is written to the DOM node, the `input` event reaches nothing, and
+`v-model`'s mounted hook then writes the model value back over it. The entry is **erased, not
+delayed** — no error, no toast, nothing persisted.
+
+It is load-dependent, so it hides in development and shows up on a cold cache, a slow device
+or a throttled CPU — most often on the login screen, where people type on sight.
+
+### What Vue already does, and where it stops
+
+Vue fixed this in **3.5.41** ([vuejs/core#14411](https://github.com/vuejs/core/pull/14411)):
+on hydration it compares the field's live value against what the server rendered and, when
+they differ, adopts the typed value into the model instead of overwriting the node.
+
+That adoption is gated on `type="text"` and `textarea`. **Every other type still loses the
+entry** — and those are exactly the fields a sign-in form uses:
+
+| Input type | Typed before hydration |
+|------------|------------------------|
+| `text`, `textarea` | kept by Vue itself |
+| `email`, `password`, `tel`, `url`, `search`, `number` | **erased** |
+
+Widening the gate is tracked upstream as
+[vuejs/core#15210](https://github.com/vuejs/core/issues/15210) — open, labelled
+`p2-edge-case`, no milestone.
+
+### What this module adds
+
+A small client plugin that closes the remaining gap. Just before hydration it reads what is
+in each field; just after, it writes back anything that was overwritten and dispatches a
+synthetic `input` event so `v-model` adopts it.
+
+A field counts as edited when its value differs from `defaultValue` — the same test Vue uses,
+so values the server pre-filled are never mistaken for user input. A browser autofill that
+lands before hydration is recovered the same way.
+
+Fields stay ordinary editable fields throughout. Nothing is made `readonly`, so autofill,
+screen-reader semantics and the mobile on-screen keyboard are untouched, and the user never
+faces a field that looks usable and silently refuses.
+
+**This is a stopgap.** When Vue covers the remaining types, delete it —
+`test/pre-hydration-input.test.ts` pins the current gate and will fail on the types Vue takes
+over, which is the signal.
+
+### Opting out
+
+```ts
+export default defineNuxtConfig({
+  ltExtensions: {
+    preHydrationInput: {
+      enabled: false,
+      // or keep it on and only change how long deferred subtrees are waited for:
+      // maxRestoreMs: 3000,
+    },
+  },
+});
+```
+
 ## Usage
 
 ### Authentication

package/dist/module.d.mts

@@ -3,7 +3,7 @@ import { LtExtensionsModuleOptions } from '../dist/runtime/types/index.js';
 export * from '../dist/runtime/types/index.js';
 
 declare const name = "@lenne.tech/nuxt-extensions";
-declare const version = "1.11.2";
+declare const version = "1.13.0";
 declare const configKey = "ltExtensions";
 declare const DEFAULT_LT_AUTH_STATE_COOKIE = "lt-auth-state";
 declare const DEFAULT_LT_JWT_TOKEN_COOKIE = "lt-jwt-token";

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "configKey": "ltExtensions",
   "name": "@lenne.tech/nuxt-extensions",
-  "version": "1.11.2",
+  "version": "1.13.0",
   "builder": {
-    "@nuxt/module-builder": "1.0.2",
+    "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"
   }
 }

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { defineNuxtModule, createResolver, tryResolveModule, addImports, addComponent, addPlugin, addRouteMiddleware } from '@nuxt/kit';
 
 const name = "@lenne.tech/nuxt-extensions";
-const version = "1.11.2";
+const version = "1.13.0";
 const configKey = "ltExtensions";
 const DEFAULT_LT_AUTH_STATE_COOKIE = "lt-auth-state";
 const DEFAULT_LT_JWT_TOKEN_COOKIE = "lt-jwt-token";
@@ -36,9 +36,15 @@ const defaultOptions = {
     enabled: true,
     defaultLocale: "de"
   },
+  formLabelAssociation: {
+    enabled: true
+  },
   i18n: {
     autoMerge: true
   },
+  preHydrationInput: {
+    enabled: true
+  },
   tus: {
     defaultChunkSize: 5 * 1024 * 1024,
     // 5MB
@@ -63,7 +69,9 @@ const module$1 = defineNuxtModule({
         systemSetup: { ...defaultOptions.auth.systemSetup, ...options.auth?.systemSetup }
       },
       errorTranslation: { ...defaultOptions.errorTranslation, ...options.errorTranslation },
+      formLabelAssociation: { ...defaultOptions.formLabelAssociation, ...options.formLabelAssociation },
       i18n: { ...defaultOptions.i18n, ...options.i18n },
+      preHydrationInput: { ...defaultOptions.preHydrationInput, ...options.preHydrationInput },
       tus: { ...defaultOptions.tus, ...options.tus }
     };
     const passkeyAvailable = !!await tryResolveModule("@better-auth/passkey/client", new URL(import.meta.url));
@@ -120,6 +128,14 @@ const module$1 = defineNuxtModule({
         enabled: resolvedOptions.errorTranslation?.enabled ?? true,
         defaultLocale: resolvedOptions.errorTranslation?.defaultLocale || "de"
       },
+      formLabelAssociation: {
+        enabled: resolvedOptions.formLabelAssociation?.enabled ?? true,
+        maxRepairMs: resolvedOptions.formLabelAssociation?.maxRepairMs ?? 1500
+      },
+      preHydrationInput: {
+        enabled: resolvedOptions.preHydrationInput?.enabled ?? true,
+        maxRestoreMs: resolvedOptions.preHydrationInput?.maxRestoreMs ?? 1500
+      },
       tus: {
         defaultChunkSize: resolvedOptions.tus?.defaultChunkSize || 5 * 1024 * 1024,
         defaultEndpoint: resolvedOptions.tus?.defaultEndpoint || "/files/upload"
@@ -208,6 +224,12 @@ const module$1 = defineNuxtModule({
         });
       });
     }
+    if (resolvedOptions.preHydrationInput.enabled !== false) {
+      addPlugin(resolve("./runtime/plugins/pre-hydration-input.client"));
+    }
+    if (resolvedOptions.formLabelAssociation.enabled !== false) {
+      addPlugin(resolve("./runtime/plugins/form-label-association.client"));
+    }
     nuxt.options.build.transpile.push(resolve("./runtime"));
     nuxt.options.build.transpile.push("tus-js-client");
     console.log(`[${name}] Module loaded with config:`, {

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

@@ -284,7 +284,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     requestPasswordReset: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
         email: string;
         redirectTo?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
         email: string;
         redirectTo?: string | undefined;
     } & {
@@ -488,8 +488,9 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
             scopes?: string[] | undefined;
             requestSignUp?: boolean | undefined;
             loginHint?: string | undefined;
+            additionalParams?: Record<string, string> | undefined;
             additionalData?: Record<string, any> | undefined;
-        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+        }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<Omit<{
             provider: (string & {}) | "linear" | "huggingface" | "github" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "slack" | "spotify" | "twitch" | "twitter" | "dropbox" | "kick" | "linkedin" | "gitlab" | "tiktok" | "reddit" | "roblox" | "salesforce" | "vk" | "zoom" | "notion" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
             callbackURL?: string | undefined;
             newUserCallbackURL?: string | undefined;
@@ -512,9 +513,13 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
             scopes?: string[] | undefined;
             requestSignUp?: boolean | undefined;
             loginHint?: string | undefined;
+            additionalParams?: Record<string, string> | undefined;
             additionalData?: Record<string, any> | undefined;
         } & {
             fetchOptions?: FetchOptions | undefined;
+        }, "provider"> & {
+            provider: string | (string & {});
+            fetchOptions?: FetchOptions | undefined;
         }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
             redirect: boolean;
             url: string;
@@ -546,11 +551,20 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
             message?: string | undefined;
         }, FetchOptions["throw"] extends true ? true : false>>;
     };
-    signOut: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
-        query?: Record<string, any> | undefined;
+    signOut: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
+        callbackURL?: string | undefined;
+        disableRedirect?: boolean | undefined;
+        state?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
+        callbackURL?: string | undefined;
+        disableRedirect?: boolean | undefined;
+        state?: string | undefined;
+    } & {
         fetchOptions?: FetchOptions | undefined;
     }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
         success: boolean;
+        url: string | undefined;
+        redirect: boolean | undefined;
     }, {
         code?: string | undefined;
         message?: string | undefined;
@@ -664,7 +678,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     verifyEmail: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<{
         token: string;
         callbackURL?: string | undefined;
-    }> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+    }> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
         query: {
             token: string;
             callbackURL?: string | undefined;
@@ -679,7 +693,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     sendVerificationEmail: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
         email: string;
         callbackURL?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
         email: string;
         callbackURL?: string | undefined;
     } & {
@@ -693,7 +707,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     changeEmail: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
         newEmail: string;
         callbackURL?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
         newEmail: string;
         callbackURL?: string | undefined;
     } & {
@@ -704,7 +718,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
-    updateSession: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<Partial<{}>> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<import("better-auth/client").InferSessionUpdateCtx<{
+    updateSession: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<Partial<{}>> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<import("better-auth/client").InferSessionUpdateCtx<{
         basePath: string;
         baseURL: any;
         fetchOptions: {
@@ -729,7 +743,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     updateUser: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<Partial<{}> & {
         name?: string | undefined;
         image?: string | undefined | null;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<import("better-auth/client").InferUserUpdateCtx<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<import("better-auth/client").InferUserUpdateCtx<{
         basePath: string;
         baseURL: any;
         fetchOptions: {
@@ -746,7 +760,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         callbackURL?: string | undefined;
         password?: string | undefined;
         token?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
         callbackURL?: string | undefined;
         password?: string | undefined;
         token?: string | undefined;
@@ -762,7 +776,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         callback: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<{
             token: string;
             callbackURL?: string | undefined;
-        }> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+        }> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
             query: {
                 token: string;
                 callbackURL?: string | undefined;
@@ -776,7 +790,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
             message?: string | undefined;
         }, FetchOptions["throw"] extends true ? true : false>>;
     };
-    listSessions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+    listSessions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
         query?: Record<string, any> | undefined;
         fetchOptions?: FetchOptions | undefined;
     }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<import("better-auth").Prettify<{
@@ -794,7 +808,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     }, FetchOptions["throw"] extends true ? true : false>>;
     revokeSession: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
         token: string;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
         token: string;
     } & {
         fetchOptions?: FetchOptions | undefined;
@@ -804,7 +818,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
-    revokeSessions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+    revokeSessions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
         query?: Record<string, any> | undefined;
         fetchOptions?: FetchOptions | undefined;
     }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
@@ -813,7 +827,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
-    revokeOtherSessions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+    revokeOtherSessions: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
         query?: Record<string, any> | undefined;
         fetchOptions?: FetchOptions | undefined;
     }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
@@ -830,14 +844,15 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
             nonce?: string | undefined;
             accessToken?: string | undefined;
             refreshToken?: string | undefined;
-            scopes?: string[] | undefined;
         } | undefined;
         requestSignUp?: boolean | undefined;
         scopes?: string[] | undefined;
         errorCallbackURL?: string | undefined;
         disableRedirect?: boolean | undefined;
+        loginHint?: string | undefined;
+        additionalParams?: Record<string, string> | undefined;
         additionalData?: Record<string, any> | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
         provider: unknown;
         callbackURL?: string | undefined;
         idToken?: {
@@ -845,12 +860,13 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
             nonce?: string | undefined;
             accessToken?: string | undefined;
             refreshToken?: string | undefined;
-            scopes?: string[] | undefined;
         } | undefined;
         requestSignUp?: boolean | undefined;
         scopes?: string[] | undefined;
         errorCallbackURL?: string | undefined;
         disableRedirect?: boolean | undefined;
+        loginHint?: string | undefined;
+        additionalParams?: Record<string, string> | undefined;
         additionalData?: Record<string, any> | undefined;
     } & {
         fetchOptions?: FetchOptions | undefined;
@@ -861,7 +877,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
-    listAccounts: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+    listAccounts: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
         query?: Record<string, any> | undefined;
         fetchOptions?: FetchOptions | undefined;
     }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
@@ -871,17 +887,16 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         updatedAt: Date;
         userId: string;
         providerId: string;
+        issuer: string;
         accountId: string;
     }[], {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
     unlinkAccount: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
-        providerId: string;
-        accountId?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
-        providerId: string;
-        accountId?: string | undefined;
+        accountId: string;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
+        accountId: string;
     } & {
         fetchOptions?: FetchOptions | undefined;
     }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
@@ -891,12 +906,18 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
     refreshToken: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
-        providerId: string;
-        accountId?: string | undefined;
+        accountId: string;
         userId?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
-        providerId: string;
-        accountId?: string | undefined;
+    } | {
+        useAccountCookie: true;
+        userId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
+        accountId: string;
+        userId?: string | undefined;
+    } & {
+        fetchOptions?: FetchOptions | undefined;
+    }> | import("better-auth").Prettify<{
+        useAccountCookie: true;
         userId?: string | undefined;
     } & {
         fetchOptions?: FetchOptions | undefined;
@@ -914,12 +935,18 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
     getAccessToken: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
-        providerId: string;
-        accountId?: string | undefined;
+        accountId: string;
         userId?: string | undefined;
-    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth").Prettify<{
-        providerId: string;
-        accountId?: string | undefined;
+    } | {
+        useAccountCookie: true;
+        userId?: string | undefined;
+    }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
+        accountId: string;
+        userId?: string | undefined;
+    } & {
+        fetchOptions?: FetchOptions | undefined;
+    }> | import("better-auth").Prettify<{
+        useAccountCookie: true;
         userId?: string | undefined;
     } & {
         fetchOptions?: FetchOptions | undefined;
@@ -933,19 +960,29 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
     accountInfo: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<{
-        accountId?: string | undefined;
-        providerId?: string | undefined;
+        accountId: string;
         userId?: string | undefined;
-    }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
-        query?: {
-            accountId?: string | undefined;
-            providerId?: string | undefined;
+    } | {
+        useAccountCookie: true;
+        userId?: string | undefined;
+    }> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0: import("better-auth").Prettify<{
+        query: {
+            accountId: string;
             userId?: string | undefined;
-        } | undefined;
+        } | {
+            useAccountCookie: true;
+            userId?: string | undefined;
+        };
         fetchOptions?: FetchOptions | undefined;
-    }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
+    }>, data_1?: FetchOptions | undefined) => Promise<import("better-auth/client").BetterFetchResponse<{
+        account: {
+            id: string;
+            providerId: string;
+            issuer: string;
+            accountId: string;
+        };
         user: import("better-auth").OAuth2UserInfo;
-        data: Record<string, any>;
+        data: object;
     }, {
         code?: string | undefined;
         message?: string | undefined;
@@ -953,7 +990,7 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
     getSession: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<{
         disableCookieCache?: unknown;
         disableRefresh?: unknown;
-    }> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+    }> & Record<string, any>, Record<string, string | undefined> | undefined>>(data_0?: import("better-auth").Prettify<{
         query?: {
             disableCookieCache?: unknown;
             disableRefresh?: unknown;
@@ -983,6 +1020,27 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
         code?: string | undefined;
         message?: string | undefined;
     }, FetchOptions["throw"] extends true ? true : false>>;
+    hydrateSession: (session: {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        }>;
+        session: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+        }>;
+    } | null) => void;
     $ERROR_CODES: {
         USER_NOT_FOUND: {
             readonly code: "USER_NOT_FOUND";

package/dist/runtime/plugins/form-label-association.client.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Repair `<label for>` associations that hydration leaves pointing at nothing.
+ *
+ * ## The defect
+ *
+ * Nuxt UI's `FormField` generates ONE id with `useId()` and uses it for both halves of
+ * the association: `<Label :for="id">` and, via `provide`/`inject`, the control's `id`.
+ * One source, so the two cannot disagree — unless `useId()` itself returns different
+ * values on the server and on the client.
+ *
+ * It does. Measured on a Nuxt 4 app page (SVL, DEV-3093), against `@nuxt/ui` 4.11.x:
+ *
+ * | | label `for` | control `id` |
+ * | -- | -- | -- |
+ * | SSR payload | `v-0-4-2` | `v-0-4-2` |
+ * | after hydration | `v-0-4-2` | `v-0-1-2` |
+ *
+ * The middle segment is Vue's per-branch id prefix, which is extended at every async
+ * boundary. Server and client walked a different number of them, so the ids diverge.
+ *
+ * **Vue >= 3.5.39 did not cause this — it exposed it.** "force patch dynamic props when
+ * hydrating" (vuejs/core#9083, merged 2026-06-25) makes a hydrated element adopt its
+ * freshly computed client value, where previously the server value simply stayed.
+ *
+ * Note WHY only the label is left behind, because it points at the real fix: the control's
+ * `id` is a compiled element binding (`<input :id="id">`), so it is in the element's
+ * `dynamicProps` and gets force-patched. The label's `for` is a PROP on reka-ui's `Label`
+ * component and arrives at the `<label>` through `$attrs`, which is not part of that set.
+ * The asymmetry is the component boundary, not the id generation. Fixing the divergence
+ * upstream — or having `FormField` pass an SSR-stable id — removes the need for this file.
+ *
+ * ## Why it is worth a plugin
+ *
+ * A control whose label does not resolve loses its programmatic label: the visible text is
+ * no longer its accessible name (WCAG 1.3.1). Where the field has no placeholder it has no
+ * accessible name at all and a screen reader announces "edit text, blank" (4.1.2). Where it
+ * has one, the placeholder becomes the name instead — which is arguably worse, because the
+ * name no longer contains the visible label and speech input stops working (2.5.3 Label in
+ * Name). Clicking the label also no longer focuses the control, and for a checkbox or radio
+ * that is not a convenience but the primary hit target.
+ *
+ * And any test that addresses fields the way assistive technology does
+ * (`getByRole('textbox', { name })`, the recommended Playwright locator) stops finding
+ * them, which is how this surfaced: 39 specs at once.
+ *
+ * ## What this does, and what it deliberately does not
+ *
+ * After mount — and for a bounded window afterwards — every Nuxt UI field label whose
+ * target does not resolve is re-pointed at the control inside its own field.
+ *
+ * It **refuses to guess**, which is the rule that matters most here. A repair that fires
+ * where it should not is worse than the defect: a dangling label is inert and visible, a
+ * mis-pointed one is confidently wrong and silent, and on a radio or checkbox a click on
+ * the caption would then change a value the user never chose. So the repair only happens
+ * when the field contains exactly ONE eligible control. A group of radios or checkboxes
+ * shares one field root and is therefore skipped, not guessed at.
+ *
+ * `for` is repaired rather than `aria-labelledby` added, because `for` carries BOTH the
+ * accessible name and click-to-focus. Adding `aria-labelledby` would restore the name
+ * and leave the label dead to the mouse.
+ *
+ * This is a repair, not a cure: the right fix is for the id not to diverge in the first
+ * place (see the component-boundary note above). It is applied here because the divergence
+ * sits in the framework stack rather than in any one application, and because a nameless
+ * form is not something to leave in place while that is resolved upstream.
+ *
+ * Default on; opt out with `ltExtensions.formLabelAssociation.enabled: false`.
+ */
+/**
+ * Re-point every dangling field label at the control in its own field.
+ *
+ * Exported for the unit test: it runs against a DOM fixture rather than a live app, so the
+ * pairing rules stay verifiable without a browser. Not part of the package's public API.
+ *
+ * @param root Where to look. Ids are resolved against the owning document regardless, since
+ *   `id` is document-scoped — so a scoped root narrows which labels are visited, not which
+ *   ids count as resolvable.
+ * @returns how many labels were repaired.
+ */
+export declare function repairDanglingLabels(root: Document | ParentNode): number;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/form-label-association.client.js

@@ -0,0 +1,67 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+const COMPONENT_ROOT = '[data-slot="root"]';
+const FIELD_LABEL = 'label[data-slot="label"][for]';
+const CONTROL = "input, textarea, select";
+const NOT_A_USER_CONTROL = '[type="hidden"], [hidden], [aria-hidden="true"], [disabled]';
+function findControlForLabel(field) {
+  const eligible = [...field.querySelectorAll(CONTROL)].filter((control) => !control.matches(NOT_A_USER_CONTROL));
+  return eligible.length === 1 && eligible[0].id !== "" ? eligible[0] : null;
+}
+export function repairDanglingLabels(root) {
+  let repaired = 0;
+  for (const label of root.querySelectorAll(FIELD_LABEL)) {
+    const field = label.closest(COMPONENT_ROOT);
+    if (field === null) {
+      continue;
+    }
+    const target = label.ownerDocument.getElementById(label.htmlFor);
+    if (target !== null && field.contains(target)) {
+      continue;
+    }
+    const control = findControlForLabel(field);
+    if (control === null || control.id === label.htmlFor) {
+      continue;
+    }
+    label.htmlFor = control.id;
+    repaired += 1;
+  }
+  return repaired;
+}
+export default defineNuxtPlugin({
+  // After the app's own plugins, so a page that assigns ids itself has already run.
+  enforce: "post",
+  name: "lt-form-label-association",
+  setup(nuxtApp) {
+    const options = useRuntimeConfig().public.ltExtensions?.formLabelAssociation;
+    if (options?.enabled === false) {
+      return;
+    }
+    const maxRepairMs = options?.maxRepairMs ?? 1500;
+    let sweeping = null;
+    const sweep = () => {
+      const repaired = repairDanglingLabels(document);
+      if (repaired > 0 && import.meta.dev) {
+        console.warn(
+          `[@lenne.tech/nuxt-extensions] repaired ${repaired} form label association(s) broken by an SSR/client useId() divergence. This is a stopgap \u2014 see runtime/plugins/form-label-association.client.ts.`
+        );
+      }
+    };
+    const sweepFor = () => {
+      sweep();
+      if (maxRepairMs <= 0 || sweeping !== null) {
+        return;
+      }
+      sweeping = setInterval(sweep, 250);
+      setTimeout(() => {
+        if (sweeping !== null) {
+          clearInterval(sweeping);
+          sweeping = null;
+        }
+      }, maxRepairMs);
+    };
+    nuxtApp.hook("app:mounted", sweepFor);
+    nuxtApp.hook("page:finish", () => {
+      requestAnimationFrame(sweepFor);
+    });
+  }
+});

package/dist/runtime/plugins/pre-hydration-input.client.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pre-hydration input preservation — the part Vue does not do yet.
+ *
+ * ## What Vue already handles
+ *
+ * Until Vue hydrates a server-rendered `<input>`, the element carries no framework listener.
+ * What the user types is written to the DOM node, the `input` event reaches no model, and
+ * `v-model`'s mounted hook then writes the model value back over it — the entry is ERASED,
+ * not delayed.
+ *
+ * Vue fixed this in `vModelText` (vuejs/core#14411, shipped in 3.5.41): `created` records
+ * `el.defaultValue`, and `mounted` compares the live value against it. When they differ, the
+ * DOM value is pushed INTO the model instead of the node being overwritten.
+ *
+ * That adoption is gated on `el.type === 'text' || el.type === 'textarea'`. **Every other
+ * input type still falls through to the erasure** — `email`, `password`, `tel`, `url`,
+ * `search`, `number`. Verified against Vue 3.5.41 in `test/pre-hydration-input.test.ts`.
+ *
+ * Widening the gate is tracked upstream as vuejs/core#15210 (open, `p2-edge-case`, no
+ * milestone, PR #15211 pending). **This plugin is a stopgap for exactly that gap and should
+ * be deleted once the upstream fix lands** — the test above will start failing on the types
+ * Vue has taken over, which is the signal to remove it.
+ *
+ * ## Why this matters more than the gate suggests
+ *
+ * The uncovered types are precisely the ones a sign-in form uses. That is also where people
+ * type on sight, and where losing the entry is most expensive: a password silently truncated
+ * to its last few characters produces "invalid credentials", which sends the user down the
+ * wrong diagnostic path entirely.
+ *
+ * ## How it works
+ *
+ * At `app:beforeMount` the client bundle has loaded but hydration has not run, so every
+ * server-rendered field still holds whatever the user typed. A field is treated as edited
+ * when its live value differs from `defaultValue` — the same test Vue itself uses, so the
+ * server's own pre-filled values are never mistaken for user input.
+ *
+ * At `app:mounted` any field whose value was overwritten gets it back, followed by a
+ * synthetic `input` event so the framework's own listener adopts it. Setting `.value` alone
+ * would not do: the model would still hold the old value and the next render would wipe the
+ * node again.
+ *
+ * A browser autofill that landed before hydration is recovered the same way.
+ *
+ * ## Why not make the field `readonly` until mounted
+ *
+ * Declining the keystroke was the first approach tried and it is worse. The user is left with
+ * a field that looks usable and silently refuses, which reads as a broken page. It also costs
+ * real things: `readonly` is the documented technique for SUPPRESSING browser autofill,
+ * screen readers announce "read only" and never announce the silent flip back, and mobile
+ * browsers do not raise the on-screen keyboard for it. Preserving the entry avoids all of
+ * that, because the field is never anything other than a normal, editable field.
+ */
+type EditableField = HTMLInputElement | HTMLTextAreaElement;
+/**
+ * Collect fields the user edited before hydration.
+ *
+ * `value !== defaultValue` is the discriminator, matching Vue's own: `defaultValue` is what
+ * the server rendered, so a difference can only have come from the user (or from an autofill,
+ * which is just as worth keeping). Server-supplied values therefore never enter the snapshot
+ * and can never be restored over a legitimate change made during hydration.
+ */
+export declare function collectEditedFields(root: ParentNode): Map<EditableField, string>;
+/**
+ * Write a preserved value back onto a field and tell the framework about it.
+ *
+ * @returns `true` when a value was actually restored.
+ */
+export declare function restoreField(field: EditableField, value: string): boolean;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/pre-hydration-input.client.js

@@ -0,0 +1,57 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+export function collectEditedFields(root) {
+  const edited = /* @__PURE__ */ new Map();
+  for (const node of root.querySelectorAll("input, textarea")) {
+    const field = node;
+    if (field.value !== field.defaultValue) {
+      edited.set(field, field.value);
+    }
+  }
+  return edited;
+}
+export function restoreField(field, value) {
+  if (!field.isConnected || field.value === value) {
+    return false;
+  }
+  field.value = value;
+  field.dispatchEvent(new Event("input", { bubbles: true }));
+  return true;
+}
+export default defineNuxtPlugin({
+  // After the app's own plugins: the restore has to land once hydration has done its writes.
+  enforce: "post",
+  name: "lt-pre-hydration-input",
+  setup(nuxtApp) {
+    const options = useRuntimeConfig().public.ltExtensions?.preHydrationInput;
+    if (options?.enabled === false) {
+      return;
+    }
+    const maxRestoreMs = options?.maxRestoreMs ?? 1500;
+    let edited = /* @__PURE__ */ new Map();
+    nuxtApp.hook("app:beforeMount", () => {
+      edited = collectEditedFields(document);
+    });
+    nuxtApp.hook("app:mounted", () => {
+      if (edited.size === 0) {
+        return;
+      }
+      const sweep = () => {
+        for (const [field, value] of edited) {
+          if (restoreField(field, value)) {
+            edited.delete(field);
+          }
+        }
+      };
+      sweep();
+      if (maxRestoreMs <= 0) {
+        edited = /* @__PURE__ */ new Map();
+        return;
+      }
+      const interval = setInterval(sweep, 250);
+      setTimeout(() => {
+        clearInterval(interval);
+        edited = /* @__PURE__ */ new Map();
+      }, maxRestoreMs);
+    });
+  }
+});

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

@@ -1,5 +1,5 @@
 export type { LtAuthClientConfig, LtAuthMode, LtAuthResponse, LtAuthState, LtPasskeyAuthResult, LtPasskeyRegisterResult, LtUser, UseLtAuthReturn } from './auth.js';
 export type { LtFileInfo, LtUploadItem, LtUploadOptions, LtUploadProgress, LtUploadStatus, UseLtFileReturn, UseLtTusUploadReturn } from './upload.js';
-export type { LtAiModuleOptions, LtAuthCookieNamesOptions, LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtSystemSetupModuleOptions, LtTusModuleOptions, } from './module.js';
+export type { LtAiModuleOptions, LtAuthCookieNamesOptions, LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtFormLabelAssociationOptions, LtI18nModuleOptions, LtPreHydrationInputOptions, LtSystemSetupModuleOptions, LtTusModuleOptions, } from './module.js';
 export type { LtErrorTranslationResponse, LtParsedError, UseLtErrorTranslationReturn } from './error.js';
 export type { LtAiAction, LtAiAvailableConnection, LtAiBudgetLimit, LtAiBudgetSummary, LtAiConnection, LtAiConnectionInput, LtAiConnectionPreference, LtAiEffectiveSlot, LtAiInteraction, LtAiMessage, LtAiMode, LtAiPlaceholder, LtAiPrompt, LtAiPromptHint, LtAiPromptHintInput, LtAiPromptInput, LtAiPromptRunInput, LtAiResponse, LtAiSlot, LtAiSlotInput, LtAiStreamEvent, LtAiStreamHandlers, LtAiUsage, LtAiUsageInfo, LtAiUsageScope, UseLtAiAdminReturn, UseLtAiChatOptions, UseLtAiChatReturn, UseLtAiConnectionsReturn, UseLtAiPlaceholdersReturn, UseLtAiPromptsReturn, UseLtAiReturn, UseLtAiUsageReturn, } from './ai.js';

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

@@ -127,11 +127,116 @@ export interface LtExtensionsModuleOptions {
     auth?: LtAuthModuleOptions;
     /** Error translation configuration */
     errorTranslation?: LtErrorTranslationModuleOptions;
+    /** Form label association repair configuration */
+    formLabelAssociation?: LtFormLabelAssociationOptions;
     /** i18n configuration */
     i18n?: LtI18nModuleOptions;
+    /** Pre-hydration input preservation configuration */
+    preHydrationInput?: LtPreHydrationInputOptions;
     /** TUS upload module configuration */
     tus?: LtTusModuleOptions;
 }
+/**
+ * Repair of `<label for>` associations broken by an SSR/client `useId()` divergence.
+ *
+ * Nuxt UI's `FormField` derives the label's `for` and the control's `id` from ONE `useId()`
+ * call, so they cannot disagree — unless `useId()` itself returns different values on server
+ * and client, which it does whenever the two walk a different number of async boundaries.
+ * The label then keeps the server value while the control adopts the client one.
+ *
+ * The control loses its programmatic label. Without a placeholder it has no accessible name
+ * at all and a screen reader announces "edit text, blank"; with one, the placeholder becomes
+ * the name instead, so the visible label is no longer part of it and speech input stops
+ * working. Either way clicking the label focuses nothing — which on a checkbox or radio is
+ * the primary hit target, not a convenience.
+ *
+ * Vue >= 3.5.39 did not cause this, it exposed it: vuejs/core#9083 force-patches an element's
+ * dynamic props during hydration, and the control's `id` is one while the label's `for` —
+ * passed through reka-ui's `Label` component and `$attrs` — is not.
+ *
+ * The repair refuses to guess: it only fires when the field contains exactly one eligible
+ * control, so a radio or checkbox group is skipped rather than having every caption bound to
+ * its first option.
+ *
+ * @example
+ * ```ts
+ * export default defineNuxtConfig({
+ *   ltExtensions: {
+ *     formLabelAssociation: { enabled: false },
+ *   },
+ * });
+ * ```
+ */
+export interface LtFormLabelAssociationOptions {
+    /**
+     * Enable the repair. Defaults to `true`.
+     *
+     * Turn it off only with a reason. Two real ones: an application that assigns `for` itself
+     * and depends on those exact values, or a test suite asserting on literal `for` / `id`
+     * strings rather than on the accessible name. The alternative is a form whose fields carry
+     * no programmatic label.
+     */
+    enabled?: boolean;
+    /**
+     * How long after mount to keep repairing, in milliseconds. Defaults to `1500`; `0` sweeps
+     * once and stops.
+     *
+     * Most fields are repaired in the first pass. The window exists for server-rendered
+     * subtrees whose hydration is deferred — `hydrate-on-visible`, an unresolved `<Suspense>`,
+     * an island — which carry the same divergence but hydrate after `app:mounted`.
+     */
+    maxRepairMs?: number;
+}
+/**
+ * Pre-hydration input preservation.
+ *
+ * Until Vue hydrates a server-rendered `<input>`, the element carries no framework listener:
+ * text typed into it reaches no model and is then overwritten by the mounting value — ERASED,
+ * not delayed.
+ *
+ * Vue fixed this in 3.5.41 (vuejs/core#14411), but only for `type="text"` and `textarea`.
+ * Every other type still loses the entry: `email`, `password`, `tel`, `url`, `search`,
+ * `number` — precisely the fields a sign-in form uses, and where people are most likely to
+ * type on sight. Widening it is tracked upstream as vuejs/core#15210.
+ *
+ * This closes that remaining gap: what the user typed is read out of the DOM just before
+ * hydration and written back afterwards, with a synthetic `input` event so `v-model` adopts
+ * it. Fields stay ordinary editable fields throughout — nothing is made `readonly`, so
+ * autofill, screen-reader semantics and the mobile keyboard are untouched. A browser autofill
+ * that lands before hydration is recovered the same way.
+ *
+ * Applies to every `<input>` and `<textarea>` on the page, regardless of which UI library
+ * rendered it. It is a stopgap and is meant to be removed once Vue covers the remaining
+ * types.
+ *
+ * @example
+ * ```ts
+ * export default defineNuxtConfig({
+ *   ltExtensions: {
+ *     preHydrationInput: { enabled: false },
+ *   },
+ * });
+ * ```
+ */
+export interface LtPreHydrationInputOptions {
+    /**
+     * Enable preservation. Defaults to `true`.
+     *
+     * Turn it off only with a reason: the alternative is that a user who types immediately
+     * after a page appears loses the entry silently.
+     */
+    enabled?: boolean;
+    /**
+     * How long after mount to keep restoring, in milliseconds. Defaults to `1500`; `0` restores
+     * once and stops immediately.
+     *
+     * Most fields are repaired in the first pass. The window exists for subtrees whose mount is
+     * deferred — an unresolved `<Suspense>` boundary writes its model value later than
+     * `app:mounted`. When it elapses the snapshot is dropped, so preserved values, passwords
+     * included, are not kept alive for the session.
+     */
+    maxRestoreMs?: number;
+}
 /**
  * Public runtime config added by this module
  */
@@ -167,6 +272,14 @@ export interface LtExtensionsPublicRuntimeConfig {
             enabled: boolean;
             defaultLocale: string;
         };
+        formLabelAssociation: {
+            enabled: boolean;
+            maxRepairMs: number;
+        };
+        preHydrationInput: {
+            enabled: boolean;
+            maxRestoreMs: number;
+        };
         tus: {
             defaultChunkSize: number;
             defaultEndpoint: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nuxt-extensions",
-  "version": "1.11.2",
+  "version": "1.13.0",
   "description": "Reusable Nuxt 4 composables, components, and Better-Auth integration for lenne.tech projects",
   "repository": {
     "type": "git",
@@ -99,21 +99,22 @@
     }
   },
   "devDependencies": {
-    "@better-auth/passkey": "1.6.23",
-    "@nuxt/module-builder": "1.0.2",
+    "@better-auth/passkey": "1.7.1",
+    "@nuxt/module-builder": "1.0.3",
     "@nuxt/schema": "4.5.2",
-    "@playwright/test": "1.61.1",
-    "@types/node": "26.1.1",
-    "@vitest/coverage-v8": "4.1.10",
-    "better-auth": "1.6.23",
-    "happy-dom": "20.10.6",
+    "@playwright/test": "1.62.1",
+    "@types/node": "26.2.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "@vue/server-renderer": "3.5.41",
+    "better-auth": "1.7.1",
+    "happy-dom": "20.11.6",
     "nuxt": "4.5.2",
-    "oxfmt": "0.59.0",
-    "oxlint": "1.74.0",
+    "oxfmt": "0.64.0",
+    "oxlint": "1.79.0",
     "tus-js-client": "4.3.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.10",
-    "vue-tsc": "3.3.7"
+    "vitest": "4.1.11",
+    "vue-tsc": "3.3.11"
   },
   "keywords": [
     "nuxt",