@opentui/keymap 0.0.0-20260423-76a94f40

package/src/keymap.d.ts

@@ -0,0 +1,73 @@
+import type { ActiveKey, ActiveKeyOptions, BindingInput, BindingExpander, BindingParser, BindingFieldCompiler, Bindings, BindingTransformer, Events, CommandFieldCompiler, CommandEntry, CommandQuery, CommandRecord, KeymapEvent, KeymapHost, LayerAnalyzer, Listener, RunCommandOptions, RunCommandResult, CommandResolver, KeyInterceptOptions, KeyInputContext, Layer, LayerFieldCompiler, RawInterceptOptions, RawInputContext, EventMatchResolver, KeyStringifyInput, KeyToken, KeyLike, KeySequencePart } from "./types.js";
+export declare class Keymap<TTarget extends object, TEvent extends KeymapEvent = KeymapEvent> {
+    private readonly host;
+    private readonly state;
+    private cleanedUp;
+    private readonly resources;
+    private readonly cleanupListeners;
+    private events;
+    private hooks;
+    private readonly notify;
+    private readonly activation;
+    private readonly runtime;
+    private readonly conditions;
+    private readonly catalog;
+    private readonly executor;
+    private readonly compiler;
+    private readonly dispatch;
+    private readonly layers;
+    private readonly environment;
+    private readonly keypressListener;
+    private readonly keyreleaseListener;
+    private readonly rawListener;
+    private readonly focusedTargetListener;
+    constructor(host: KeymapHost<TTarget, TEvent>);
+    private cleanup;
+    setData(name: string, value: unknown): void;
+    getData(name: string): unknown;
+    hasPendingSequence(): boolean;
+    getPendingSequence(): readonly KeySequencePart[];
+    createKeyMatcher(key: KeyLike): (input: KeyStringifyInput | null | undefined) => boolean;
+    clearPendingSequence(): void;
+    popPendingSequence(): boolean;
+    getActiveKeys(options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
+    getCommands(query?: CommandQuery<TTarget>): readonly CommandRecord[];
+    getCommandEntries(query?: CommandQuery<TTarget>): readonly CommandEntry<TTarget, TEvent>[];
+    normalizeCommandName(name: string): string;
+    normalizeBindings(bindings: Bindings<TTarget, TEvent>): BindingInput<TTarget, TEvent>[];
+    acquireResource(key: symbol, setup: () => () => void): () => void;
+    runCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult;
+    on(name: "state", fn: Listener<Events<TTarget, TEvent>["state"]>): () => void;
+    on(name: "pendingSequence", fn: Listener<Events<TTarget, TEvent>["pendingSequence"]>): () => void;
+    on(name: "warning", fn: Listener<Events<TTarget, TEvent>["warning"]>): () => void;
+    on(name: "error", fn: Listener<Events<TTarget, TEvent>["error"]>): () => void;
+    intercept(name: "key", fn: (ctx: KeyInputContext<TEvent>) => void, options?: KeyInterceptOptions): () => void;
+    intercept(name: "raw", fn: (ctx: RawInputContext) => void, options?: RawInterceptOptions): () => void;
+    registerLayer(layer: Layer<TTarget, TEvent>): () => void;
+    registerLayerFields(fields: Record<string, LayerFieldCompiler>): () => void;
+    prependBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void;
+    appendBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void;
+    clearBindingTransformers(): void;
+    prependBindingParser(parser: BindingParser): () => void;
+    appendBindingParser(parser: BindingParser): () => void;
+    clearBindingParsers(): void;
+    registerToken(token: KeyToken): () => void;
+    prependBindingExpander(expander: BindingExpander): () => void;
+    appendBindingExpander(expander: BindingExpander): () => void;
+    clearBindingExpanders(): void;
+    registerBindingFields(fields: Record<string, BindingFieldCompiler>): () => void;
+    registerCommandFields(fields: Record<string, CommandFieldCompiler>): () => void;
+    prependCommandResolver(resolver: CommandResolver<TTarget, TEvent>): () => void;
+    appendCommandResolver(resolver: CommandResolver<TTarget, TEvent>): () => void;
+    clearCommandResolvers(): void;
+    prependLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
+    appendLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
+    clearLayerAnalyzers(): void;
+    prependEventMatchResolver(resolver: EventMatchResolver<TEvent>): () => void;
+    appendEventMatchResolver(resolver: EventMatchResolver<TEvent>): () => void;
+    clearEventMatchResolvers(): void;
+    private handleFocusedTargetChange;
+    private warnUnknownField;
+    private warnUnknownToken;
+    private releaseResource;
+}

package/src/lib/emitter.d.ts

@@ -0,0 +1,13 @@
+export type EmitterListener<TValue> = [TValue] extends [void] ? () => void : (value: TValue) => void;
+type EmitterArgs<TValue> = [TValue] extends [void] ? [] : [TValue];
+export declare class Emitter<TEvents extends Record<string, unknown>> {
+    private readonly onError;
+    private listeners;
+    constructor(onError: (name: keyof TEvents, error: unknown) => void);
+    hook<TName extends keyof TEvents>(name: TName, listener: EmitterListener<TEvents[TName]>): () => void;
+    has<TName extends keyof TEvents>(name: TName): boolean;
+    off<TName extends keyof TEvents>(name: TName, listener: EmitterListener<TEvents[TName]>): void;
+    clear(): void;
+    emit<TName extends keyof TEvents>(name: TName, ...args: EmitterArgs<TEvents[TName]>): void;
+}
+export {};

package/src/lib/registry.d.ts

@@ -0,0 +1,28 @@
+export type PriorityRegistration<TListener, TOptions extends {
+    priority: number;
+}> = Readonly<TOptions & {
+    listener: TListener;
+    order: number;
+}>;
+declare abstract class CopyOnWriteRegistry<TValue> {
+    private items;
+    protected getItems(): readonly TValue[];
+    protected setItems(items: readonly TValue[]): void;
+    protected removeItem(value: TValue): boolean;
+    has(): boolean;
+    clear(): void;
+}
+export declare class OrderedRegistry<TValue> extends CopyOnWriteRegistry<TValue> {
+    append(value: TValue): () => void;
+    prepend(value: TValue): () => void;
+    remove(value: TValue): boolean;
+    values(): readonly TValue[];
+}
+export declare class PriorityRegistry<TListener, TOptions extends {
+    priority: number;
+}> extends CopyOnWriteRegistry<PriorityRegistration<TListener, TOptions>> {
+    private order;
+    register(listener: TListener, options: TOptions): () => void;
+    entries(): readonly PriorityRegistration<TListener, TOptions>[];
+}
+export {};

package/src/opentui.d.ts

@@ -0,0 +1,7 @@
+import { KeyEvent, type CliRenderer, type Renderable } from "@opentui/core";
+import { Keymap } from "./keymap.js";
+import type { KeymapHost } from "./types.js";
+export * from "./index.js";
+export declare function createOpenTuiKeymapHost(renderer: CliRenderer): KeymapHost<Renderable, KeyEvent>;
+export declare function createOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent>;
+export declare function createDefaultOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent>;

package/src/react/index.d.ts

@@ -0,0 +1,42 @@
+import type { KeyEvent, Renderable } from "@opentui/core";
+import { type ActiveKey, type ActiveKeyOptions, type LayerFields, type Keymap, type ReactiveMatcher, type KeySequencePart } from "../index.js";
+import { type DependencyList, type ReactNode } from "react";
+type OpenTuiKeymap = Keymap<Renderable, KeyEvent>;
+export interface KeymapProviderProps {
+    keymap: OpenTuiKeymap;
+    children?: ReactNode;
+}
+export declare function KeymapProvider({ keymap, children }: KeymapProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<OpenTuiKeymap | null>>;
+export type UseBindingsTarget<TRenderable extends Renderable = Renderable> = TRenderable | null | undefined | (() => TRenderable | null | undefined);
+type UseBindingsLayerBase = LayerFields<Renderable, KeyEvent>;
+export type BindingsRef<TRenderable extends Renderable = Renderable> = (value: TRenderable | null) => void;
+export interface UseGlobalBindingsLayer extends UseBindingsLayerBase {
+    scope?: "global";
+    target?: undefined;
+}
+export interface UseFocusBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
+    scope: "focus";
+    target?: UseBindingsTarget<TRenderable>;
+}
+export interface UseFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
+    scope: "focus-within";
+    target?: UseBindingsTarget<TRenderable>;
+}
+export interface UseInferredFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
+    scope?: undefined;
+    target: UseBindingsTarget<TRenderable>;
+}
+export type UseTargetBindingsLayer<TRenderable extends Renderable = Renderable> = UseFocusBindingsLayer<TRenderable> | UseFocusWithinBindingsLayer<TRenderable> | UseInferredFocusWithinBindingsLayer<TRenderable>;
+export type UseBindingsLayer<TRenderable extends Renderable = Renderable> = UseGlobalBindingsLayer | UseTargetBindingsLayer<TRenderable>;
+export declare const useKeymap: () => OpenTuiKeymap;
+export declare const useActiveKeys: (options?: ActiveKeyOptions) => readonly ActiveKey[];
+export declare const usePendingSequence: () => readonly KeySequencePart[];
+export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseGlobalBindingsLayer, deps?: DependencyList): BindingsRef<TRenderable>;
+export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseTargetBindingsLayer<TRenderable>, deps?: DependencyList): BindingsRef<TRenderable>;
+/**
+ * Adapts any `subscribe` + `getSnapshot` store to
+ * `ReactiveMatcher`. Pass `predicate` when the snapshot value is not
+ * already boolean.
+ */
+export declare function reactiveMatcherFromStore<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, predicate?: (value: T) => boolean): ReactiveMatcher;
+export {};

