@tanstack/lit-hotkeys 0.14.0 → 0.15.1

package/dist/controllers/_app-hotkeys.js

@@ -0,0 +1,11 @@
+import { getHotkeyManager } from "@tanstack/hotkeys";
+import { subscribePublishedAppHotkeys as subscribeAppHotkeys } from "@tanstack/hotkeys/adapter";
+
+//#region src/controllers/_app-hotkeys.ts
+/** The app hotkeys store published by `provideAppHotkeys`, if any. */
+function getAppHotkeysStore() {
+	return getHotkeyManager().appHotkeys.state;
+}
+
+//#endregion
+export { getAppHotkeysStore, subscribeAppHotkeys };

package/dist/controllers/app-hotkeys.d.ts

@@ -0,0 +1,48 @@
+import { AppHotkey, AppHotkeyListItem, CustomHotkeys, Hotkey, RegisteredAppHotkeys } from "@tanstack/hotkeys";
+import { ReactiveController, ReactiveControllerHost } from "lit";
+//#region src/controllers/app-hotkeys.d.ts
+/**
+ * A Lit ReactiveController for app hotkeys provided with `provideAppHotkeys`:
+ * the effective app hotkeys, a cheat sheet list with live status, and the
+ * user's custom hotkeys. Requests an update when any of them change.
+ *
+ * @example
+ * ```ts
+ * class CheatSheet extends LitElement {
+ *   private app = new AppHotkeysController(this)
+ *
+ *   render() {
+ *     return html`<ul>
+ *       ${this.app.list.map(
+ *         ({ appHotkey, status }) => html`<li>${appHotkey.meta?.name}: ${status}</li>`,
+ *       )}
+ *     </ul>`
+ *   }
+ * }
+ * ```
+ */
+export declare class AppHotkeysController implements ReactiveController {
+  private _host;
+  private _unsubscribe;
+  constructor(_host: ReactiveControllerHost);
+  /** Effective app hotkeys, typed by `Register`. */
+  get appHotkeys(): RegisteredAppHotkeys;
+  /** Every app hotkey with its live status, in declaration order. */
+  get list(): Array<AppHotkeyListItem<RegisteredAppHotkeys[keyof RegisteredAppHotkeys]>>;
+  /** The user's hotkeys that differ from the defaults. */
+  get customHotkeys(): CustomHotkeys;
+  /**
+   * Sets the user's hotkey for an app hotkey. `null` unbinds it.
+   * Returns conflicting app hotkeys; when any exist, nothing changes.
+   */
+  setCustomHotkey(id: keyof RegisteredAppHotkeys & string, hotkey: Hotkey | null): Array<AppHotkey>;
+  /** Restores the default hotkey for an app hotkey. */
+  resetCustomHotkey(id: keyof RegisteredAppHotkeys & string): void;
+  /** Restores every default hotkey. */
+  resetCustomHotkeys(): void;
+  /** Other app hotkeys that would collide if `id` used `hotkey`. */
+  findConflicts(id: keyof RegisteredAppHotkeys & string, hotkey: Hotkey): Array<AppHotkey>;
+  hostConnected(): void;
+  hostDisconnected(): void;
+}
+//#endregion

package/dist/controllers/app-hotkeys.js

