ci: apply automated fixes

Author: autofix-ci[bot]

docs/framework/react/reference/functions/useHotkey.md

@@ -12,19 +12,24 @@ function useHotkey(
    options): void;
 ```
 
-Defined in: [useHotkey.ts:71](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L71)
+Defined in: [useHotkey.ts:83](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L83)
 
 React hook for registering a keyboard hotkey.
 
 Uses the singleton HotkeyManager for efficient event handling.
 The callback receives both the keyboard event and a context object
 containing the hotkey string and parsed hotkey.
 
+This hook syncs the callback and options on every render to avoid
+stale closures, similar to TanStack Pacer's pattern. This means
+callbacks that reference React state will always have access to
+the latest values.
+
 ## Parameters
 
 ### hotkey
 
-The hotkey string (e.g., 'Mod+S', 'Escape')
+The hotkey string (e.g., 'Mod+S', 'Escape') or ParsedHotkey object
 
 `Hotkey` | `ParsedHotkey`
 
@@ -48,18 +53,21 @@ Options for the hotkey behavior
 
 ```tsx
 function SaveButton() {
-  useHotkey('Mod+S', (event, { hotkey, parsedHotkey }) => {
-    console.log(`${hotkey} was pressed`)
+  const [count, setCount] = useState(0)
+
+  // Callback always has access to latest count value
+  useHotkey('Mod+S', (event, { hotkey }) => {
+    console.log(`Save triggered, count is ${count}`)
     handleSave()
   }, { preventDefault: true })
 
-  return <button>Save</button>
+  return <button onClick={() => setCount(c => c + 1)}>Count: {count}</button>
 }
 ```
 
 ```tsx
 function Modal({ isOpen, onClose }) {
-  // Only active when modal is open
+  // enabled option is synced on every render
   useHotkey('Escape', () => {
     onClose()
   }, { enabled: isOpen })
@@ -71,11 +79,13 @@ function Modal({ isOpen, onClose }) {
 
 ```tsx
 function Editor() {
-  // Prevent repeated triggering while holding
+  const editorRef = useRef<HTMLDivElement>(null)
+
+  // Scoped to a specific element
   useHotkey('Mod+S', () => {
     save()
-  }, { preventDefault: true, requireReset: true })
+  }, { target: editorRef, preventDefault: true })
 
-  return <div>...</div>
+  return <div ref={editorRef}>...</div>
 }
 ```

docs/framework/react/reference/interfaces/UseHotkeyOptions.md

@@ -5,26 +5,14 @@ title: UseHotkeyOptions
 
 # Interface: UseHotkeyOptions
 
-Defined in: [useHotkey.ts:10](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L10)
+Defined in: [useHotkey.ts:11](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L11)
 
 ## Extends
 
-- `Omit`\<`HotkeyOptions`, `"enabled"` \| `"target"`\>
+- `Omit`\<`HotkeyOptions`, `"target"`\>
 
 ## Properties
 
-### enabled?
-
-```ts
-optional enabled: boolean;
-```
-
-Defined in: [useHotkey.ts:12](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L12)
-
-Whether the hotkey is enabled. Defaults to true.
-
-***
-
 ### target?
 
 ```ts
@@ -36,6 +24,8 @@ optional target:
   | null;
 ```
 
-Defined in: [useHotkey.ts:14](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L14)
+Defined in: [useHotkey.ts:17](https://github.com/TanStack/keys/blob/main/packages/react-keys/src/useHotkey.ts#L17)
 
-The DOM element or React ref to attach the event listener to. Defaults to document.
+The DOM element to attach the event listener to.
+Can be a React ref, direct DOM element, or null.
+Defaults to document.

docs/reference/classes/HotkeyManager.md

@@ -5,7 +5,7 @@ title: HotkeyManager
 
 # Class: HotkeyManager
 
-Defined in: [manager.ts:40](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L40)
+Defined in: [manager.ts:56](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L56)
 
 Singleton manager for hotkey registrations.
 
@@ -34,7 +34,7 @@ unregister()
 destroy(): void;
 ```
 
-Defined in: [manager.ts:459](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L459)
+Defined in: [manager.ts:526](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L526)
 
 Destroys the manager and removes all listeners.
 
@@ -50,7 +50,7 @@ Destroys the manager and removes all listeners.
 getRegistrationCount(): number;
 ```
 
-Defined in: [manager.ts:440](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L440)
+Defined in: [manager.ts:497](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L497)
 
 Gets the number of registered hotkeys.
 
@@ -63,10 +63,10 @@ Gets the number of registered hotkeys.
 ### isRegistered()
 
 ```ts
-isRegistered(hotkey): boolean;
+isRegistered(hotkey, target?): boolean;
 ```
 
-Defined in: [manager.ts:447](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L447)
+Defined in: [manager.ts:508](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L508)
 
 Checks if a specific hotkey is registered.
 
@@ -76,10 +76,20 @@ Checks if a specific hotkey is registered.
 
 [`Hotkey`](../type-aliases/Hotkey.md)
 
+The hotkey string to check
+
+##### target?
+
+Optional target element to match (if provided, both hotkey and target must match)
+
+`HTMLElement` | `Document` | `Window`
+
 #### Returns
 
 `boolean`
 
+True if a matching registration exists
+
 ***
 
 ### register()
@@ -88,12 +98,15 @@ Checks if a specific hotkey is registered.
 register(
    hotkey, 
    callback, 
-   options): () => void;
+   options): HotkeyRegistrationHandle;
 ```
 
-Defined in: [manager.ts:89](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L89)
+Defined in: [manager.ts:122](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L122)
+
+Registers a hotkey handler and returns a handle for updating the registration.
 
-Registers a hotkey handler.
+The returned handle allows updating the callback and options without
+re-registering, which is useful for avoiding stale closures in React.
 
 #### Parameters
 
@@ -117,15 +130,24 @@ Options for the hotkey behavior
 
 #### Returns
 
-A function to unregister the hotkey
+[`HotkeyRegistrationHandle`](../interfaces/HotkeyRegistrationHandle.md)
+
+A handle for managing the registration
+
+#### Example
 
 ```ts
-(): void;
-```
+const handle = manager.register('Mod+S', callback, { preventDefault: true })
 
-##### Returns
+// Update callback without re-registering (avoids stale closures)
+handle.callback = newCallback
 
-`void`
+// Update options
+handle.setOptions({ enabled: false })
+
+// Unregister when done
+handle.unregister()
+```
 
 ***
 
@@ -135,7 +157,7 @@ A function to unregister the hotkey
 static getInstance(): HotkeyManager;
 ```
 
-Defined in: [manager.ts:64](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L64)
+Defined in: [manager.ts:80](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L80)
 
 Gets the singleton instance of HotkeyManager.
 
@@ -151,7 +173,7 @@ Gets the singleton instance of HotkeyManager.
 static resetInstance(): void;
 ```
 
-Defined in: [manager.ts:74](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L74)
+Defined in: [manager.ts:90](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L90)
 
 Resets the singleton instance. Useful for testing.
 

docs/reference/functions/getHotkeyManager.md

@@ -9,7 +9,7 @@ title: getHotkeyManager
 function getHotkeyManager(): HotkeyManager;
 ```
 
-Defined in: [manager.ts:475](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L475)
+Defined in: [manager.ts:542](https://github.com/TanStack/keys/blob/main/packages/keys/src/manager.ts#L542)
 
 Gets the singleton HotkeyManager instance.
 Convenience function for accessing the manager.

docs/reference/index.md

@@ -18,6 +18,7 @@ title: "@tanstack/keys"
 - [HotkeyCallbackContext](interfaces/HotkeyCallbackContext.md)
 - [HotkeyOptions](interfaces/HotkeyOptions.md)
 - [HotkeyRegistration](interfaces/HotkeyRegistration.md)
+- [HotkeyRegistrationHandle](interfaces/HotkeyRegistrationHandle.md)
 - [KeyStateTrackerState](interfaces/KeyStateTrackerState.md)
 - [ParsedHotkey](interfaces/ParsedHotkey.md)
 - [SequenceOptions](interfaces/SequenceOptions.md)

docs/reference/interfaces/HotkeyRegistrationHandle.md

@@ -0,0 +1,110 @@
+---
+id: HotkeyRegistrationHandle
+title: HotkeyRegistrationHandle
+---
+
+# Interface: HotkeyRegistrationHandle
+
+Defined in: [types.ts:492](https://github.com/TanStack/keys/blob/main/packages/keys/src/types.ts#L492)
+
+A handle returned from HotkeyManager.register() that allows updating
+the callback and options without re-registering the hotkey.
+
+This pattern is similar to TanStack Pacer's Debouncer, where the function
+and options can be synced on every render to avoid stale closures.
+
+## Example
+
+```ts
+const handle = manager.register('Mod+S', callback, options)
+
+// Update callback without re-registering (avoids stale closures)
+handle.callback = newCallback
+
+// Update options without re-registering
+handle.setOptions({ enabled: false })
+
+// Check if still active
+if (handle.isActive) {
+  // ...
+}
+
+// Unregister when done
+handle.unregister()
+```
+
+## Properties
+
+### callback
+
+```ts
+callback: HotkeyCallback;
+```
+
+Defined in: [types.ts:503](https://github.com/TanStack/keys/blob/main/packages/keys/src/types.ts#L503)
+
+The callback function. Can be set directly to update without re-registering.
+This avoids stale closures when the callback references React state.
+
+***
+
+### id
+
+```ts
+readonly id: string;
+```
+
+Defined in: [types.ts:494](https://github.com/TanStack/keys/blob/main/packages/keys/src/types.ts#L494)
+
+Unique identifier for this registration
+
+***
+
+### isActive
+
+```ts
+readonly isActive: boolean;
+```
+
+Defined in: [types.ts:512](https://github.com/TanStack/keys/blob/main/packages/keys/src/types.ts#L512)
+
+Check if this registration is still active (not unregistered)
+
+***
+
+### setOptions()
+
+```ts
+setOptions: (options) => void;
+```
+
+Defined in: [types.ts:509](https://github.com/TanStack/keys/blob/main/packages/keys/src/types.ts#L509)
+
+Update options (merged with existing options).
+Useful for updating `enabled`, `preventDefault`, etc. without re-registering.
+
+#### Parameters
+
+##### options
+
+`Partial`\<[`HotkeyOptions`](HotkeyOptions.md)\>
+
+#### Returns
+
+`void`
+
+***
+
+### unregister()
+
+```ts
+unregister: () => void;
+```
+
+Defined in: [types.ts:497](https://github.com/TanStack/keys/blob/main/packages/keys/src/types.ts#L497)
+
+Unregister this hotkey
+
+#### Returns
+
+`void`

packages/keys/src/manager.ts

@@ -130,7 +130,8 @@ export class HotkeyManager {
 
     // Resolve target: default to document if not provided or null
     const target =
-      options.target ?? (typeof document !== 'undefined' ? document : ({} as Document))
+      options.target ??
+      (typeof document !== 'undefined' ? document : ({} as Document))
 
     const registration: HotkeyRegistration = {
       id,
@@ -504,7 +505,10 @@ export class HotkeyManager {
    * @param target - Optional target element to match (if provided, both hotkey and target must match)
    * @returns True if a matching registration exists
    */
-  isRegistered(hotkey: Hotkey, target?: HTMLElement | Document | Window): boolean {
+  isRegistered(
+    hotkey: Hotkey,
+    target?: HTMLElement | Document | Window,
+  ): boolean {
     for (const registration of this.registrations.values()) {
       if (registration.hotkey === hotkey) {
         // If target is specified, both must match