package/src/schema.d.ts

@@ -0,0 +1,3 @@
+export declare const RESERVED_COMMAND_FIELDS: Set<string>;
+export declare const RESERVED_BINDING_FIELDS: Set<string>;
+export declare const RESERVED_LAYER_FIELDS: Set<string>;

package/src/services/activation.d.ts

@@ -0,0 +1,44 @@
+import type { Emitter } from "../lib/emitter.js";
+import type { ActiveKey, ActiveKeyOptions, Hooks, KeymapEvent, KeymapHost, KeySequencePart, PendingSequenceState, RegisteredLayer, SequenceNode } from "../types.js";
+import type { CommandCatalogService } from "./command-catalog.js";
+import type { ConditionService } from "./conditions.js";
+import type { NotificationService } from "./notify.js";
+import type { State } from "./state.js";
+export declare class ActivationService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly host;
+    private readonly hooks;
+    private readonly notify;
+    private readonly conditions;
+    private readonly catalog;
+    constructor(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, hooks: Emitter<Hooks<TTarget, TEvent>>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, catalog: CommandCatalogService<TTarget, TEvent>);
+    getFocusedTarget(): TTarget | null;
+    getFocusedTargetIfAvailable(): TTarget | null;
+    setPendingSequence(next: PendingSequenceState<TTarget, TEvent> | null): void;
+    ensureValidPendingSequence(): PendingSequenceState<TTarget, TEvent> | undefined;
+    getPendingSequence(): readonly KeySequencePart[];
+    popPendingSequence(): boolean;
+    getActiveKeys(options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
+    nodeHasReachableBindings(node: SequenceNode<TTarget, TEvent>, focused: TTarget | null): boolean;
+    getActiveLayers(focused: TTarget | null): RegisteredLayer<TTarget, TEvent>[];
+    isLayerActiveForFocused(layer: RegisteredLayer<TTarget, TEvent>, focused: TTarget | null): boolean;
+    layerCanCacheActiveKeys(layer: RegisteredLayer<TTarget, TEvent>): boolean;
+    activeLayersCanCacheActiveKeys(activeLayers: readonly RegisteredLayer<TTarget, TEvent>[]): boolean;
+    private collectSequencePartsFromNode;
+    private getMatchingBindings;
+    private hasMatchingBindings;
+    private getNodePresentation;
+    private toActiveBinding;
+    private collectActiveBindings;
+    private collectActiveKeysAtRoot;
+    private collectActiveKeysFromChildren;
+    private selectActiveKey;
+    private selectPrefixActiveKey;
+    private selectExactActiveKey;
+    private selectActiveBindings;
+    private createActiveKeyState;
+    private updateActiveKeyState;
+    private materializeActiveKey;
+    private invalidateCaches;
+    private notifyPendingSequenceChange;
+}