@@ -0,0 +1,84 @@
+import { getAppHotkeysStore, subscribeAppHotkeys } from "./_app-hotkeys.js";
+import { getHotkeyManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+
+//#region src/controllers/app-hotkeys.ts
+function requireStore() {
+	const store = getAppHotkeysStore();
+	if (!store) throw new Error("AppHotkeysController requires provideAppHotkeys()");
+	return store;
+}
+/**
+* A Lit ReactiveController for app hotkeys provided with `provideAppHotkeys`:
+* the effective app hotkeys, a cheat sheet list with live status, and the
+* user's custom hotkeys. Requests an update when any of them change.
+*
+* @example
+* ```ts
+* class CheatSheet extends LitElement {
+*   private app = new AppHotkeysController(this)
+*
+*   render() {
+*     return html`<ul>
+*       ${this.app.list.map(
+*         ({ appHotkey, status }) => html`<li>${appHotkey.meta?.name}: ${status}</li>`,
+*       )}
+*     </ul>`
+*   }
+* }
+* ```
+*/
+var AppHotkeysController = class {
+	_host;
+	_unsubscribe;
+	constructor(_host) {
+		this._host = _host;
+		this._host.addController(this);
+	}
+	/** Effective app hotkeys, typed by `Register`. */
+	get appHotkeys() {
+		return requireStore().appHotkeys;
+	}
+	/** Every app hotkey with its live status, in declaration order. */
+	get list() {
+		return requireStore().getList(Array.from(getHotkeyManager().registrations.state.values()).map(toHotkeyRegistrationView));
+	}
+	/** The user's hotkeys that differ from the defaults. */
+	get customHotkeys() {
+		return requireStore().customHotkeys;
+	}
+	/**
+	* Sets the user's hotkey for an app hotkey. `null` unbinds it.
+	* Returns conflicting app hotkeys; when any exist, nothing changes.
+	*/
+	setCustomHotkey(id, hotkey) {
+		return requireStore().setCustomHotkey(id, hotkey);
+	}
+	/** Restores the default hotkey for an app hotkey. */
+	resetCustomHotkey(id) {
+		requireStore().resetCustomHotkey(id);
+	}
+	/** Restores every default hotkey. */
+	resetCustomHotkeys() {
+		requireStore().resetCustomHotkeys();
+	}
+	/** Other app hotkeys that would collide if `id` used `hotkey`. */
+	findConflicts(id, hotkey) {
+		return requireStore().findConflicts(id, hotkey);
+	}
+	hostConnected() {
+		const update = () => this._host.requestUpdate();
+		const unsubscribeAppHotkeys = subscribeAppHotkeys(update);
+		const registrations = getHotkeyManager().registrations.subscribe(update);
+		this._unsubscribe = () => {
+			unsubscribeAppHotkeys();
+			registrations.unsubscribe();
+		};
+	}
+	hostDisconnected() {
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
+	}
+};
+
+//#endregion
+export { AppHotkeysController };

package/dist/controllers/hotkey-hint.d.ts

@@ -1,4 +1,4 @@
-import { HeldModifierOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import { AppHotkey, HeldModifierOptions, RegisterableHotkey } from "@tanstack/hotkeys";
 import { ReactiveController, ReactiveControllerHost } from "lit";
 //#region src/controllers/hotkey-hint.d.ts
 /** Modifier hint controller. Getter arguments can read reactive host properties. */
@@ -9,7 +9,7 @@ export declare class HotkeyHintController implements ReactiveController {
   private unsubscribe?;
   private visible;
   /** Attaches to the host; getter arguments can read changing reactive properties. */
-  constructor(host: ReactiveControllerHost, hotkey: RegisterableHotkey | (() => RegisterableHotkey), options?: HeldModifierOptions | (() => HeldModifierOptions));
+  constructor(host: ReactiveControllerHost, hotkey: RegisterableHotkey | AppHotkey | (() => RegisterableHotkey | AppHotkey), options?: HeldModifierOptions | (() => HeldModifierOptions));
   /** Current visibility; combine with the action’s enabled state when rendering. */
   get value(): boolean;
   /** Subscribes on connection and requests renders only when hint visibility changes. */

package/dist/controllers/hotkey-hint.js

@@ -1,4 +1,5 @@
-import { getKeyStateTracker, matchesHeldModifiers } from "@tanstack/hotkeys";
+import { getAppHotkeysStore, subscribeAppHotkeys } from "./_app-hotkeys.js";
+import { getKeyStateTracker, isAppHotkey, matchesHeldModifiers, resolveAppHotkey } from "@tanstack/hotkeys";
 
 //#region src/controllers/hotkey-hint.ts
 /** Modifier hint controller. Getter arguments can read reactive host properties. */
@@ -22,10 +23,15 @@ var HotkeyHintController = class {
 	/** Subscribes on connection and requests renders only when hint visibility changes. */
 	hostConnected() {
 		this.update();
-		const subscription = getKeyStateTracker().store.subscribe(() => {
+		const refresh = () => {
 			if (this.update()) this.host.requestUpdate();
-		});
-		this.unsubscribe = () => subscription.unsubscribe();
+		};
+		const subscription = getKeyStateTracker().store.subscribe(refresh);
+		const unsubscribeAppHotkeys = subscribeAppHotkeys(refresh);
+		this.unsubscribe = () => {
+			subscription.unsubscribe();
+			unsubscribeAppHotkeys();
+		};
 	}
 	/** Re-evaluates getter arguments when host properties trigger an update. */
 	hostUpdate() {
@@ -39,7 +45,9 @@ var HotkeyHintController = class {
 	}
 	/** Recomputes visibility and reports whether the host needs another render. */
 	update() {
-		const next = matchesHeldModifiers(typeof this.hotkey === "function" ? this.hotkey() : this.hotkey, getKeyStateTracker().store.state.heldKeys, typeof this.options === "function" ? this.options() : this.options);
+		const value = typeof this.hotkey === "function" ? this.hotkey() : this.hotkey;
+		const hotkey = isAppHotkey(value) ? resolveAppHotkey(value, getAppHotkeysStore()).hotkey : value;
+		const next = hotkey !== null && matchesHeldModifiers(hotkey, getKeyStateTracker().store.state.heldKeys, typeof this.options === "function" ? this.options() : this.options);
 		const changed = next !== this.visible;
 		this.visible = next;
 		return changed;

package/dist/controllers/hotkey-recorder.d.ts

@@ -1,12 +1,14 @@
-import { Hotkey, HotkeyRecorderOptions } from "@tanstack/hotkeys";
+import { Hotkey, HotkeyChordRecorderOptions, HotkeyRecorderOptions, HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
 import { ReactiveController, ReactiveControllerHost } from "lit";
 //#region src/controllers/hotkey-recorder.d.ts
 /**
  * A Lit ReactiveController that records keyboard shortcuts.
  *
- * Wraps the framework-agnostic `HotkeyRecorder` class, managing all the
- * complexity of capturing keyboard events, converting them to hotkey strings,
- * and handling edge cases like Escape to cancel or Backspace/Delete to clear.
+ * With the default `maxSteps: 1`, the first valid chord is recorded. With a
+ * larger `maxSteps`, each chord adds a step; the recording commits on Enter
+ * (unless `commitKeys: 'none'`), after `idleTimeoutMs`, or at `maxSteps`, and
+ * `onRecord` receives a chord (one step) or a sequence. Escape cancels;
+ * Backspace/Delete removes the last step or clears.
  *
  * @example
  * ```ts
@@ -46,17 +48,25 @@ export declare class HotkeyRecorderController implements ReactiveController {
   private _unsubscribe;
   /** Whether recording is currently active. */
   private _isRecording;
-  /** The currently recorded hotkey (for live preview). */
+  /** The last committed hotkey. */
   private _recordedHotkey;
+  /** Chords recorded so far in a multi-step recording. */
+  private _steps;
   /** Whether recording is currently active. */
   get isRecording(): boolean;
-  /** The currently recorded hotkey (for live preview). */
+  /** The last committed hotkey: a chord, or a sequence of two or more steps. */
   get recordedHotkey(): Hotkey | null;
+  /** Chords recorded so far in a multi-step recording (for live preview). */
+  get steps(): HotkeySequence;
   /**
-   * @param _host - The Lit component that owns this controller.
-   * @param _options - Options or a getter, read during recording.
+   * @param host - The Lit component that owns this controller.
+   * @param options - Options or a getter, read during recording.
    */
-  constructor(_host: ReactiveControllerHost, _options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions));
+  constructor(host: ReactiveControllerHost, options: HotkeyChordRecorderOptions);
+  constructor(host: ReactiveControllerHost, options: HotkeySequenceRecorderOptions);
+  constructor(host: ReactiveControllerHost, options: () => HotkeySequenceRecorderOptions);
+  constructor(host: ReactiveControllerHost, options: () => HotkeyChordRecorderOptions);
+  constructor(host: ReactiveControllerHost, options: () => HotkeyRecorderOptions);
   /** Subscribes to the recorder store and updates the internal state when changes occur. */
   hostConnected(): void;
   /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */
@@ -69,5 +79,7 @@ export declare class HotkeyRecorderController implements ReactiveController {
   stopRecording(): void;
   /** Cancel recording without saving. */
   cancelRecording(): void;
+  /** Commit the recorded steps now (multi-step recordings). */
+  commitRecording(): void;
 }
 //#endregion

package/dist/controllers/hotkey-recorder.js

@@ -4,9 +4,11 @@ import { HotkeyRecorder } from "@tanstack/hotkeys";
 /**
 * A Lit ReactiveController that records keyboard shortcuts.
 *
-* Wraps the framework-agnostic `HotkeyRecorder` class, managing all the
-* complexity of capturing keyboard events, converting them to hotkey strings,
-* and handling edge cases like Escape to cancel or Backspace/Delete to clear.
+* With the default `maxSteps: 1`, the first valid chord is recorded. With a
+* larger `maxSteps`, each chord adds a step; the recording commits on Enter
+* (unless `commitKeys: 'none'`), after `idleTimeoutMs`, or at `maxSteps`, and
+* `onRecord` receives a chord (one step) or a sequence. Escape cancels;
+* Backspace/Delete removes the last step or clears.
 *
 * @example
 * ```ts
@@ -46,20 +48,22 @@ var HotkeyRecorderController = class {
 	_unsubscribe;
 	/** Whether recording is currently active. */
 	_isRecording = false;
-	/** The currently recorded hotkey (for live preview). */
+	/** The last committed hotkey. */
 	_recordedHotkey = null;
+	/** Chords recorded so far in a multi-step recording. */
+	_steps = [];
 	/** Whether recording is currently active. */
 	get isRecording() {
 		return this._isRecording;
 	}
-	/** The currently recorded hotkey (for live preview). */
+	/** The last committed hotkey: a chord, or a sequence of two or more steps. */
 	get recordedHotkey() {
 		return this._recordedHotkey;
 	}
-	/**
-	* @param _host - The Lit component that owns this controller.
-	* @param _options - Options or a getter, read during recording.
-	*/
+	/** Chords recorded so far in a multi-step recording (for live preview). */
+	get steps() {
+		return this._steps;
+	}
 	constructor(_host, _options) {
 		this._host = _host;
 		this._options = _options;
@@ -72,10 +76,11 @@ var HotkeyRecorderController = class {
 	/** Subscribes to the recorder store and updates the internal state when changes occur. */
 	hostConnected() {
 		const subscription = this._recorder.store.subscribe(() => {
-			const { isRecording, recordedHotkey } = this._recorder.store.state;
-			if (isRecording !== this._isRecording || recordedHotkey !== this._recordedHotkey) {
+			const { isRecording, recordedHotkey, steps } = this._recorder.store.state;
+			if (isRecording !== this._isRecording || recordedHotkey !== this._recordedHotkey || steps !== this._steps) {
 				this._isRecording = isRecording;
 				this._recordedHotkey = recordedHotkey;
+				this._steps = steps;
 				this._host.requestUpdate();
 			}
 		});
@@ -88,6 +93,7 @@ var HotkeyRecorderController = class {
 		this._recorder.stop();
 		this._isRecording = false;
 		this._recordedHotkey = null;
+		this._steps = [];
 	}
 	/** Updates the recorder options (e.g. callbacks). */
 	setOptions(options) {
@@ -108,6 +114,10 @@ var HotkeyRecorderController = class {
 	cancelRecording() {
 		this._recorder.cancel();
 	}
+	/** Commit the recorded steps now (multi-step recordings). */
+	commitRecording() {
+		this._recorder.commit();
+	}
 };
 
 //#endregion

package/dist/controllers/hotkey-registrations.d.ts

@@ -1,11 +1,10 @@
-import { HotkeyRegistrationView, SequenceRegistrationView } from "@tanstack/hotkeys";
+import { HotkeyRegistrationView } from "@tanstack/hotkeys";
 import { ReactiveController, ReactiveControllerHost } from "lit";
 //#region src/controllers/hotkey-registrations.d.ts
 /**
- * A Lit ReactiveController that tracks all hotkey and sequence registrations.
- *
- * Subscribes to the singleton HotkeyManager and SequenceManager stores and
- * triggers host updates whenever registrations change.
+ * A Lit ReactiveController that reads every hotkey registration, chords and
+ * sequences, from the singleton HotkeyManager and requests an update when
+ * they change. Narrow each view with `kind`.
  *
  * @example
  * ```ts
@@ -13,27 +12,21 @@ import { ReactiveController, ReactiveControllerHost } from "lit";
  *   private registrations = new HotkeyRegistrationsController(this)
  *
  *   render() {
- *     return html`
- *       <ul>
- *         ${this.registrations.hotkeys.map(
- *           (reg) => html`<li>${reg.options.meta?.name ?? reg.hotkey}</li>`,
- *         )}
- *       </ul>
- *     `
+ *     return html`<ul>
+ *       ${this.registrations.hotkeys.map(
+ *         (reg) => html`<li>${reg.options.meta?.name}: ${formatForDisplay(reg.hotkey)}</li>`,
+ *       )}
+ *     </ul>`
  *   }
  * }
  * ```
  */
 export declare class HotkeyRegistrationsController implements ReactiveController {
   private _host;
-  private _unsubscribeHotkeys;
-  private _unsubscribeSequences;
+  private _unsubscribe;
   private _hotkeys;
-  private _sequences;
-  /** All registered hotkeys (public view, no callbacks). */
+  /** Every registration, chords and sequences (public view, no callbacks). */
   get hotkeys(): Array<HotkeyRegistrationView>;
-  /** All registered sequences. */
-  get sequences(): Array<SequenceRegistrationView>;
   constructor(_host: ReactiveControllerHost);
   hostConnected(): void;
   hostDisconnected(): void;

package/dist/controllers/hotkey-registrations.js

@@ -1,11 +1,10 @@
-import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
+import { getHotkeyManager, toHotkeyRegistrationView } from "@tanstack/hotkeys";
 
 //#region src/controllers/hotkey-registrations.ts
 /**
-* A Lit ReactiveController that tracks all hotkey and sequence registrations.
-*
-* Subscribes to the singleton HotkeyManager and SequenceManager stores and
-* triggers host updates whenever registrations change.
+* A Lit ReactiveController that reads every hotkey registration, chords and
+* sequences, from the singleton HotkeyManager and requests an update when
+* they change. Narrow each view with `kind`.
 *
 * @example
 * ```ts
@@ -13,58 +12,41 @@ import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView } from "
 *   private registrations = new HotkeyRegistrationsController(this)
 *
 *   render() {
-*     return html`
-*       <ul>
-*         ${this.registrations.hotkeys.map(
-*           (reg) => html`<li>${reg.options.meta?.name ?? reg.hotkey}</li>`,
-*         )}
-*       </ul>
-*     `
+*     return html`<ul>
+*       ${this.registrations.hotkeys.map(
+*         (reg) => html`<li>${reg.options.meta?.name}: ${formatForDisplay(reg.hotkey)}</li>`,
+*       )}
+*     </ul>`
 *   }
 * }
 * ```
 */
 var HotkeyRegistrationsController = class {
 	_host;
-	_unsubscribeHotkeys;
-	_unsubscribeSequences;
+	_unsubscribe;
 	_hotkeys = [];
-	_sequences = [];
-	/** All registered hotkeys (public view, no callbacks). */
+	/** Every registration, chords and sequences (public view, no callbacks). */
 	get hotkeys() {
 		return this._hotkeys;
 	}
-	/** All registered sequences. */
-	get sequences() {
-		return this._sequences;
-	}
 	constructor(_host) {
 		this._host = _host;
 		this._host.addController(this);
 	}
 	hostConnected() {
-		const hotkeyManager = getHotkeyManager();
-		const sequenceManager = getSequenceManager();
-		const hotkeysSub = hotkeyManager.registrations.subscribe(() => {
-			this._hotkeys = Array.from(hotkeyManager.registrations.state.values()).map(toHotkeyRegistrationView);
-			this._host.requestUpdate();
-		});
-		const sequencesSub = sequenceManager.registrations.subscribe(() => {
-			this._sequences = Array.from(sequenceManager.registrations.state.values());
+		const manager = getHotkeyManager();
+		const read = () => Array.from(manager.registrations.state.values()).map(toHotkeyRegistrationView);
+		const subscription = manager.registrations.subscribe(() => {
+			this._hotkeys = read();
 			this._host.requestUpdate();
 		});
-		this._unsubscribeHotkeys = () => hotkeysSub.unsubscribe();
-		this._unsubscribeSequences = () => sequencesSub.unsubscribe();
-		this._hotkeys = Array.from(hotkeyManager.registrations.state.values()).map(toHotkeyRegistrationView);
-		this._sequences = Array.from(sequenceManager.registrations.state.values());
+		this._unsubscribe = () => subscription.unsubscribe();
+		this._hotkeys = read();
 	}
 	hostDisconnected() {
-		this._unsubscribeHotkeys?.();
-		this._unsubscribeSequences?.();
-		this._unsubscribeHotkeys = void 0;
-		this._unsubscribeSequences = void 0;
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
 		this._hotkeys = [];
-		this._sequences = [];
 	}
 };
 

package/dist/controllers/hotkey.d.ts

@@ -1,18 +1,42 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import { AppHotkey, HotkeyCallback, RegisterableHotkey, Target } from "@tanstack/hotkeys";
+import { AdapterAppHotkeyOptions, AdapterChordOptions, AdapterCommonOptions, AdapterHotkeyOptions, AdapterOptionsFor, AdapterSequenceOptions } from "@tanstack/hotkeys/adapter";
 import { ReactiveController, ReactiveControllerHost } from "lit";
 //#region src/controllers/hotkey.d.ts
+/** The element to listen on. A `null` target skips registration until it is set. */
+export type HotkeyControllerTarget = Target | null;
+/** Options shared by chords and sequences. */
+export type HotkeyControllerOptions = AdapterHotkeyOptions<HotkeyControllerTarget>;
+/** Options for a chord such as `'Mod+S'`. */
+export type HotkeyControllerChordOptions = AdapterChordOptions<HotkeyControllerTarget>;
+/** Options for a sequence such as `['G', 'G']`. */
+export type HotkeyControllerSequenceOptions = AdapterSequenceOptions<HotkeyControllerTarget>;
+/** Options for every kind; each applies to the kinds that support it. */
+export type HotkeyControllerCommonOptions = AdapterCommonOptions<HotkeyControllerTarget>;
+/** The options type for a hotkey: chord options for chords, sequence options for sequences. */
+export type HotkeyControllerOptionsFor<T extends RegisterableHotkey> = AdapterOptionsFor<T, HotkeyControllerTarget>;
+/** Call-site options for an app hotkey, typed by its declared default kind. */
+export type AppHotkeyControllerOptions<T extends AppHotkey = AppHotkey> = AdapterAppHotkeyOptions<T, HotkeyControllerTarget>;
+type MaybeGetter<T> = T | (() => T);
 /**
- * A Lit ReactiveController that registers a keyboard hotkey when the host
- * element is connected and unregisters it when the host is disconnected.
+ * A Lit ReactiveController that registers a hotkey when the host element is
+ * connected and unregisters it when the host is disconnected. The hotkey can
+ * be a chord such as `'Mod+S'`, a sequence such as `['G', 'G']`, or an app
+ * hotkey from `defineAppHotkeys`, which uses its custom hotkey from
+ * `provideAppHotkeys`.
+ *
+ * Chords accept `requireReset`; sequences accept `timeout`. Pass a getter for
+ * the hotkey or options to re-read them after each host update.
  *
  * @example
  * ```ts
  * class MyElement extends LitElement {
- *   private hotkey = new HotkeyController(this, 'Mod+S', () => this.save())
+ *   private save = new HotkeyController(this, 'Mod+S', () => this.doSave())
+ *   private top = new HotkeyController(this, ['G', 'G'], () => this.scrollToTop())
  *
  *   constructor() {
  *     super()
- *     this.addController(this.hotkey)
+ *     this.addController(this.save)
+ *     this.addController(this.top)
  *   }
  * }
  * ```
@@ -24,13 +48,15 @@ export declare class HotkeyController implements ReactiveController {
   private _bindings;
   private _connected;
   private _boundCallback;
+  private _unsubscribe;
   /**
-   * @param _host - The Lit component that owns this controller. Add the controller with `addController()`.
-   * @param _hotkey - The shortcut to register.
+   * @param host - The Lit component that owns this controller. Add the controller with `addController()`.
+   * @param hotkey - The chord, sequence, or app hotkey to register, or a getter. A getter is read on connection and after host updates.
    * @param callback - Called with the host as `this`.
-   * @param _options - Options or a getter. Property getters are read on connection and after host updates.
+   * @param options - Options or a getter. Property getters are read on connection and after host updates.
    */
-  constructor(_host: ReactiveControllerHost, _hotkey: RegisterableHotkey, callback: HotkeyCallback, _options?: HotkeyOptions | (() => HotkeyOptions));
+  constructor(host: ReactiveControllerHost, hotkey: MaybeGetter<AppHotkey>, callback: HotkeyCallback, options?: MaybeGetter<AppHotkeyControllerOptions>);
+  constructor(host: ReactiveControllerHost, hotkey: MaybeGetter<RegisterableHotkey>, callback: HotkeyCallback, options?: MaybeGetter<HotkeyControllerCommonOptions>);
   /** Registers when connected and a target is available. */
   hostConnected(): void;
   /** Refreshes options after rendering, when scoped targets are available. */

package/dist/controllers/hotkey.js

@@ -1,19 +1,27 @@
-import { HOTKEY_DEFAULT_OPTIONS } from "../constants.js";
-import { createHotkeyBindings } from "@tanstack/hotkeys/adapter";
+import { getAppHotkeysStore, subscribeAppHotkeys } from "./_app-hotkeys.js";
+import { createHotkeyBindings, prepareHotkeyDefinitions } from "@tanstack/hotkeys/adapter";
 
 //#region src/controllers/hotkey.ts
 /**
-* A Lit ReactiveController that registers a keyboard hotkey when the host
-* element is connected and unregisters it when the host is disconnected.
+* A Lit ReactiveController that registers a hotkey when the host element is
+* connected and unregisters it when the host is disconnected. The hotkey can
+* be a chord such as `'Mod+S'`, a sequence such as `['G', 'G']`, or an app
+* hotkey from `defineAppHotkeys`, which uses its custom hotkey from
+* `provideAppHotkeys`.
+*
+* Chords accept `requireReset`; sequences accept `timeout`. Pass a getter for
+* the hotkey or options to re-read them after each host update.
 *
 * @example
 * ```ts
 * class MyElement extends LitElement {
-*   private hotkey = new HotkeyController(this, 'Mod+S', () => this.save())
+*   private save = new HotkeyController(this, 'Mod+S', () => this.doSave())
+*   private top = new HotkeyController(this, ['G', 'G'], () => this.scrollToTop())
 *
 *   constructor() {
 *     super()
-*     this.addController(this.hotkey)
+*     this.addController(this.save)
+*     this.addController(this.top)
 *   }
 * }
 * ```
@@ -25,13 +33,8 @@ var HotkeyController = class {
 	_bindings = createHotkeyBindings();
 	_connected = false;
 	_boundCallback;
-	/**
-	* @param _host - The Lit component that owns this controller. Add the controller with `addController()`.
-	* @param _hotkey - The shortcut to register.
-	* @param callback - Called with the host as `this`.
-	* @param _options - Options or a getter. Property getters are read on connection and after host updates.
-	*/
-	constructor(_host, _hotkey, callback, _options = HOTKEY_DEFAULT_OPTIONS) {
+	_unsubscribe;
+	constructor(_host, _hotkey, callback, _options = {}) {
 		this._host = _host;
 		this._hotkey = _hotkey;
 		this._options = _options;
@@ -40,6 +43,7 @@ var HotkeyController = class {
 	/** Registers when connected and a target is available. */
 	hostConnected() {
 		this._connected = true;
+		this._unsubscribe = subscribeAppHotkeys(() => this._sync());
 		this._sync();
 	}
 	/** Refreshes options after rendering, when scoped targets are available. */
@@ -48,15 +52,20 @@ var HotkeyController = class {
 	}
 	_sync() {
 		const options = typeof this._options === "function" ? this._options() : this._options;
-		this._bindings.update([{
-			hotkey: this._hotkey,
+		this._bindings.update(prepareHotkeyDefinitions([{
+			hotkey: typeof this._hotkey === "function" ? this._hotkey() : this._hotkey,
 			callback: this._boundCallback,
 			options
-		}]);
+		}], {
+			appHotkeysStore: getAppHotkeysStore(),
+			resolveTarget: (target) => target
+		}));
 	}
 	/** Releases registrations when the host disconnects. */
 	hostDisconnected() {
 		this._connected = false;
+		this._unsubscribe?.();
+		this._unsubscribe = void 0;
 		this._bindings.destroy();
 	}
 };

package/dist/controllers/index.d.ts

@@ -1,10 +1,9 @@
+import { AppHotkeyControllerOptions, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget } from "./hotkey.js";
+import { AppHotkeysController } from "./app-hotkeys.js";
 import { HeldKeyCodesController } from "./held-key-codes.js";
 import { HeldKeysController } from "./held-keys.js";
-import { HotkeyController } from "./hotkey.js";
 import { HotkeyRecorderController } from "./hotkey-recorder.js";
 import { HotkeyRegistrationsController } from "./hotkey-registrations.js";
-import { HotkeySequenceController } from "./hotkey-sequence.js";
-import { HotkeySequenceRecorderController } from "./hotkey-sequence-recorder.js";
 import { KeyHoldController } from "./key-hold.js";
 import { HotkeyHintController } from "./hotkey-hint.js";
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController };
+export { AppHotkeyControllerOptions, AppHotkeysController, HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, KeyHoldController };

package/dist/controllers/key-hold.d.ts

@@ -49,8 +49,8 @@ export declare class KeyHoldController implements ReactiveController {
   /** Whether the tracked key is currently held down. */
   get value(): boolean;
   /**
-   * @param host - The Lit component that owns this controller.
-   * @param key - The key to track (e.g. 'Shift', 'Control', 'A').
+   * @param _host - The Lit component that owns this controller.
+   * @param _key - The key to track (e.g. 'Shift', 'Control', 'A').
    */
   constructor(_host: ReactiveControllerHost, _key: IndividualKey);
   hostConnected(): void;

package/dist/controllers/key-hold.js

@@ -51,8 +51,8 @@ var KeyHoldController = class {
 		return this._value;
 	}
 	/**
-	* @param host - The Lit component that owns this controller.
-	* @param key - The key to track (e.g. 'Shift', 'Control', 'A').
+	* @param _host - The Lit component that owns this controller.
+	* @param _key - The key to track (e.g. 'Shift', 'Control', 'A').
 	*/
 	constructor(_host, _key) {
 		this._host = _host;

package/dist/decorators/hotkey.d.ts

@@ -1,11 +1,14 @@
-import { HotkeyCallback, HotkeyOptions, RegisterableHotkey } from "@tanstack/hotkeys";
+import { AppHotkeyControllerOptions, HotkeyControllerOptionsFor } from "../controllers/hotkey.js";
+import { AppHotkey, HotkeyCallback, RegisterableHotkey } from "@tanstack/hotkeys";
 import { LitElement } from "lit";
 //#region src/decorators/hotkey.d.ts
+type HotkeyDecorator = <T extends HotkeyCallback>(proto: LitElement, propertyKey: string, descriptor?: TypedPropertyDescriptor<T>) => void;
 /**
- * Decorator that registers a keyboard hotkey on the element when it connects
- * and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.
+ * Decorator that registers a hotkey on the element when it connects and
+ * unregisters when it disconnects: a chord such as `'Mod+S'`, a sequence such
+ * as `['G', 'G']`, or an app hotkey. Uses {@link HotkeyController} under the hood.
  *
- * @param hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).
+ * @param hotkey - The chord, sequence, or app hotkey to listen for.
  * @param options - Optional registration options (target, platform, enabled, etc.).
  * @returns A method decorator for use on LitElement methods.
  *
@@ -15,10 +18,11 @@ import { LitElement } from "lit";
  *   @hotkey('Mod+S')
  *   save() { this.doSave() }
  *
- *   @hotkey('Escape')
- *   close() { this.dismiss() }
+ *   @hotkey(['G', 'G'], { timeout: 500 })
+ *   goToTop() { window.scrollTo(0, 0) }
  * }
  * ```
  */
-export declare function hotkey(hotkey: RegisterableHotkey, options?: HotkeyOptions): <T extends HotkeyCallback>(proto: LitElement, propertyKey: string, descriptor?: TypedPropertyDescriptor<T>) => void;
+export declare function hotkey<T extends AppHotkey>(hotkey: T, options?: AppHotkeyControllerOptions<T>): HotkeyDecorator;
+export declare function hotkey<T extends RegisterableHotkey>(hotkey: T, options?: HotkeyControllerOptionsFor<T>): HotkeyDecorator;
 //#endregion

package/dist/decorators/hotkey.js

@@ -1,27 +1,7 @@
-import { HOTKEY_DEFAULT_OPTIONS } from "../constants.js";
 import { HotkeyController } from "../controllers/hotkey.js";
 
 //#region src/decorators/hotkey.ts
-/**
-* Decorator that registers a keyboard hotkey on the element when it connects
-* and unregisters when it disconnects. Uses {@link HotkeyController} under the hood.
-*
-* @param hotkey - The key or key combo to listen for (e.g. `'Mod+S'` or a raw hotkey object).
-* @param options - Optional registration options (target, platform, enabled, etc.).
-* @returns A method decorator for use on LitElement methods.
-*
-* @example
-* ```ts
-* class MyElement extends LitElement {
-*   @hotkey('Mod+S')
-*   save() { this.doSave() }
-*
-*   @hotkey('Escape')
-*   close() { this.dismiss() }
-* }
-* ```
-*/
-function hotkey(hotkey, options = HOTKEY_DEFAULT_OPTIONS) {
+function hotkey(hotkey, options = {}) {
 	return function(proto, propertyKey, descriptor) {
 		const originalConnected = proto.connectedCallback;
 		const controllerKey = Symbol(`@hotkey:${propertyKey}`);

package/dist/decorators/index.d.ts

@@ -1,3 +1,2 @@
-import { hotkeySequence } from "./hotkey-sequence.js";
 import { hotkey } from "./hotkey.js";
-export { hotkey, hotkeySequence };
+export { hotkey };

package/dist/index.d.ts

@@ -1,15 +1,13 @@
-import { hotkeySequence } from "./decorators/hotkey-sequence.js";
+import { AppHotkeyControllerOptions, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget } from "./controllers/hotkey.js";
 import { hotkey } from "./decorators/hotkey.js";
 import "./decorators/index.js";
+import { AppHotkeysController } from "./controllers/app-hotkeys.js";
 import { HeldKeyCodesController } from "./controllers/held-key-codes.js";
 import { HeldKeysController } from "./controllers/held-keys.js";
-import { HotkeyController } from "./controllers/hotkey.js";
 import { HotkeyRecorderController } from "./controllers/hotkey-recorder.js";
 import { HotkeyRegistrationsController } from "./controllers/hotkey-registrations.js";
-import { HotkeySequenceController } from "./controllers/hotkey-sequence.js";
-import { HotkeySequenceRecorderController } from "./controllers/hotkey-sequence-recorder.js";
 import { KeyHoldController } from "./controllers/key-hold.js";
 import { HotkeyHintController } from "./controllers/hotkey-hint.js";
 import "./controllers/index.js";
 export * from "@tanstack/hotkeys";
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController, hotkey, hotkeySequence };
+export { AppHotkeyControllerOptions, AppHotkeysController, HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyControllerChordOptions, HotkeyControllerCommonOptions, HotkeyControllerOptions, HotkeyControllerOptionsFor, HotkeyControllerSequenceOptions, HotkeyControllerTarget, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, KeyHoldController, hotkey };

package/dist/index.js

@@ -1,15 +1,13 @@
-import { HotkeySequenceController } from "./controllers/hotkey-sequence.js";
-import { hotkeySequence } from "./decorators/hotkey-sequence.js";
 import { HotkeyController } from "./controllers/hotkey.js";
 import { hotkey } from "./decorators/hotkey.js";
+import { AppHotkeysController } from "./controllers/app-hotkeys.js";
 import { HeldKeyCodesController } from "./controllers/held-key-codes.js";
 import { HeldKeysController } from "./controllers/held-keys.js";
 import { HotkeyRecorderController } from "./controllers/hotkey-recorder.js";
 import { HotkeyRegistrationsController } from "./controllers/hotkey-registrations.js";
-import { HotkeySequenceRecorderController } from "./controllers/hotkey-sequence-recorder.js";
 import { KeyHoldController } from "./controllers/key-hold.js";
 import { HotkeyHintController } from "./controllers/hotkey-hint.js";
 
 export * from "@tanstack/hotkeys"
 
-export { HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, HotkeySequenceController, HotkeySequenceRecorderController, KeyHoldController, hotkey, hotkeySequence };
+export { AppHotkeysController, HeldKeyCodesController, HeldKeysController, HotkeyController, HotkeyHintController, HotkeyRecorderController, HotkeyRegistrationsController, KeyHoldController, hotkey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/lit-hotkeys",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Lit adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.11.0"
+    "@tanstack/hotkeys": "0.12.1"
   },
   "devDependencies": {
     "lit": "^3.3.3"

package/dist/constants.js

@@ -1,24 +0,0 @@
-//#region src/constants.ts
-const HOTKEY_DEFAULT_OPTIONS = {
-	enabled: true,
-	preventDefault: true,
-	stopPropagation: true,
-	eventType: "keydown",
-	requireReset: false,
-	ignoreInputs: void 0,
-	platform: void 0,
-	conflictBehavior: "warn"
-};
-const HOTKEY_SEQUENCE_DEFAULT_OPTIONS = {
-	enabled: true,
-	timeout: 1e3,
-	preventDefault: true,
-	stopPropagation: true,
-	eventType: "keydown",
-	ignoreInputs: void 0,
-	platform: void 0,
-	conflictBehavior: "warn"
-};
-
-//#endregion
-export { HOTKEY_DEFAULT_OPTIONS, HOTKEY_SEQUENCE_DEFAULT_OPTIONS };

package/dist/controllers/hotkey-sequence-recorder.d.ts

@@ -1,81 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-import { ReactiveController, ReactiveControllerHost } from "lit";
-//#region src/controllers/hotkey-sequence-recorder.d.ts
-/**
- * A Lit ReactiveController that records multi-chord sequences (Vim-style shortcuts).
- *
- * Wraps the framework-agnostic `HotkeySequenceRecorder` class, managing store
- * subscriptions and host update lifecycle automatically.
- *
- * @example
- * ```ts
- * class ShortcutSettings extends LitElement {
- *   private recorder = new HotkeySequenceRecorderController(this, {
- *     onRecord: (sequence) => {
- *       this.sequence = sequence
- *       this.requestUpdate()
- *     },
- *     onCancel: () => {
- *       console.log('Recording cancelled')
- *     },
- *   })
- *
- *   private sequence: HotkeySequence | null = null
- *
- *   render() {
- *     return html`
- *       <button @click=${() => this.recorder.startRecording()}>
- *         ${this.recorder.isRecording ? 'Recording...' : 'Edit Sequence'}
- *       </button>
- *       ${this.recorder.steps.length
- *         ? html`<div>Steps: ${this.recorder.steps.join(' → ')}</div>`
- *         : nothing}
- *       ${this.recorder.recordedSequence
- *         ? html`<div>Recorded: ${this.recorder.recordedSequence.join(' → ')}</div>`
- *         : nothing}
- *     `
- *   }
- * }
- * ```
- */
-export declare class HotkeySequenceRecorderController implements ReactiveController {
-  private _host;
-  private _options;
-  /** The recorder instance. */
-  private _recorder;
-  private _optionOverrides;
-  /** The unsubscribe function. */
-  private _unsubscribe;
-  /** Whether recording is currently active. */
-  private _isRecording;
-  /** Chords captured in the current session. */
-  private _steps;
-  /** Last committed sequence, or null if none. */
-  private _recordedSequence;
-  /** Whether recording is currently active. */
-  get isRecording(): boolean;
-  /** Chords captured in the current session. */
-  get steps(): HotkeySequence;
-  /** Last committed sequence, or null if none. */
-  get recordedSequence(): HotkeySequence | null;
-  /**
-   * @param _host - The Lit component that owns this controller.
-   * @param _options - Options or a getter, read during recording.
-   */
-  constructor(_host: ReactiveControllerHost, _options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions));
-  /** Subscribes to the recorder store and updates internal state when changes occur. */
-  hostConnected(): void;
-  /** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */
-  hostDisconnected(): void;
-  /** Updates the recorder options. */
-  setOptions(options: Partial<HotkeySequenceRecorderOptions>): void;
-  /** Start recording a new sequence. */
-  startRecording(): void;
-  /** Stop recording (same as cancel but without calling onCancel). */
-  stopRecording(): void;
-  /** Cancel recording without saving. */
-  cancelRecording(): void;
-  /** Commit current steps as a sequence (no-op if empty). */
-  commitRecording(): void;
-}
-//#endregion

package/dist/controllers/hotkey-sequence-recorder.js

@@ -1,128 +0,0 @@
-import { HotkeySequenceRecorder } from "@tanstack/hotkeys";
-
-//#region src/controllers/hotkey-sequence-recorder.ts
-/**
-* A Lit ReactiveController that records multi-chord sequences (Vim-style shortcuts).
-*
-* Wraps the framework-agnostic `HotkeySequenceRecorder` class, managing store
-* subscriptions and host update lifecycle automatically.
-*
-* @example
-* ```ts
-* class ShortcutSettings extends LitElement {
-*   private recorder = new HotkeySequenceRecorderController(this, {
-*     onRecord: (sequence) => {
-*       this.sequence = sequence
-*       this.requestUpdate()
-*     },
-*     onCancel: () => {
-*       console.log('Recording cancelled')
-*     },
-*   })
-*
-*   private sequence: HotkeySequence | null = null
-*
-*   render() {
-*     return html`
-*       <button @click=${() => this.recorder.startRecording()}>
-*         ${this.recorder.isRecording ? 'Recording...' : 'Edit Sequence'}
-*       </button>
-*       ${this.recorder.steps.length
-*         ? html`<div>Steps: ${this.recorder.steps.join(' → ')}</div>`
-*         : nothing}
-*       ${this.recorder.recordedSequence
-*         ? html`<div>Recorded: ${this.recorder.recordedSequence.join(' → ')}</div>`
-*         : nothing}
-*     `
-*   }
-* }
-* ```
-*/
-var HotkeySequenceRecorderController = class {
-	_host;
-	_options;
-	/** The recorder instance. */
-	_recorder;
-	_optionOverrides = {};
-	/** The unsubscribe function. */
-	_unsubscribe;
-	/** Whether recording is currently active. */
-	_isRecording = false;
-	/** Chords captured in the current session. */
-	_steps = [];
-	/** Last committed sequence, or null if none. */
-	_recordedSequence = null;
-	/** Whether recording is currently active. */
-	get isRecording() {
-		return this._isRecording;
-	}
-	/** Chords captured in the current session. */
-	get steps() {
-		return this._steps;
-	}
-	/** Last committed sequence, or null if none. */
-	get recordedSequence() {
-		return this._recordedSequence;
-	}
-	/**
-	* @param _host - The Lit component that owns this controller.
-	* @param _options - Options or a getter, read during recording.
-	*/
-	constructor(_host, _options) {
-		this._host = _host;
-		this._options = _options;
-		this._recorder = new HotkeySequenceRecorder(() => ({
-			...typeof this._options === "function" ? this._options() : this._options,
-			...this._optionOverrides
-		}));
-		this._host.addController(this);
-	}
-	/** Subscribes to the recorder store and updates internal state when changes occur. */
-	hostConnected() {
-		const subscription = this._recorder.store.subscribe(() => {
-			const { isRecording, steps, recordedSequence } = this._recorder.store.state;
-			if (isRecording !== this._isRecording || steps !== this._steps || recordedSequence !== this._recordedSequence) {
-				this._isRecording = isRecording;
-				this._steps = steps;
-				this._recordedSequence = recordedSequence;
-				this._host.requestUpdate();
-			}
-		});
-		this._unsubscribe = () => subscription.unsubscribe();
-	}
-	/** Unsubscribes from the recorder store and destroys the recorder instance to prevent memory leaks. */
-	hostDisconnected() {
-		this._unsubscribe?.();
-		this._unsubscribe = void 0;
-		this._recorder.stop();
-		this._isRecording = false;
-		this._steps = [];
-		this._recordedSequence = null;
-	}
-	/** Updates the recorder options. */
-	setOptions(options) {
-		this._optionOverrides = {
-			...this._optionOverrides,
-			...options
-		};
-	}
-	/** Start recording a new sequence. */
-	startRecording() {
-		this._recorder.start();
-	}
-	/** Stop recording (same as cancel but without calling onCancel). */
-	stopRecording() {
-		this._recorder.stop();
-	}
-	/** Cancel recording without saving. */
-	cancelRecording() {
-		this._recorder.cancel();
-	}
-	/** Commit current steps as a sequence (no-op if empty). */
-	commitRecording() {
-		this._recorder.commit();
-	}
-};
-
-//#endregion
-export { HotkeySequenceRecorderController };

package/dist/controllers/hotkey-sequence.d.ts

@@ -1,42 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-import { ReactiveController, ReactiveControllerHost } from "lit";
-//#region src/controllers/hotkey-sequence.d.ts
-/**
- * A Lit ReactiveController that registers a keyboard sequence (e.g. Vim-style)
- * when the host element is connected and unregisters it when the host is disconnected.
- *
- * @example
- * ```ts
- * class MyElement extends LitElement {
- *   private seq = new HotkeySequenceController(this, ['G', 'G'], () => this.goToTop())
- *
- *   constructor() {
- *     super()
- *     this.addController(this.seq)
- *   }
- * }
- * ```
- */
-export declare class HotkeySequenceController implements ReactiveController {
-  private _host;
-  private _sequence;
-  private _options;
-  private _bindings;
-  private _connected;
-  private _boundCallback;
-  /**
-   * @param _host - The Lit component that owns this controller. Add the controller with `addController()`.
-   * @param _sequence - The sequence to register.
-   * @param callback - Called with the host as `this`.
-   * @param _options - Options or a getter. Property getters are read on connection and after host updates.
-   */
-  constructor(_host: ReactiveControllerHost, _sequence: HotkeySequence, callback: HotkeyCallback, _options?: SequenceOptions | (() => SequenceOptions));
-  /** Registers when connected and a target is available. */
-  hostConnected(): void;
-  /** Refreshes options after rendering, when scoped targets are available. */
-  hostUpdated(): void;
-  private _sync;
-  /** Releases registrations when the host disconnects. */
-  hostDisconnected(): void;
-}
-//#endregion

package/dist/controllers/hotkey-sequence.js

@@ -1,65 +0,0 @@
-import { HOTKEY_SEQUENCE_DEFAULT_OPTIONS } from "../constants.js";
-import { createHotkeySequenceBindings } from "@tanstack/hotkeys/adapter";
-
-//#region src/controllers/hotkey-sequence.ts
-/**
-* A Lit ReactiveController that registers a keyboard sequence (e.g. Vim-style)
-* when the host element is connected and unregisters it when the host is disconnected.
-*
-* @example
-* ```ts
-* class MyElement extends LitElement {
-*   private seq = new HotkeySequenceController(this, ['G', 'G'], () => this.goToTop())
-*
-*   constructor() {
-*     super()
-*     this.addController(this.seq)
-*   }
-* }
-* ```
-*/
-var HotkeySequenceController = class {
-	_host;
-	_sequence;
-	_options;
-	_bindings = createHotkeySequenceBindings();
-	_connected = false;
-	_boundCallback;
-	/**
-	* @param _host - The Lit component that owns this controller. Add the controller with `addController()`.
-	* @param _sequence - The sequence to register.
-	* @param callback - Called with the host as `this`.
-	* @param _options - Options or a getter. Property getters are read on connection and after host updates.
-	*/
-	constructor(_host, _sequence, callback, _options = HOTKEY_SEQUENCE_DEFAULT_OPTIONS) {
-		this._host = _host;
-		this._sequence = _sequence;
-		this._options = _options;
-		this._boundCallback = callback.bind(this._host);
-	}
-	/** Registers when connected and a target is available. */
-	hostConnected() {
-		this._connected = true;
-		this._sync();
-	}
-	/** Refreshes options after rendering, when scoped targets are available. */
-	hostUpdated() {
-		if (this._connected) this._sync();
-	}
-	_sync() {
-		const options = typeof this._options === "function" ? this._options() : this._options;
-		this._bindings.update([{
-			sequence: this._sequence,
-			callback: this._boundCallback,
-			options
-		}]);
-	}
-	/** Releases registrations when the host disconnects. */
-	hostDisconnected() {
-		this._connected = false;
-		this._bindings.destroy();
-	}
-};
-
-//#endregion
-export { HotkeySequenceController };

package/dist/decorators/hotkey-sequence.d.ts

@@ -1,25 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-import { LitElement } from "lit";
-//#region src/decorators/hotkey-sequence.d.ts
-/**
- * Decorator that registers a keyboard sequence (e.g. Vim-style) on the element
- * when it connects and unregisters when it disconnects. Uses
- * {@link HotkeySequenceController} under the hood.
- *
- * @param sequence - The key sequence to listen for (e.g. `['G', 'G']` for "g g").
- * @param options - Optional sequence options (target, timeout, enabled, etc.).
- * @returns A method decorator for use on LitElement methods.
- *
- * @example
- * ```ts
- * class MyElement extends LitElement {
- *   @hotkeySequence(['G', 'G'])
- *   goToTop() { window.scrollTo(0, 0) }
- *
- *   @hotkeySequence(['D', 'D'], { timeout: 500 })
- *   deleteLine() { this.deleteCurrentLine() }
- * }
- * ```
- */
-export declare function hotkeySequence(sequence: HotkeySequence, options?: SequenceOptions): <T extends HotkeyCallback>(proto: LitElement, methodName: string, descriptor: TypedPropertyDescriptor<T>) => void;
-//#endregion

package/dist/decorators/hotkey-sequence.js

@@ -1,44 +0,0 @@
-import { HOTKEY_SEQUENCE_DEFAULT_OPTIONS } from "../constants.js";
-import { HotkeySequenceController } from "../controllers/hotkey-sequence.js";
-
-//#region src/decorators/hotkey-sequence.ts
-/**
-* Decorator that registers a keyboard sequence (e.g. Vim-style) on the element
-* when it connects and unregisters when it disconnects. Uses
-* {@link HotkeySequenceController} under the hood.
-*
-* @param sequence - The key sequence to listen for (e.g. `['G', 'G']` for "g g").
-* @param options - Optional sequence options (target, timeout, enabled, etc.).
-* @returns A method decorator for use on LitElement methods.
-*
-* @example
-* ```ts
-* class MyElement extends LitElement {
-*   @hotkeySequence(['G', 'G'])
-*   goToTop() { window.scrollTo(0, 0) }
-*
-*   @hotkeySequence(['D', 'D'], { timeout: 500 })
-*   deleteLine() { this.deleteCurrentLine() }
-* }
-* ```
-*/
-function hotkeySequence(sequence, options = HOTKEY_SEQUENCE_DEFAULT_OPTIONS) {
-	return function(proto, methodName, descriptor) {
-		const originalConnected = proto.connectedCallback;
-		const controllerKey = Symbol(`@hotkeySequence:${methodName}`);
-		proto.connectedCallback = function() {
-			originalConnected.call(this);
-			const host = this;
-			if (!host[controllerKey]) {
-				const callback = descriptor.value ? descriptor.value.bind(this) : host[methodName].bind(this);
-				if (typeof callback !== "function") throw new Error(`@hotkeySequence decorator can only be applied to functions`);
-				const controller = new HotkeySequenceController(this, sequence, callback, options);
-				host[controllerKey] = controller;
-				this.addController(controller);
-			}
-		};
-	};
-}
-
-//#endregion
-export { hotkeySequence };