@tanstack/hotkeys 0.11.0 → 0.12.1

package/dist/hotkey-recorder.d.ts

@@ -1,4 +1,4 @@
-import { Hotkey } from "./hotkey.types.js";
+import { Hotkey, HotkeyChord, HotkeySequence } from "./hotkey.types.js";
 import { HotkeyRecorderValidationContext, RecorderOptions } from "./recorder-options.js";
 import { Store } from "@tanstack/store";
 //#region src/hotkey-recorder.d.ts
@@ -8,78 +8,97 @@ import { Store } from "@tanstack/store";
 export interface HotkeyRecorderState {
   /** Whether recording is currently active */
   isRecording: boolean;
-  /** The currently recorded hotkey (for live preview) */
+  /** Chords recorded so far in a multi-step recording (empty for `maxSteps: 1`) */
+  steps: HotkeySequence;
+  /** The last committed hotkey: a chord, or a sequence of two or more steps */
   recordedHotkey: Hotkey | null;
 }
-/**
- * Options for configuring a HotkeyRecorder instance.
- */
-export interface HotkeyRecorderOptions extends RecorderOptions {
-  /** Return true to accept, or false/a message to reject while staying in recording mode. */
-  validate?: (hotkey: Hotkey, context: HotkeyRecorderValidationContext) => boolean | string;
-  /** Callback when a hotkey is successfully recorded */
-  onRecord: (hotkey: Hotkey) => void;
+/** Which keys commit a multi-step recording before it reaches `maxSteps`. */
+export type HotkeyRecorderCommitKeys = 'enter' | 'none';
+interface HotkeyRecorderBaseOptions extends RecorderOptions {
   /** Optional callback when recording is cancelled (Escape pressed) */
   onCancel?: () => void;
-  /** Optional callback when shortcut is cleared (Backspace/Delete pressed) */
+  /**
+   * Optional callback when the recording is cleared: Backspace/Delete with no
+   * modifiers and no recorded steps
+   */
   onClear?: () => void;
   /**
    * Whether to ignore keyboard events from input-like elements (text inputs,
-   * textarea, select, contenteditable). When true, typing in inputs passes
-   * through normally instead of being captured as a hotkey recording.
-   * Escape always works regardless of this setting.
-   * @default true
+   * textarea, select, contenteditable) while recording. When true, typing in
+   * inputs passes through normally (Escape still cancels). Defaults to true.
    */
   ignoreInputs?: boolean;
 }
+/** Options for recording a single chord. This is the default (`maxSteps: 1`). */
+export interface HotkeyChordRecorderOptions extends HotkeyRecorderBaseOptions {
+  /** Maximum number of chords to record. Default: 1 */
+  maxSteps?: 1;
+  /** Return true to accept, or false/a message to reject while staying in recording mode. */
+  validate?: (hotkey: HotkeyChord, context: HotkeyRecorderValidationContext) => boolean | string;
+  /** Callback when a chord is successfully recorded */
+  onRecord: (hotkey: HotkeyChord) => void;
+}
+/**
+ * Options for recording up to `maxSteps` chords. A one-step recording commits
+ * as a chord string; two or more steps commit as a sequence.
+ */
+export interface HotkeySequenceRecorderOptions extends HotkeyRecorderBaseOptions {
+  /** Maximum number of chords to record. Reaching it commits automatically. Use `Infinity` for no limit. */
+  maxSteps: number;
+  /** Return true to accept, or false/a message to reject while staying in recording mode. */
+  validate?: (hotkey: Hotkey, context: HotkeyRecorderValidationContext) => boolean | string;
+  /** Callback when a hotkey is successfully recorded */
+  onRecord: (hotkey: Hotkey) => void;
+  /** Whether plain Enter commits the recorded steps. Default: 'enter' */
+  commitKeys?: HotkeyRecorderCommitKeys;
+  /** Commit automatically after this many milliseconds without a new step. Disabled when unset or 0. */
+  idleTimeoutMs?: number;
+}
+/**
+ * Options for HotkeyRecorder. `maxSteps` (default 1) selects between recording
+ * a single chord and recording a sequence.
+ */
+export type HotkeyRecorderOptions = HotkeyChordRecorderOptions | HotkeySequenceRecorderOptions;
 /**
  * Framework-agnostic class for recording keyboard shortcuts.
  *
- * This class handles 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 commits. With a larger
+ * `maxSteps`, each chord adds a step; the recording commits on Enter (unless
+ * `commitKeys: 'none'`), after `idleTimeoutMs`, or when it reaches `maxSteps`.
+ * Backspace/Delete removes the last step, and on an empty recording calls
+ * `onClear`. Escape cancels. A one-step result is a chord string.
  *
  * State Management:
  * - Uses TanStack Store for reactive state management
  * - State can be accessed via `recorder.store.state` when using the class directly
- * - When using framework adapters (React), use `useSelector` hooks for reactive state
+ * - When using framework adapters, use the `useHotkeyRecorder` hook for reactive state
  *
  * @example
  * ```ts
  * const recorder = new HotkeyRecorder({
  *   onRecord: (hotkey) => {
- *     console.log('Recorded:', hotkey)
- *   },
- *   onCancel: () => {
- *     console.log('Recording cancelled')
+ *     console.log('Recorded:', hotkey) // 'Mod+S'
  *   },
  * })
  *
- * // Start recording
- * recorder.start()
- *
- * // Access state directly
- * console.log(recorder.store.state.isRecording) // true
- *
- * // Subscribe to changes with TanStack Store
- * const unsubscribe = recorder.store.subscribe(() => {
- *   console.log('Recording:', recorder.store.state.isRecording)
+ * const sequenceRecorder = new HotkeyRecorder({
+ *   maxSteps: 3,
+ *   onRecord: (hotkey) => {
+ *     console.log('Recorded:', hotkey) // 'Mod+S' or ['G', 'H']
+ *   },
  * })
  *
- * // Cleanup
+ * recorder.start()
+ * // ... later
  * recorder.destroy()
- * unsubscribe()
  * ```
  */
 export declare class HotkeyRecorder {
   #private;
-  /**
-   * The TanStack Store instance containing the recorder state.
-   * Use this to subscribe to state changes or access current state.
-   */
   readonly store: Store<HotkeyRecorderState>;
-  /** Options may be a getter to read current configuration during an active session. */
-  constructor(options: HotkeyRecorderOptions | (() => HotkeyRecorderOptions));
+  constructor(options: HotkeyChordRecorderOptions | (() => HotkeyChordRecorderOptions));
+  constructor(options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions));
   /**
    * Updates the recorder options, including callbacks.
    * This allows framework adapters to sync callback changes without recreating the recorder.
@@ -89,10 +108,15 @@ export declare class HotkeyRecorder {
    * Start recording a new hotkey.
    *
    * Sets up a keydown event listener that captures keyboard events
-   * and converts them to hotkey strings. Recording continues until
-   * a valid hotkey is recorded, Escape is pressed, or stop/cancel is called.
+   * and records chords according to `maxSteps`.
    */
   start(): void;
+  /**
+   * Commits the recorded steps after validation and conflict checks.
+   * Called automatically at `maxSteps`, on Enter, or after `idleTimeoutMs`.
+   * A rejected commit leaves recording active with its steps intact.
+   */
+  commit(): void;
   /**
    * Stop recording (same as cancel, but doesn't call onCancel).
    *

package/dist/hotkey-recorder.js

@@ -1,6 +1,6 @@
 import { detectPlatform } from "./platform.js";
 import { normalizeKeyboardEvent } from "./_keyboard-event.js";
-import { isModifierKey, parseHotkey } from "./parse.js";
+import { isModifierKey, parseHotkey, simplifyHotkey } from "./parse.js";
 import { validateHotkey } from "./validate.js";
 import { beginRecording, captureRecordingEvent, endRecording } from "./_recording-guard.js";
 import { shouldIgnoreInputEvent } from "./_event-target.js";
@@ -9,65 +9,62 @@ import { chordRejection, hotkeyChordFromKeydown } from "./_recorder-chord.js";
 import { Store } from "@tanstack/store";
 
 //#region src/hotkey-recorder.ts
+const initialState = {
+	isRecording: false,
+	steps: [],
+	recordedHotkey: null
+};
 /**
 * Framework-agnostic class for recording keyboard shortcuts.
 *
-* This class handles 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 commits. With a larger
+* `maxSteps`, each chord adds a step; the recording commits on Enter (unless
+* `commitKeys: 'none'`), after `idleTimeoutMs`, or when it reaches `maxSteps`.
+* Backspace/Delete removes the last step, and on an empty recording calls
+* `onClear`. Escape cancels. A one-step result is a chord string.
 *
 * State Management:
 * - Uses TanStack Store for reactive state management
 * - State can be accessed via `recorder.store.state` when using the class directly
-* - When using framework adapters (React), use `useSelector` hooks for reactive state
+* - When using framework adapters, use the `useHotkeyRecorder` hook for reactive state
 *
 * @example
 * ```ts
 * const recorder = new HotkeyRecorder({
 *   onRecord: (hotkey) => {
-*     console.log('Recorded:', hotkey)
-*   },
-*   onCancel: () => {
-*     console.log('Recording cancelled')
+*     console.log('Recorded:', hotkey) // 'Mod+S'
 *   },
 * })
 *
-* // Start recording
-* recorder.start()
-*
-* // Access state directly
-* console.log(recorder.store.state.isRecording) // true
-*
-* // Subscribe to changes with TanStack Store
-* const unsubscribe = recorder.store.subscribe(() => {
-*   console.log('Recording:', recorder.store.state.isRecording)
+* const sequenceRecorder = new HotkeyRecorder({
+*   maxSteps: 3,
+*   onRecord: (hotkey) => {
+*     console.log('Recorded:', hotkey) // 'Mod+S' or ['G', 'H']
+*   },
 * })
 *
-* // Cleanup
+* recorder.start()
+* // ... later
 * recorder.destroy()
-* unsubscribe()
 * ```
 */
 var HotkeyRecorder = class {
-	/**
-	* The TanStack Store instance containing the recorder state.
-	* Use this to subscribe to state changes or access current state.
-	*/
-	store = new Store({
-		isRecording: false,
-		recordedHotkey: null
-	});
+	store = new Store(initialState);
 	#keydownHandler = null;
 	#optionsSource;
 	#optionOverrides = {};
+	#platform;
+	#events = [];
+	#idleTimer = null;
 	get #options() {
 		return {
 			...typeof this.#optionsSource === "function" ? this.#optionsSource() : this.#optionsSource,
 			...this.#optionOverrides
 		};
 	}
-	#platform;
-	/** Options may be a getter to read current configuration during an active session. */
+	get #maxSteps() {
+		return Math.max(1, this.#options.maxSteps ?? 1);
+	}
 	constructor(options) {
 		this.#optionsSource = options;
 		this.#platform = detectPlatform();
@@ -82,19 +79,35 @@ var HotkeyRecorder = class {
 			...options
 		};
 	}
+	#clearIdleTimer() {
+		if (this.#idleTimer !== null) {
+			clearTimeout(this.#idleTimer);
+			this.#idleTimer = null;
+		}
+	}
+	#scheduleIdleTimer() {
+		this.#clearIdleTimer();
+		const ms = this.#maxSteps > 1 ? this.#options.idleTimeoutMs : void 0;
+		if (ms === void 0 || ms <= 0 || this.store.state.steps.length === 0) return;
+		this.#idleTimer = setTimeout(() => {
+			this.#idleTimer = null;
+			if (this.#keydownHandler && this.store.state.steps.length >= 1) this.commit();
+		}, ms);
+	}
 	/**
 	* Start recording a new hotkey.
 	*
 	* Sets up a keydown event listener that captures keyboard events
-	* and converts them to hotkey strings. Recording continues until
-	* a valid hotkey is recorded, Escape is pressed, or stop/cancel is called.
+	* and records chords according to `maxSteps`.
 	*/
 	start() {
 		if (this.#keydownHandler) return;
+		this.#clearIdleTimer();
+		this.#events = [];
 		beginRecording(this);
 		this.store.setState(() => ({
-			isRecording: true,
-			recordedHotkey: null
+			...initialState,
+			isRecording: true
 		}));
 		const handler = (event) => {
 			if (!this.#keydownHandler) return;
@@ -109,120 +122,152 @@ var HotkeyRecorder = class {
 				this.cancel();
 				return;
 			}
-			if (event.key === "Backspace" || event.key === "Delete") {
-				if (!event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey) {
+			const unmodified = !event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey;
+			const multiStep = this.#maxSteps > 1;
+			if ((event.key === "Backspace" || event.key === "Delete") && unmodified) {
+				if (this.store.state.steps.length === 0) {
 					this.stop();
 					this.#options.onClear?.();
 					return;
 				}
+				this.#events.pop();
+				this.store.setState((s) => ({
+					...s,
+					steps: s.steps.slice(0, -1)
+				}));
+				if (this.store.state.steps.length === 0) this.#clearIdleTimer();
+				else this.#scheduleIdleTimer();
+				return;
+			}
+			const options = this.#options;
+			if (multiStep && options.commitKeys !== "none" && event.key === "Enter" && unmodified) {
+				if (this.store.state.steps.length >= 1) this.commit();
+				return;
 			}
 			if (isModifierKey(event.key) || event.key === "AltGraph") return;
 			const rejection = chordRejection(event, {
-				...this.#options,
+				...options,
 				platform
 			});
 			if (rejection) {
-				this.#options.onReject?.(rejection);
+				options.onReject?.(rejection);
 				return;
 			}
-			const finalHotkey = hotkeyChordFromKeydown(event, platform, this.#options.recordBy);
-			if (finalHotkey === null) return;
-			const validation = validateHotkey(finalHotkey);
+			const chord = hotkeyChordFromKeydown(event, platform, options.recordBy);
+			if (chord === null) return;
+			const validation = validateHotkey(chord);
 			if (!validation.valid) {
-				this.#options.onReject?.({
+				options.onReject?.({
 					reason: "invalid",
 					message: validation.errors.join("; "),
-					hotkey: finalHotkey
-				});
-				return;
-			}
-			const accepted = this.#options.validate?.(finalHotkey, {
-				event,
-				parsedHotkey: parseHotkey(finalHotkey, platform)
-			});
-			if (accepted !== void 0 && accepted !== true) {
-				this.#options.onReject?.({
-					reason: "validation",
-					message: typeof accepted === "string" ? accepted : "This shortcut is not allowed.",
-					hotkey: finalHotkey
+					hotkey: chord
 				});
 				return;
 			}
-			if (this.#options.detectConflicts) {
-				const conflicts = findHotkeyConflicts(finalHotkey, {
-					...typeof this.#options.detectConflicts === "object" ? this.#options.detectConflicts : {},
-					platform,
-					events: [event]
-				});
-				if (conflicts.length) {
-					this.#options.onReject?.({
-						reason: "conflict",
-						message: "This shortcut conflicts with a registered binding.",
-						hotkey: finalHotkey,
-						conflicts
-					});
-					return;
-				}
-			}
-			endRecording(this);
-			const handlerToRemove = this.#keydownHandler;
-			if (handlerToRemove) {
-				this.#removeListener(handlerToRemove);
-				this.#keydownHandler = null;
-			}
-			this.store.setState(() => ({
-				isRecording: false,
-				recordedHotkey: finalHotkey
+			this.#events.push(event);
+			this.store.setState((s) => ({
+				...s,
+				steps: [...s.steps, chord]
 			}));
-			this.#options.onRecord(finalHotkey);
+			if (this.store.state.steps.length >= this.#maxSteps) this.commit();
+			else this.#scheduleIdleTimer();
 		};
 		this.#keydownHandler = handler;
 		this.#addListener(handler);
 	}
 	/**
-	* Stop recording (same as cancel, but doesn't call onCancel).
-	*
-	* Removes the event listener and resets the recording state.
+	* Commits the recorded steps after validation and conflict checks.
+	* Called automatically at `maxSteps`, on Enter, or after `idleTimeoutMs`.
+	* A rejected commit leaves recording active with its steps intact.
 	*/
-	stop() {
+	commit() {
+		const steps = this.store.state.steps;
+		if (steps.length < 1) return;
+		const options = this.#options;
+		const platform = options.platform ?? this.#platform;
+		const hotkey = simplifyHotkey(steps);
+		const single = this.#maxSteps === 1;
+		this.#clearIdleTimer();
+		const rejectAndKeepRecording = (rejection) => {
+			if (single) {
+				this.#events = [];
+				this.store.setState((s) => ({
+					...s,
+					steps: []
+				}));
+			}
+			options.onReject?.(rejection);
+		};
+		const parsedSequence = steps.map((step) => parseHotkey(step, platform));
+		const accepted = options.validate?.(hotkey, {
+			event: this.#events[this.#events.length - 1],
+			parsedHotkey: parsedSequence[parsedSequence.length - 1],
+			events: [...this.#events],
+			parsedSequence
+		});
+		if (accepted !== void 0 && accepted !== true) {
+			rejectAndKeepRecording({
+				reason: "validation",
+				message: typeof accepted === "string" ? accepted : `This ${single ? "shortcut" : "sequence"} is not allowed.`,
+				hotkey
+			});
+			return;
+		}
+		if (options.detectConflicts) {
+			const conflicts = findHotkeyConflicts(hotkey, {
+				...typeof options.detectConflicts === "object" ? options.detectConflicts : {},
+				platform,
+				events: this.#events
+			});
+			if (conflicts.length) {
+				rejectAndKeepRecording({
+					reason: "conflict",
+					message: `This ${single ? "shortcut" : "sequence"} conflicts with a registered hotkey.`,
+					hotkey,
+					conflicts
+				});
+				return;
+			}
+		}
+		this.#finish(hotkey);
+		options.onRecord(hotkey);
+	}
+	/** Stops listening and stores the final state. */
+	#finish(recordedHotkey) {
 		endRecording(this);
+		this.#events = [];
+		this.#clearIdleTimer();
 		if (this.#keydownHandler) {
 			this.#removeListener(this.#keydownHandler);
 			this.#keydownHandler = null;
 		}
 		this.store.setState(() => ({
-			isRecording: false,
-			recordedHotkey: null
+			...initialState,
+			recordedHotkey
 		}));
 	}
 	/**
+	* Stop recording (same as cancel, but doesn't call onCancel).
+	*
+	* Removes the event listener and resets the recording state.
+	*/
+	stop() {
+		this.#finish(null);
+	}
+	/**
 	* Cancel recording without saving.
 	*
 	* Removes the event listener, resets the recording state, and calls
 	* the onCancel callback if provided.
 	*/
 	cancel() {
-		endRecording(this);
-		if (this.#keydownHandler) {
-			this.#removeListener(this.#keydownHandler);
-			this.#keydownHandler = null;
-		}
-		this.store.setState(() => ({
-			isRecording: false,
-			recordedHotkey: null
-		}));
+		this.#finish(null);
 		this.#options.onCancel?.();
 	}
-	/**
-	* Adds the keydown event listener to the document.
-	*/
 	#addListener(handler) {
 		if (typeof document === "undefined") return;
 		document.addEventListener("keydown", handler, true);
 	}
-	/**
-	* Removes the keydown event listener from the document.
-	*/
 	#removeListener(handler) {
 		if (typeof document === "undefined") return;
 		document.removeEventListener("keydown", handler, true);
@@ -234,11 +279,7 @@ var HotkeyRecorder = class {
 	* all event listeners are properly removed.
 	*/
 	destroy() {
-		this.stop();
-		this.store.setState(() => ({
-			isRecording: false,
-			recordedHotkey: null
-		}));
+		this.#finish(null);
 	}
 };
 

package/dist/hotkey.types.d.ts

@@ -88,16 +88,16 @@ export type FourModifierHotkey = `Control+Alt+Shift+Meta+${Key}`;
  * @example
  * ```ts
  * // Cross-platform shortcuts (recommended)
- * const save: Hotkey = 'Mod+S'           // Command+S on Mac, Ctrl+S on Windows/Linux
- * const saveAs: Hotkey = 'Mod+Shift+S'   // Command+Shift+S on Mac, Ctrl+Shift+S elsewhere
- * const comment: Hotkey = 'Mod+/'       // Command+/ on Mac, Ctrl+/ elsewhere
+ * const save: HotkeyChord = 'Mod+S'           // Command+S on Mac, Ctrl+S on Windows/Linux
+ * const saveAs: HotkeyChord = 'Mod+Shift+S'   // Command+Shift+S on Mac, Ctrl+Shift+S elsewhere
+ * const comment: HotkeyChord = 'Mod+/'       // Command+/ on Mac, Ctrl+/ elsewhere
  *
  * // Platform-specific shortcuts
- * const macOnly: Hotkey = 'Meta+S'       // Command+S on Mac only
- * const windowsOnly: Hotkey = 'Control+S' // Ctrl+S on Windows/Linux only
+ * const macOnly: HotkeyChord = 'Meta+S'       // Command+S on Mac only
+ * const windowsOnly: HotkeyChord = 'Control+S' // Ctrl+S on Windows/Linux only
  * ```
  */
-export type Hotkey = Key | SingleModifierHotkey | TwoModifierHotkey | ThreeModifierHotkey | FourModifierHotkey;
+export type HotkeyChord = Key | SingleModifierHotkey | TwoModifierHotkey | ThreeModifierHotkey | FourModifierHotkey;
 /** Resolved modifier flags shared by both parsed binding variants. */
 export interface ParsedModifiers {
   /** Whether Control is required. */
@@ -171,17 +171,31 @@ export type RawHotkey = ({
   key?: never;
 } & RawModifiers);
 /**
- * A hotkey that can be passed to `HotkeyManager.register()` and `useHotkey()`.
- * Either a type-safe string (`Hotkey`) or a raw object (`RawHotkey`).
+ * A sequence of chords pressed one after another (Vim-style), such as `['G', 'G']`.
+ *
+ * Steps may include modifiers; the same modifier can appear on consecutive
+ * steps (e.g. `['Shift+R', 'Shift+T']`). Modifier-only key events do not
+ * advance or reset matching. Automatic repeats and IME composition are ignored.
+ * A one-step sequence is treated as its single chord.
+ */
+export type HotkeySequence = ReadonlyArray<HotkeyChord>;
+/**
+ * A hotkey: one chord (`'Mod+S'`) or a sequence of chords (`['G', 'G']`).
+ */
+export type Hotkey = HotkeyChord | HotkeySequence;
+/** A single chord as a type-safe string (`HotkeyChord`) or a raw object (`RawHotkey`). */
+export type RegisterableHotkeyChord = HotkeyChord | RawHotkey;
+/**
+ * Anything that can be registered: a chord string, a raw chord object, or a sequence.
  */
-export type RegisterableHotkey = Hotkey | RawHotkey;
+export type RegisterableHotkey = RegisterableHotkeyChord | HotkeySequence;
 /**
  * Context passed to hotkey callbacks along with the keyboard event.
  */
 export interface HotkeyCallbackContext {
-  /** The original hotkey string that was registered */
+  /** The registered hotkey: a chord string or a sequence */
   hotkey: Hotkey;
-  /** The parsed representation of the hotkey */
+  /** The parsed chord that completed the match (the last step of a sequence) */
   parsedHotkey: ParsedHotkey;
 }
 /**
@@ -200,7 +214,7 @@ export interface HotkeyCallbackContext {
  */
 export type HotkeyCallback = (event: KeyboardEvent, context: HotkeyCallbackContext) => void;
 /**
- * Metadata for hotkey and sequence registrations.
+ * Metadata for hotkey registrations, chords and sequences alike.
  * Includes `name`, `description`, and `group` by default. Extend via declaration merging:
  *
  * @example

package/dist/index.d.ts

@@ -1,18 +1,17 @@
 import { CanonicalModifier, EditingKey, FunctionKey, IndividualKey, Key, LetterKey, LogicalKey, Modifier, NamedKey, NavigationKey, NonPunctuationKey, NormalizedKeyboardEvent, NumberKey, PhysicalKey, PhysicalKeyCode, PunctuationKey } from "./key.types.js";
-import { ConflictBehavior, FourModifierHotkey, Hotkey, HotkeyCallback, HotkeyCallbackContext, HotkeyMeta, ParsedHotkey, ParsedModifiers, RawHotkey, RawModifiers, RegisterableHotkey, SingleModifierHotkey, ThreeModifierHotkey, TwoModifierHotkey } from "./hotkey.types.js";
-import { HotkeyManager, HotkeyOptions, HotkeyRegistration, HotkeyRegistrationHandle, HotkeyRegistrationView, getHotkeyManager, toHotkeyRegistrationView } from "./hotkey-manager.js";
-import { DEFAULT_SEQUENCE_TIMEOUT, HotkeySequence, SequenceManager, SequenceOptions, SequenceRegistration, SequenceRegistrationHandle, SequenceRegistrationView, Target, createSequenceMatcher, getSequenceManager } from "./sequence-manager.js";
+import { ConflictBehavior, FourModifierHotkey, Hotkey, HotkeyCallback, HotkeyCallbackContext, HotkeyChord, HotkeyMeta, HotkeySequence, ParsedHotkey, ParsedModifiers, RawHotkey, RawModifiers, RegisterableHotkey, RegisterableHotkeyChord, SingleModifierHotkey, ThreeModifierHotkey, TwoModifierHotkey } from "./hotkey.types.js";
+import { HotkeyChordOptions, HotkeyChordRegistration, HotkeyChordRegistrationView, HotkeyManager, HotkeyOptions, HotkeyOptionsFor, HotkeyRegistration, HotkeyRegistrationHandle, HotkeyRegistrationView, HotkeySequenceOptions, HotkeySequenceRegistration, HotkeySequenceRegistrationView, Target, getHotkeyManager, toHotkeyRegistrationView } from "./hotkey-manager.js";
+import { AppHotkey, AppHotkeyChordOptions, AppHotkeyDefaultKind, AppHotkeyId, AppHotkeyInput, AppHotkeyListItem, AppHotkeyOptions, AppHotkeySequenceOptions, AppHotkeyStatus, AppHotkeys, AppHotkeysState, AppHotkeysStore, AppHotkeysStoreOptions, CustomHotkeys, DefinedAppHotkeys, Register, RegisteredAppHotkeys, defineAppHotkeys, getAppHotkeyRegistrationOptions, isAppHotkey, isCustomHotkey, provideAppHotkeys, publishAppHotkeysStore, resolveAppHotkey } from "./app-hotkeys.js";
 import { ALL_KEYS, EDITING_KEYS, FUNCTION_KEYS, LETTER_KEYS, MODIFIER_ALIASES, MODIFIER_KEYS, MODIFIER_ORDER, NAVIGATION_KEYS, NUMBER_KEYS, PUNCTUATION_CODE_MAP, PUNCTUATION_KEYS, isSingleLetterKey, normalizeKeyName } from "./constants.js";
 import { KEY_DISPLAY_SYMBOLS, LINUX_MODIFIER_LABELS, MAC_MODIFIER_LABELS, MAC_MODIFIER_SYMBOLS, PUNCTUATION_KEY_DISPLAY_LABELS, WINDOWS_MODIFIER_LABELS } from "./display-labels.js";
 import { detectPlatform, resolveModifier } from "./platform.js";
-import { DisplayHotkey, FormatDisplayOptions, formatForDisplay, formatHotkey, formatHotkeySequence, formatWithLabels } from "./format.js";
-import { hasNonModifierKey, isModifierKey, normalizeHotkey, normalizeHotkeyFromEvent, normalizeHotkeyFromParsed, normalizeRegisterableHotkey, parseHotkey, parseKeyboardEvent, parseRegisterableHotkey, rawHotkeyToParsedHotkey } from "./parse.js";
-import { ValidationResult, assertValidHotkey, checkHotkey, validateHotkey } from "./validate.js";
-import { CreateHotkeyHandlerOptions, KeyboardEventMatch, MultiHotkeyHandler, areHotkeysEqual, createHotkeyHandler, createMultiHotkeyHandler, matchesKeyboardEvent } from "./match.js";
+import { DisplayHotkey, DisplayHotkeyChord, FormatDisplayOptions, formatForDisplay, formatHotkey } from "./format.js";
+import { hasNonModifierKey, isHotkeySequence, isModifierKey, normalizeHotkey, normalizeHotkeyFromEvent, normalizeHotkeyFromParsed, normalizeRegisterableHotkey, parseHotkey, parseKeyboardEvent, parseRegisterableHotkey, rawHotkeyToParsedHotkey, simplifyHotkey } from "./parse.js";
+import { ValidatableHotkey, ValidationResult, assertValidHotkey, checkHotkey, validateHotkey } from "./validate.js";
+import { CreateHotkeyHandlerOptions, DEFAULT_SEQUENCE_TIMEOUT, KeyboardEventMatch, MultiHotkeyHandler, areHotkeysEqual, createHotkeyHandler, createMultiHotkeyHandler, createSequenceMatcher, matchesKeyboardEvent } from "./match.js";
 import { HeldModifierOptions, matchesHeldModifiers } from "./hint.js";
 import { HotkeyConflict, HotkeyConflictOptions, findHotkeyConflicts } from "./conflicts.js";
 import { KeyStateTracker, KeyStateTrackerState, getKeyStateTracker } from "./key-state-tracker.js";
-import { HotkeyRecorderValidationContext, HotkeySequenceRecorderValidationContext, RecorderKeyMode, RecorderOptions, RecorderRejection } from "./recorder-options.js";
-import { HotkeyRecorder, HotkeyRecorderOptions, HotkeyRecorderState } from "./hotkey-recorder.js";
-import { HotkeySequenceRecorder, HotkeySequenceRecorderCommitKeys, HotkeySequenceRecorderOptions, HotkeySequenceRecorderState } from "./hotkey-sequence-recorder.js";
-export { ALL_KEYS, CanonicalModifier, ConflictBehavior, CreateHotkeyHandlerOptions, DEFAULT_SEQUENCE_TIMEOUT, DisplayHotkey, EDITING_KEYS, EditingKey, FUNCTION_KEYS, FormatDisplayOptions, FourModifierHotkey, FunctionKey, HeldModifierOptions, Hotkey, HotkeyCallback, HotkeyCallbackContext, HotkeyConflict, HotkeyConflictOptions, HotkeyManager, HotkeyMeta, HotkeyOptions, HotkeyRecorder, HotkeyRecorderOptions, HotkeyRecorderState, HotkeyRecorderValidationContext, HotkeyRegistration, HotkeyRegistrationHandle, HotkeyRegistrationView, HotkeySequence, HotkeySequenceRecorder, HotkeySequenceRecorderCommitKeys, HotkeySequenceRecorderOptions, HotkeySequenceRecorderState, HotkeySequenceRecorderValidationContext, IndividualKey, KEY_DISPLAY_SYMBOLS, Key, KeyStateTracker, KeyStateTrackerState, KeyboardEventMatch, LETTER_KEYS, LINUX_MODIFIER_LABELS, LetterKey, LogicalKey, MAC_MODIFIER_LABELS, MAC_MODIFIER_SYMBOLS, MODIFIER_ALIASES, MODIFIER_KEYS, MODIFIER_ORDER, Modifier, MultiHotkeyHandler, NAVIGATION_KEYS, NUMBER_KEYS, NamedKey, NavigationKey, NonPunctuationKey, NormalizedKeyboardEvent, NumberKey, PUNCTUATION_CODE_MAP, PUNCTUATION_KEYS, PUNCTUATION_KEY_DISPLAY_LABELS, ParsedHotkey, ParsedModifiers, PhysicalKey, PhysicalKeyCode, PunctuationKey, RawHotkey, RawModifiers, RecorderKeyMode, RecorderOptions, RecorderRejection, RegisterableHotkey, SequenceManager, SequenceOptions, SequenceRegistration, SequenceRegistrationHandle, SequenceRegistrationView, SingleModifierHotkey, Target, ThreeModifierHotkey, TwoModifierHotkey, ValidationResult, WINDOWS_MODIFIER_LABELS, areHotkeysEqual, assertValidHotkey, checkHotkey, createHotkeyHandler, createMultiHotkeyHandler, createSequenceMatcher, detectPlatform, findHotkeyConflicts, formatForDisplay, formatHotkey, formatHotkeySequence, formatWithLabels, getHotkeyManager, getKeyStateTracker, getSequenceManager, hasNonModifierKey, isModifierKey, isSingleLetterKey, matchesHeldModifiers, matchesKeyboardEvent, normalizeHotkey, normalizeHotkeyFromEvent, normalizeHotkeyFromParsed, normalizeKeyName, normalizeRegisterableHotkey, parseHotkey, parseKeyboardEvent, parseRegisterableHotkey, rawHotkeyToParsedHotkey, resolveModifier, toHotkeyRegistrationView, validateHotkey };
+import { HotkeyRecorderValidationContext, RecorderKeyMode, RecorderOptions, RecorderRejection } from "./recorder-options.js";
+import { HotkeyChordRecorderOptions, HotkeyRecorder, HotkeyRecorderCommitKeys, HotkeyRecorderOptions, HotkeyRecorderState, HotkeySequenceRecorderOptions } from "./hotkey-recorder.js";
+export { ALL_KEYS, AppHotkey, AppHotkeyChordOptions, AppHotkeyDefaultKind, AppHotkeyId, AppHotkeyInput, AppHotkeyListItem, AppHotkeyOptions, AppHotkeySequenceOptions, AppHotkeyStatus, AppHotkeys, AppHotkeysState, AppHotkeysStore, AppHotkeysStoreOptions, CanonicalModifier, ConflictBehavior, CreateHotkeyHandlerOptions, CustomHotkeys, DEFAULT_SEQUENCE_TIMEOUT, DefinedAppHotkeys, DisplayHotkey, DisplayHotkeyChord, EDITING_KEYS, EditingKey, FUNCTION_KEYS, FormatDisplayOptions, FourModifierHotkey, FunctionKey, HeldModifierOptions, Hotkey, HotkeyCallback, HotkeyCallbackContext, HotkeyChord, HotkeyChordOptions, HotkeyChordRecorderOptions, HotkeyChordRegistration, HotkeyChordRegistrationView, HotkeyConflict, HotkeyConflictOptions, HotkeyManager, HotkeyMeta, HotkeyOptions, HotkeyOptionsFor, HotkeyRecorder, HotkeyRecorderCommitKeys, HotkeyRecorderOptions, HotkeyRecorderState, HotkeyRecorderValidationContext, HotkeyRegistration, HotkeyRegistrationHandle, HotkeyRegistrationView, HotkeySequence, HotkeySequenceOptions, HotkeySequenceRecorderOptions, HotkeySequenceRegistration, HotkeySequenceRegistrationView, IndividualKey, KEY_DISPLAY_SYMBOLS, Key, KeyStateTracker, KeyStateTrackerState, KeyboardEventMatch, LETTER_KEYS, LINUX_MODIFIER_LABELS, LetterKey, LogicalKey, MAC_MODIFIER_LABELS, MAC_MODIFIER_SYMBOLS, MODIFIER_ALIASES, MODIFIER_KEYS, MODIFIER_ORDER, Modifier, MultiHotkeyHandler, NAVIGATION_KEYS, NUMBER_KEYS, NamedKey, NavigationKey, NonPunctuationKey, NormalizedKeyboardEvent, NumberKey, PUNCTUATION_CODE_MAP, PUNCTUATION_KEYS, PUNCTUATION_KEY_DISPLAY_LABELS, ParsedHotkey, ParsedModifiers, PhysicalKey, PhysicalKeyCode, PunctuationKey, RawHotkey, RawModifiers, RecorderKeyMode, RecorderOptions, RecorderRejection, Register, RegisterableHotkey, RegisterableHotkeyChord, RegisteredAppHotkeys, SingleModifierHotkey, Target, ThreeModifierHotkey, TwoModifierHotkey, ValidatableHotkey, ValidationResult, WINDOWS_MODIFIER_LABELS, areHotkeysEqual, assertValidHotkey, checkHotkey, createHotkeyHandler, createMultiHotkeyHandler, createSequenceMatcher, defineAppHotkeys, detectPlatform, findHotkeyConflicts, formatForDisplay, formatHotkey, getAppHotkeyRegistrationOptions, getHotkeyManager, getKeyStateTracker, hasNonModifierKey, isAppHotkey, isCustomHotkey, isHotkeySequence, isModifierKey, isSingleLetterKey, matchesHeldModifiers, matchesKeyboardEvent, normalizeHotkey, normalizeHotkeyFromEvent, normalizeHotkeyFromParsed, normalizeKeyName, normalizeRegisterableHotkey, parseHotkey, parseKeyboardEvent, parseRegisterableHotkey, provideAppHotkeys, publishAppHotkeysStore, rawHotkeyToParsedHotkey, resolveAppHotkey, resolveModifier, simplifyHotkey, toHotkeyRegistrationView, validateHotkey };