package/src/services/command-catalog.d.ts

@@ -0,0 +1,49 @@
+import type { Attributes, BindingCommand, CommandEntry, CommandDefinition, CommandResolutionStatus, CommandQuery, CommandRecord, CommandResolver, CompiledBinding, KeymapEvent, KeymapHost, RegisteredCommand, ResolvedBindingCommand } from "../types.js";
+import type { ConditionService } from "./conditions.js";
+import type { NotificationService } from "./notify.js";
+import type { ActiveCommandView, ResolvedCommandEntry, State } from "./state.js";
+interface CommandCatalogOptions {
+    onCommandResolversChanged(): void;
+}
+export declare function normalizeBindingCommand<TTarget extends object, TEvent extends KeymapEvent>(command: BindingCommand<TTarget, TEvent> | undefined): BindingCommand<TTarget, TEvent> | undefined;
+export declare function normalizeCommandName(name: string): string;
+export declare class CommandCatalogService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly host;
+    private readonly notify;
+    private readonly conditions;
+    private readonly options;
+    constructor(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, options: CommandCatalogOptions);
+    normalizeCommands(commands: readonly CommandDefinition<TTarget, TEvent>[]): RegisteredCommand<TTarget, TEvent>[];
+    prependCommandResolver(resolver: CommandResolver<TTarget, TEvent>): () => void;
+    appendCommandResolver(resolver: CommandResolver<TTarget, TEvent>): () => void;
+    clearCommandResolvers(): void;
+    getCommands(query?: CommandQuery<TTarget>): readonly CommandRecord[];
+    getCommandEntries(query?: CommandQuery<TTarget>): readonly CommandEntry<TTarget, TEvent>[];
+    getResolvedCommandChain(command: string, focused: TTarget | null, includeRecord: boolean): {
+        entries?: readonly ResolvedCommandEntry<TTarget, TEvent>[];
+        hadError: boolean;
+    };
+    getCommandAttrs(command: string, focused: TTarget | null): Readonly<Attributes> | undefined;
+    getTopCommandRecord(command: string, focused: TTarget | null): CommandRecord | undefined;
+    getActiveCommandView(focused: TTarget | null): ActiveCommandView<TTarget, TEvent>;
+    isBindingVisible(binding: CompiledBinding<TTarget, TEvent>, focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): boolean;
+    getBindingCommandAttrs(binding: CompiledBinding<TTarget, TEvent>, focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): Readonly<Attributes> | undefined;
+    getCommandResolutionStatus(command: string, layerCommands?: ReadonlyMap<string, RegisteredCommand<TTarget, TEvent>>): CommandResolutionStatus;
+    private mutateCommandResolvers;
+    private getTopResolvedCommand;
+    private getFallbackResolvedCommand;
+    private getResolvedCommandChainFromView;
+    private getRegisteredLayerCommandEntries;
+    private getCommandQueryContext;
+    private getFilteredCommandEntries;
+    private collectCommandEntryBindings;
+    private collectBindingForCommandEntries;
+    private resolveCommandWithResolvers;
+    private createCommandResolverContext;
+}
+export declare function getRegisteredCommandRecord<TTarget extends object, TEvent extends KeymapEvent>(command: RegisteredCommand<TTarget, TEvent>): CommandRecord;
+export declare function resolveRegisteredCommand<TTarget extends object, TEvent extends KeymapEvent>(command: RegisteredCommand<TTarget, TEvent>, options?: {
+    includeRecord?: boolean;
+}): ResolvedBindingCommand<TTarget, TEvent>;
+export {};

package/src/services/command-executor.d.ts

@@ -0,0 +1,22 @@
+import type { Keymap } from "../keymap.js";
+import type { CompiledBinding, KeymapEvent, RegisteredLayer, RunCommandOptions, RunCommandResult } from "../types.js";
+import { type CommandCatalogService } from "./command-catalog.js";
+import type { ActivationService } from "./activation.js";
+import type { NotificationService } from "./notify.js";
+import type { RuntimeService } from "./runtime.js";
+interface CommandExecutorOptions<TTarget extends object, TEvent extends KeymapEvent> {
+    keymap: Keymap<TTarget, TEvent>;
+    createCommandEvent: () => TEvent;
+}
+export declare class CommandExecutorService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly notify;
+    private readonly runtime;
+    private readonly activation;
+    private readonly catalog;
+    private readonly options;
+    constructor(notify: NotificationService<TTarget, TEvent>, runtime: RuntimeService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, catalog: CommandCatalogService<TTarget, TEvent>, options: CommandExecutorOptions<TTarget, TEvent>);
+    runCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult;
+    runBinding(bindingLayer: RegisteredLayer<TTarget, TEvent>, binding: CompiledBinding<TTarget, TEvent>, event: TEvent, focused: TTarget | null): boolean;
+    private executeResolvedCommand;
+}
+export {};

package/src/services/compiler.d.ts

@@ -0,0 +1,21 @@
+import type { ConditionService } from "./conditions.js";
+import type { State } from "./state.js";
+import type { NotificationService } from "./notify.js";
+import type { BindingInput, Scope, CompiledBindingsResult, KeyLike, KeymapEvent, KeySequencePart, ResolvedKeyToken } from "../types.js";
+export interface CompilerOptions {
+    warnUnknownField: (kind: "binding" | "layer", fieldName: string) => void;
+    warnUnknownToken: (token: string, sequence: string) => void;
+}
+export declare class CompilerService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly notify;
+    private readonly conditions;
+    private readonly options;
+    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, options: CompilerOptions);
+    parseTokenKey(key: KeyLike): KeySequencePart;
+    compileBindings(bindings: readonly BindingInput<TTarget, TEvent>[], tokens: ReadonlyMap<string, ResolvedKeyToken>, sourceScope: Scope, sourceTarget: TTarget | undefined, sourceLayerOrder: number, compileFields?: Readonly<Record<string, unknown>>): CompiledBindingsResult<TTarget, TEvent>;
+    private parseObjectKeyPart;
+    private normalizeBindingEvent;
+    private applyBindingTransformers;
+    private insertBinding;
+}

package/src/services/conditions.d.ts

@@ -0,0 +1,20 @@
+import type { NotificationService } from "./notify.js";
+import type { State } from "./state.js";
+import type { KeymapEvent, ReactiveMatcher, RegisteredLayer, RuntimeMatchable, RuntimeMatcher } from "../types.js";
+export declare class ConditionService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly notify;
+    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>);
+    buildRuntimeMatcher(matcher: (() => boolean) | ReactiveMatcher, source: string): RuntimeMatcher;
+    hasNoConditions(target: RuntimeMatchable): boolean;
+    registerRuntimeMatchable(target: RuntimeMatchable): void;
+    unregisterRuntimeMatchable(target: RuntimeMatchable): void;
+    invalidateRuntimeConditionKey(name: string): void;
+    matchesConditions(target: RuntimeMatchable): boolean;
+    layerMatchesRuntimeState(layer: RegisteredLayer<TTarget, TEvent>): boolean;
+    private matchRequirements;
+    private hasFreshConditionCache;
+    private updateConditionCache;
+    private matchesRuntimeMatcher;
+    private matchesRuntimeMatchers;
+}

package/src/services/dispatch.d.ts

@@ -0,0 +1,34 @@
+import type { CompilerService } from "./compiler.js";
+import type { ActivationService } from "./activation.js";
+import type { CommandExecutorService } from "./command-executor.js";
+import type { ConditionService } from "./conditions.js";
+import type { NotificationService } from "./notify.js";
+import type { RuntimeService } from "./runtime.js";
+import type { State } from "./state.js";
+import type { EventMatchResolver, KeyInterceptOptions, KeyInputContext, KeymapEvent, RawInterceptOptions, RawInputContext } from "../types.js";
+export declare class DispatchService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly notify;
+    private readonly runtime;
+    private readonly activation;
+    private readonly conditions;
+    private readonly executor;
+    private readonly compiler;
+    private readonly eventMatchResolverContext;
+    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, runtime: RuntimeService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, executor: CommandExecutorService<TTarget, TEvent>, compiler: CompilerService<TTarget, TEvent>);
+    intercept(name: "key", fn: (ctx: KeyInputContext<TEvent>) => void, options?: KeyInterceptOptions): () => void;
+    intercept(name: "raw", fn: (ctx: RawInputContext) => void, options?: RawInterceptOptions): () => void;
+    prependEventMatchResolver(resolver: EventMatchResolver<TEvent>): () => void;
+    appendEventMatchResolver(resolver: EventMatchResolver<TEvent>): () => void;
+    clearEventMatchResolvers(): void;
+    handleRawSequence(sequence: string): boolean;
+    handleKeyEvent(event: TEvent, release: boolean): void;
+    private dispatchReleaseLayers;
+    private dispatchLayers;
+    private dispatchPendingSequence;
+    private dispatchFromRoot;
+    private resolveEventMatchKeys;
+    private runReleaseBindings;
+    private getReachableChild;
+    private runBindings;
+}

package/src/services/environment.d.ts

@@ -0,0 +1,25 @@
+import type { CompilerService } from "./compiler.js";
+import type { LayerService } from "./layers.js";
+import type { NotificationService } from "./notify.js";
+import type { State } from "./state.js";
+import type { BindingExpander, BindingFieldCompiler, BindingParser, BindingTransformer, CommandFieldCompiler, KeyToken, KeymapEvent, LayerFieldCompiler } from "../types.js";
+export declare class EnvironmentService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly notify;
+    private readonly compiler;
+    private readonly layers;
+    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, compiler: CompilerService<TTarget, TEvent>, layers: LayerService<TTarget, TEvent>);
+    prependBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void;
+    appendBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void;
+    clearBindingTransformers(): void;
+    prependBindingParser(parser: BindingParser): () => void;
+    appendBindingParser(parser: BindingParser): () => void;
+    clearBindingParsers(): void;
+    registerToken(token: KeyToken): () => void;
+    prependBindingExpander(expander: BindingExpander): () => void;
+    appendBindingExpander(expander: BindingExpander): () => void;
+    clearBindingExpanders(): void;
+    registerLayerFields(fields: Record<string, LayerFieldCompiler>): () => void;
+    registerBindingFields(fields: Record<string, BindingFieldCompiler>): () => void;
+    registerCommandFields(fields: Record<string, CommandFieldCompiler>): () => void;
+}

package/src/services/keys.d.ts

@@ -0,0 +1,18 @@
+import type { KeyMatch, KeySequencePart, KeyStrokeInput, KeyStringifyInput, KeymapEvent, NormalizedKeyStroke, StringifyOptions } from "../types.js";
+export declare function normalizeBindingTokenName(token: string): string;
+export declare function normalizeKeyName(name: string): string;
+export declare function normalizeKeyStroke(input: KeyStrokeInput): NormalizedKeyStroke;
+export declare function normalizeEventKeyStroke(event: KeymapEvent): NormalizedKeyStroke;
+export declare function cloneKeyStroke(stroke: NormalizedKeyStroke): NormalizedKeyStroke;
+export declare function createKeySequencePart(input: KeyStrokeInput, options?: {
+    display?: string;
+    match?: KeyMatch;
+    tokenName?: string;
+}): KeySequencePart;
+export declare function cloneKeySequencePart(part: KeySequencePart): KeySequencePart;
+export declare function cloneKeySequence(parts: readonly KeySequencePart[]): KeySequencePart[];
+export declare function resolveKeyMatch(input: KeyStringifyInput): KeyMatch;
+export declare function createKeyMatch(input: KeyStrokeInput): KeyMatch;
+export declare function createTextKeyMatch(id: string): KeyMatch;
+export declare function stringifyKeyStroke(input: KeyStringifyInput, options?: StringifyOptions): string;
+export declare function stringifyKeySequence(input: readonly KeyStringifyInput[], options?: StringifyOptions): string;

package/src/services/layers.d.ts

@@ -0,0 +1,34 @@
+import type { CompilerService } from "./compiler.js";
+import type { CommandCatalogService } from "./command-catalog.js";
+import type { ConditionService } from "./conditions.js";
+import type { ActivationService } from "./activation.js";
+import type { KeymapEvent, KeymapHost, Layer, LayerAnalyzer, ResolvedKeyToken } from "../types.js";
+import type { State } from "./state.js";
+import type { NotificationService } from "./notify.js";
+interface LayersOptions<TTarget extends object, TEvent extends KeymapEvent> {
+    compiler: CompilerService<TTarget, TEvent>;
+    commands: CommandCatalogService<TTarget, TEvent>;
+    host: KeymapHost<TTarget, TEvent>;
+    warnUnknownField: (kind: "binding" | "layer", fieldName: string) => void;
+}
+export declare class LayerService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly notify;
+    private readonly conditions;
+    private readonly activation;
+    private readonly options;
+    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, options: LayersOptions<TTarget, TEvent>);
+    registerLayer(layer: Layer<TTarget, TEvent>): () => void;
+    applyTokenState(nextTokens: Map<string, ResolvedKeyToken>): void;
+    prependLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
+    appendLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
+    clearLayerAnalyzers(): void;
+    private normalizeScope;
+    private runLayerAnalyzers;
+    private compileLayerRuntimeState;
+    private getOrCreateTargetBucket;
+    private indexLayer;
+    private removeLayerFromIndex;
+    private unregisterLayer;
+}
+export {};

package/src/services/notify.d.ts

@@ -0,0 +1,18 @@
+import type { Events, HookName, Hooks, KeymapEvent } from "../types.js";
+import type { State } from "./state.js";
+import { Emitter } from "../lib/emitter.js";
+type DiagnosticEvents<TTarget extends object, TEvent extends KeymapEvent> = Pick<Events<TTarget, TEvent>, "warning" | "error">;
+export declare class NotificationService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly events;
+    private readonly hooks;
+    constructor(state: State<TTarget, TEvent>, events: Emitter<DiagnosticEvents<TTarget, TEvent>>, hooks: Emitter<Hooks<TTarget, TEvent>>);
+    runWithStateChangeBatch<T>(fn: () => T): T;
+    queueStateChange(): void;
+    emitWarning(code: string, warning: unknown, message: string): void;
+    emitError(code: string, error: unknown, message: string): void;
+    reportListenerError(name: HookName, error: unknown): void;
+    warnOnce(key: string, code: string, warning: unknown, message: string): void;
+    private flushStateChange;
+}
+export {};

package/src/services/primitives/active-layers.d.ts

@@ -0,0 +1,5 @@
+import type { KeymapEvent, KeymapHost, RegisteredLayer, RegisteredLayerBucket } from "../../types.js";
+export declare function getFocusedTargetIfAvailable<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>): TTarget | null;
+export declare function forEachActivationTarget<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, focused: TTarget | null, visit: (target: TTarget, isFocusedTarget: boolean) => boolean | void): void;
+export declare function getActiveLayersForFocused<TTarget extends object, TEvent extends KeymapEvent>(targetLayers: WeakMap<TTarget, RegisteredLayerBucket<TTarget, TEvent>>, host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): RegisteredLayer<TTarget, TEvent>[];
+export declare function isLayerActiveForFocused<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, layer: RegisteredLayer<TTarget, TEvent>, focused: TTarget | null): boolean;

package/src/services/primitives/binding-inputs.d.ts

@@ -0,0 +1,4 @@
+import type { BindingInput, Bindings, KeymapEvent, ParsedBindingInput } from "../../types.js";
+export declare function normalizeBindingInputs<TTarget extends object, TEvent extends KeymapEvent>(bindings: Bindings<TTarget, TEvent>): BindingInput<TTarget, TEvent>[];
+export declare function snapshotBindingInputs<TTarget extends object, TEvent extends KeymapEvent>(bindings: Bindings<TTarget, TEvent>): BindingInput<TTarget, TEvent>[];
+export declare function snapshotParsedBindingInput<TTarget extends object, TEvent extends KeymapEvent>(binding: ParsedBindingInput<TTarget, TEvent>): ParsedBindingInput<TTarget, TEvent>;

package/src/services/primitives/field-invariants.d.ts

@@ -0,0 +1,3 @@
+import type { Attributes, EventData } from "../../types.js";
+export declare function mergeRequirement(target: EventData, name: string, value: unknown, source: string): void;
+export declare function mergeAttribute(target: Attributes, name: string, value: unknown, source: string): void;

package/src/services/runtime.d.ts

@@ -0,0 +1,15 @@
+import type { EventData, KeymapEvent } from "../types.js";
+import type { ActivationService } from "./activation.js";
+import type { ConditionService } from "./conditions.js";
+import type { NotificationService } from "./notify.js";
+import type { State } from "./state.js";
+export declare class RuntimeService<TTarget extends object, TEvent extends KeymapEvent> {
+    private readonly state;
+    private readonly notify;
+    private readonly conditions;
+    private readonly activation;
+    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>);
+    getData(name: string): unknown;
+    setData(name: string, value: unknown): void;
+    getReadonlyData(): Readonly<EventData>;
+}

package/src/services/state.d.ts

@@ -0,0 +1,102 @@
+import type { ActiveKey, BindingExpander, BindingFieldCompiler, BindingParser, BindingTransformer, CommandFieldCompiler, CommandResolver, EventData, EventMatchResolver, KeyInputContext, KeySequencePart, KeymapEvent, LayerAnalyzer, LayerFieldCompiler, PendingSequenceState, RawInputContext, RegisteredCommand, RegisteredLayer, RegisteredLayerBucket, ResolvedBindingCommand, RuntimeMatchable } from "../types.js";
+import { OrderedRegistry, PriorityRegistry } from "../lib/registry.js";
+export interface CoreState {
+    order: number;
+}
+export interface EnvironmentState<TTarget extends object, TEvent extends KeymapEvent> {
+    tokens: Map<string, import("../types.js").ResolvedKeyToken>;
+    layerFields: Map<string, LayerFieldCompiler>;
+    bindingExpanders: OrderedRegistry<BindingExpander>;
+    bindingParsers: OrderedRegistry<BindingParser>;
+    bindingTransformers: OrderedRegistry<BindingTransformer<TTarget, TEvent>>;
+    bindingFields: Map<string, BindingFieldCompiler>;
+    commandFields: Map<string, CommandFieldCompiler>;
+}
+export interface DispatchState<TEvent extends KeymapEvent> {
+    eventMatchResolvers: OrderedRegistry<EventMatchResolver<TEvent>>;
+    keyHooks: PriorityRegistry<(ctx: KeyInputContext<TEvent>) => void, {
+        priority: number;
+        release: boolean;
+    }>;
+    rawHooks: PriorityRegistry<(ctx: RawInputContext) => void, {
+        priority: number;
+    }>;
+}
+export interface LayersState<TTarget extends object, TEvent extends KeymapEvent> {
+    layers: Set<RegisteredLayer<TTarget, TEvent>>;
+    targetLayers: WeakMap<TTarget, RegisteredLayerBucket<TTarget, TEvent>>;
+    layersWithConditions: number;
+    layersWithCommands: number;
+    layerAnalyzers: OrderedRegistry<LayerAnalyzer<TTarget, TEvent>>;
+}
+export interface LayerCommandEntry<TTarget extends object, TEvent extends KeymapEvent> {
+    layer: RegisteredLayer<TTarget, TEvent>;
+    command: RegisteredCommand<TTarget, TEvent>;
+}
+export interface ResolvedCommandEntry<TTarget extends object, TEvent extends KeymapEvent> {
+    target?: TTarget;
+    resolved: ResolvedBindingCommand<TTarget, TEvent>;
+}
+export interface ActiveCommandView<TTarget extends object, TEvent extends KeymapEvent> {
+    cacheable: boolean;
+    entries: readonly LayerCommandEntry<TTarget, TEvent>[];
+    reachable: readonly LayerCommandEntry<TTarget, TEvent>[];
+    reachableByName: ReadonlyMap<string, LayerCommandEntry<TTarget, TEvent>>;
+    chainsByName: ReadonlyMap<string, readonly LayerCommandEntry<TTarget, TEvent>[]>;
+    resolvedWithoutRecordChains: Map<string, readonly ResolvedCommandEntry<TTarget, TEvent>[]>;
+    resolvedWithRecordChains: Map<string, readonly ResolvedCommandEntry<TTarget, TEvent>[]>;
+    fallbackWithoutRecord: Map<string, ResolvedBindingCommand<TTarget, TEvent> | null>;
+    fallbackWithRecord: Map<string, ResolvedBindingCommand<TTarget, TEvent> | null>;
+    fallbackWithoutRecordErrors: Set<string>;
+    fallbackWithRecordErrors: Set<string>;
+}
+export interface CommandsState<TTarget extends object, TEvent extends KeymapEvent> {
+    commandMetadataVersion: number;
+    registeredNames: Map<string, number>;
+    commandResolvers: OrderedRegistry<CommandResolver<TTarget, TEvent>>;
+    activeCommandViewVersion: number;
+    activeCommandView?: ActiveCommandView<TTarget, TEvent>;
+    registeredCommandEntriesCacheVersion: number;
+    registeredCommandEntriesCache: readonly LayerCommandEntry<TTarget, TEvent>[];
+}
+export interface ProjectionState<TTarget extends object, TEvent extends KeymapEvent> {
+    pendingSequence: PendingSequenceState<TTarget, TEvent> | null;
+    pendingSequenceCacheVersion: number;
+    pendingSequenceCache: readonly KeySequencePart[];
+    activeKeysPlainCacheVersion: number;
+    activeKeysPlainCache: readonly ActiveKey<TTarget, TEvent>[];
+    activeKeysBindingsCacheVersion: number;
+    activeKeysBindingsCache: readonly ActiveKey<TTarget, TEvent>[];
+    activeKeysMetadataCacheVersion: number;
+    activeKeysMetadataCache: readonly ActiveKey<TTarget, TEvent>[];
+    activeKeysBindingsAndMetadataCacheVersion: number;
+    activeKeysBindingsAndMetadataCache: readonly ActiveKey<TTarget, TEvent>[];
+}
+export interface ConditionsState {
+    runtimeKeyDependents: Map<string, Set<RuntimeMatchable>>;
+}
+export interface RuntimeState {
+    data: EventData;
+    dataVersion: number;
+    readonlyDataVersion: number;
+    readonlyData: Readonly<EventData>;
+}
+export interface NotifyState {
+    derivedStateVersion: number;
+    stateChangeDepth: number;
+    stateChangePending: boolean;
+    flushingStateChange: boolean;
+    usedWarningKeys: Set<string>;
+}
+export interface State<TTarget extends object, TEvent extends KeymapEvent> {
+    core: CoreState;
+    environment: EnvironmentState<TTarget, TEvent>;
+    dispatch: DispatchState<TEvent>;
+    layers: LayersState<TTarget, TEvent>;
+    commands: CommandsState<TTarget, TEvent>;
+    projection: ProjectionState<TTarget, TEvent>;
+    conditions: ConditionsState;
+    runtime: RuntimeState;
+    notify: NotifyState;
+}
+export declare function createKeymapState<TTarget extends object, TEvent extends KeymapEvent>(): State<TTarget, TEvent>;

package/src/services/values.d.ts

@@ -0,0 +1,7 @@
+export declare function getErrorMessage(error: unknown, fallback: string): string;
+export declare function isPromiseLike(value: unknown): value is Promise<unknown>;
+export declare function snapshotDataValue(value: unknown, options?: {
+    deep?: boolean;
+    freeze?: boolean;
+    preserveNonPlainObjects?: boolean;
+}): unknown;