@opentui/keymap 0.2.1 → 0.2.3

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

@@ -1,61 +1,44 @@
-import type { Attributes, BindingCommand, CommandEntry, CommandDefinition, CommandResolutionStatus, CommandQuery, CommandRecord, CommandResolver, CompiledBinding, KeymapEvent, KeymapHost, RegisteredCommand, ResolvedBindingCommand } from "../types.js";
+import type { ActiveBinding, Attributes, Command, CommandEntry, CommandBindingsQuery, CommandResolutionStatus, CommandQuery, CommandResolver, BindingState, KeymapEvent, KeymapHost, CommandState } from "../types.js";
 import type { ConditionService } from "./conditions.js";
 import type { NotificationService } from "./notify.js";
-import type { ActiveCommandView, RegisteredCommandView, ResolvedCommandEntry, State } from "./state.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>[];
+interface ResolvedCommandLookup<TTarget extends object, TEvent extends KeymapEvent> {
+    resolved?: ResolvedCommandEntry<TTarget, TEvent>;
+    hadError: boolean;
+}
+interface CommandExecutionFields {
+    input: string;
+    payload?: unknown;
+}
+export interface CommandCatalogService<TTarget extends object, TEvent extends KeymapEvent> {
+    normalizeCommands(commands: readonly Command<TTarget, TEvent>[]): CommandState<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): {
+    getCommands(query?: CommandQuery<TTarget, TEvent>): readonly Command<TTarget, TEvent>[];
+    getCommandEntries(query?: CommandQuery<TTarget, TEvent>): readonly CommandEntry<TTarget, TEvent>[];
+    getCommandBindings(query: CommandBindingsQuery<TTarget>): ReadonlyMap<string, readonly ActiveBinding<TTarget, TEvent>[]>;
+    getResolvedCommandChain(command: string, focused: TTarget | null, execution?: CommandExecutionFields): {
         entries?: readonly ResolvedCommandEntry<TTarget, TEvent>[];
         hadError: boolean;
     };
-    getRegisteredResolvedEntries(command: string, includeRecord: boolean): readonly ResolvedCommandEntry<TTarget, TEvent>[] | undefined;
-    getRegisteredResolverFallback(command: string, includeRecord: boolean): {
-        resolved?: ResolvedBindingCommand<TTarget, TEvent>;
-        hadError: boolean;
-    };
-    getCommandAttrs(command: string, focused: TTarget | null): Readonly<Attributes> | undefined;
-    getTopCommandRecord(command: string, focused: TTarget | null): CommandRecord | undefined;
-    getTopRegisteredCommandRecord(command: string): CommandRecord | undefined;
-    getDispatchUnavailableCommandState(command: string, focused: TTarget | null, includeRecord: boolean): {
+    getRegisteredResolvedEntries(command: string): readonly ResolvedCommandEntry<TTarget, TEvent>[] | undefined;
+    getActiveRegisteredResolvedEntries(command: string, focused: TTarget | null): readonly ResolvedCommandEntry<TTarget, TEvent>[] | undefined;
+    resolveRegisteredResolverFallback(command: string, execution?: CommandExecutionFields): ResolvedCommandLookup<TTarget, TEvent>;
+    resolveActiveResolverFallback(command: string, focused: TTarget | null, execution?: CommandExecutionFields): ResolvedCommandLookup<TTarget, TEvent>;
+    getTopCommand(command: string, focused: TTarget | null): Command<TTarget, TEvent> | undefined;
+    getDispatchUnavailableCommandState(command: string, focused: TTarget | null, includeCommand: boolean): {
         reason: "inactive" | "disabled";
-        command?: CommandRecord;
+        command?: Command<TTarget, TEvent>;
     } | undefined;
     getActiveCommandView(focused: TTarget | null): ActiveCommandView<TTarget, TEvent>;
-    getRegisteredCommandView(): RegisteredCommandView<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 getTopRegisteredCommand;
-    private getFallbackResolvedCommand;
-    private getResolvedCommandChainFromView;
-    private getRegisteredLayerCommandEntries;
-    private getCommandQueryContext;
-    private getFilteredCommandEntries;
-    private collectCommandEntryBindings;
-    private collectBindingForCommandEntries;
-    private resolveCommandWithResolvers;
-    private createCommandResolverContext;
+    isBindingVisible(binding: BindingState<TTarget, TEvent>, focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): boolean;
+    getBindingCommandAttrs(binding: BindingState<TTarget, TEvent>, focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): Readonly<Attributes> | undefined;
+    getCommandResolutionStatus(command: string, layerCommands?: readonly CommandState<TTarget, TEvent>[]): CommandResolutionStatus;
 }
-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 declare function createCommandCatalogService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, options: CommandCatalogOptions): CommandCatalogService<TTarget, TEvent>;
+export declare function getCommand<TTarget extends object, TEvent extends KeymapEvent>(state: CommandState<TTarget, TEvent>): Command<TTarget, TEvent>;
 export {};

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

@@ -1,6 +1,6 @@
 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 { BindingState, 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";
@@ -8,16 +8,10 @@ interface CommandExecutorOptions<TTarget extends object, TEvent extends KeymapEv
     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;
-    dispatchCommand(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 interface CommandExecutorService<TTarget extends object, TEvent extends KeymapEvent> {
+    runCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult<TTarget, TEvent>;
+    dispatchCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult<TTarget, TEvent>;
+    runBinding(bindingLayer: RegisteredLayer<TTarget, TEvent>, binding: BindingState<TTarget, TEvent>, event: TEvent, focused: TTarget | null, payload?: unknown): boolean;
 }
+export declare function createCommandExecutorService<TTarget extends object, TEvent extends KeymapEvent>(notify: NotificationService<TTarget, TEvent>, runtime: RuntimeService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, catalog: CommandCatalogService<TTarget, TEvent>, options: CommandExecutorOptions<TTarget, TEvent>): CommandExecutorService<TTarget, TEvent>;
 export {};

package/src/services/compiler.d.ts

@@ -1,21 +1,15 @@
 import type { ConditionService } from "./conditions.js";
 import type { State } from "./state.js";
 import type { NotificationService } from "./notify.js";
-import type { BindingInput, CompiledBindingsResult, KeyLike, KeymapEvent, KeySequencePart, ResolvedKeyToken } from "../types.js";
+import type { Binding, BindingCompilationResult, KeyLike, KeymapEvent, KeySequencePart, ResolvedKeyToken, StringifyOptions } 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);
+export interface CompilerService<TTarget extends object, TEvent extends KeymapEvent> {
     parseTokenKey(key: KeyLike): KeySequencePart;
-    compileBindings(bindings: readonly BindingInput<TTarget, TEvent>[], tokens: ReadonlyMap<string, ResolvedKeyToken>, sourceTarget: TTarget | undefined, sourceLayerOrder: number, compileFields?: Readonly<Record<string, unknown>>): CompiledBindingsResult<TTarget, TEvent>;
-    private parseObjectKeyPart;
-    private normalizeBindingEvent;
-    private applyBindingTransformers;
-    private insertBinding;
+    parseKeySequence(key: KeyLike): KeySequencePart[];
+    formatKey(key: KeyLike, options?: StringifyOptions): string;
+    compileBindings(bindings: readonly Binding<TTarget, TEvent>[], tokens: ReadonlyMap<string, ResolvedKeyToken>, sourceTarget: TTarget | undefined, sourceLayerOrder: number, fields?: Readonly<Record<string, unknown>>): BindingCompilationResult<TTarget, TEvent>;
 }
+export declare function createCompilerService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, options: CompilerOptions): CompilerService<TTarget, TEvent>;

package/src/services/conditions.d.ts

@@ -1,20 +1,8 @@
-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>);
+import type { NotificationService } from "./notify.js";
+import type { KeymapEvent, ReactiveMatcher, RuntimeMatchable, RuntimeMatcher } from "../types.js";
+export interface ConditionService<TTarget extends object, TEvent extends KeymapEvent> {
     buildRuntimeMatcher(matcher: (() => boolean) | ReactiveMatcher, source: string): RuntimeMatcher;
-    hasNoConditions(target: RuntimeMatchable): boolean;
-    indexRuntimeMatchable(target: RuntimeMatchable): void;
-    unindexRuntimeMatchable(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;
 }
+export declare function createConditionService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>): ConditionService<TTarget, TEvent>;

package/src/services/dispatch-decisions.d.ts

@@ -0,0 +1,21 @@
+import type { KeyDeferredDisambiguationDecision, KeyDeferredDisambiguationHandler, KeyDisambiguationDecision, KeymapEvent, PendingSequenceCapture } from "../types.js";
+export type SyncDecisionAction = "run-exact" | "continue-sequence" | "clear" | "defer";
+export type DeferredDecisionAction = "run-exact" | "continue-sequence" | "clear";
+export interface InternalDisambiguationDecision extends KeyDisambiguationDecision {
+    readonly action: SyncDecisionAction;
+    readonly handler?: KeyDeferredDisambiguationHandler<any, any>;
+}
+export interface InternalDeferredDisambiguationDecision extends KeyDeferredDisambiguationDecision {
+    readonly action: DeferredDecisionAction;
+}
+export interface PendingDisambiguation<TTarget extends object, TEvent extends KeymapEvent> {
+    id: number;
+    controller: AbortController;
+    captures: readonly PendingSequenceCapture<TTarget, TEvent>[];
+    apply: (decision: InternalDeferredDisambiguationDecision | void) => void;
+}
+export declare function createSyncDecision(action: SyncDecisionAction, handler?: KeyDeferredDisambiguationHandler<any, any>): InternalDisambiguationDecision;
+export declare function createDeferredDecision(action: DeferredDecisionAction): InternalDeferredDisambiguationDecision;
+export declare function isSyncDecision(value: unknown): value is InternalDisambiguationDecision;
+export declare function isDeferredDecision(value: unknown): value is InternalDeferredDisambiguationDecision;
+export declare function sleepWithSignal(ms: number, signal: AbortSignal): Promise<boolean>;

package/src/services/dispatch-patterns.d.ts

@@ -0,0 +1,5 @@
+import type { KeymapEvent, KeySequencePart, PendingSequenceCapture, ResolvedSequencePattern, SequencePatternMatch } from "../types.js";
+import type { NotificationService } from "./notify.js";
+export declare function matchSequencePattern<TTarget extends object, TEvent extends KeymapEvent>(patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, notify: NotificationService<TTarget, TEvent>, patternName: string, event: TEvent): SequencePatternMatch | undefined;
+export declare function createPatternEventPart<TEvent extends KeymapEvent>(patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, event: TEvent, patternName: string, match: SequencePatternMatch): KeySequencePart;
+export declare function createSequencePayload<TTarget extends object, TEvent extends KeymapEvent>(patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, notify: NotificationService<TTarget, TEvent>, capture?: PendingSequenceCapture<TTarget, TEvent>): unknown;

package/src/services/dispatch.d.ts

@@ -1,4 +1,5 @@
 import type { CompilerService } from "./compiler.js";
+import type { RuntimeEmitter } from "../lib/runtime-utils.js";
 import type { ActivationService } from "./activation.js";
 import type { CommandExecutorService } from "./command-executor.js";
 import type { CommandCatalogService } from "./command-catalog.js";
@@ -7,22 +8,10 @@ import type { LayerService } from "./layers.js";
 import type { NotificationService } from "./notify.js";
 import type { RuntimeService } from "./runtime.js";
 import type { State } from "./state.js";
-import { type EventMatchResolver, type KeyDisambiguationResolver, type KeyInterceptOptions, type KeyInputContext, type KeymapEvent, type PendingSequenceState, type RawInterceptOptions, type 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 catalog;
-    private readonly layers;
-    private readonly eventMatchResolverContext;
-    private pendingDisambiguation;
-    private nextPendingDisambiguationId;
-    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>, catalog: CommandCatalogService<TTarget, TEvent>, layers: LayerService<TTarget, TEvent>);
+import { type EventMatchResolver, type KeyDisambiguationResolver, type KeyInterceptOptions, type KeyAfterInputContext, type KeyInputContext, type KeymapEvent, type PendingSequenceState, type RawInterceptOptions, type RawInputContext, type Hooks } from "../types.js";
+export interface DispatchService<TTarget extends object, TEvent extends KeymapEvent> {
     intercept(name: "key", fn: (ctx: KeyInputContext<TEvent>) => void, options?: KeyInterceptOptions): () => void;
+    intercept(name: "key:after", fn: (ctx: KeyAfterInputContext<TTarget, 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;
@@ -30,33 +19,8 @@ export declare class DispatchService<TTarget extends object, TEvent extends Keym
     prependDisambiguationResolver(resolver: KeyDisambiguationResolver<TTarget, TEvent>): () => void;
     appendDisambiguationResolver(resolver: KeyDisambiguationResolver<TTarget, TEvent>): () => void;
     clearDisambiguationResolvers(): void;
-    handlePendingSequenceChange(_previous: PendingSequenceState<TTarget, TEvent> | null, _next: PendingSequenceState<TTarget, TEvent> | null): void;
+    handlePendingSequenceChange(previous: PendingSequenceState<TTarget, TEvent> | null, next: PendingSequenceState<TTarget, TEvent> | null): void;
     handleRawSequence(sequence: string): boolean;
     handleKeyEvent(event: TEvent, release: boolean): void;
-    private mutateDisambiguationResolvers;
-    private dispatchReleaseLayers;
-    private dispatchLayers;
-    private dispatchPendingSequence;
-    private dispatchPendingCapturesFromIndex;
-    private dispatchFromRoot;
-    private dispatchFromRootAtIndex;
-    private tryResolveRootAmbiguity;
-    private tryResolvePendingAmbiguity;
-    private tryResolveAmbiguity;
-    private applySyncDecision;
-    private resolveDisambiguation;
-    private scheduleDeferredDisambiguation;
-    private executeDeferredDisambiguation;
-    private applyDeferredDisambiguationResult;
-    private finishPendingDisambiguation;
-    private cancelPendingDisambiguation;
-    private isPendingDisambiguationCurrent;
-    private sleepWithSignal;
-    private warnUnresolvedAmbiguity;
-    private collectPendingCapturesFromRoot;
-    private collectPendingCapturesFromAdvanced;
-    private resolveEventMatchKeys;
-    private runReleaseBindings;
-    private getReachableChild;
-    private runBindings;
 }
+export declare function createDispatchService<TTarget extends object, TEvent extends KeymapEvent>(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>, catalog: CommandCatalogService<TTarget, TEvent>, layers: LayerService<TTarget, TEvent>, hooks: RuntimeEmitter<Hooks<TTarget, TEvent>>): DispatchService<TTarget, TEvent>;

package/src/services/environment.d.ts

@@ -2,24 +2,9 @@ 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;
-}
+import type { KeyToken, KeymapEvent, SequencePattern } from "../types.js";
+type FieldKind = "layer" | "binding" | "command";
+export declare function registerToken<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, compiler: CompilerService<TTarget, TEvent>, layers: LayerService<TTarget, TEvent>, token: KeyToken): () => void;
+export declare function registerSequencePattern<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, layers: LayerService<TTarget, TEvent>, pattern: SequencePattern<TEvent>): () => void;
+export declare function registerFields<TTarget extends object, TEvent extends KeymapEvent, T>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, kind: FieldKind, fields: Record<string, T>): () => void;
+export {};

package/src/services/extension-context.d.ts

@@ -0,0 +1,16 @@
+import type { ActivationService } from "./activation.js";
+import type { CommandCatalogService } from "./command-catalog.js";
+import type { ConditionService } from "./conditions.js";
+import type { State } from "./state.js";
+import type { KeymapEvent, KeymapHost } from "../types.js";
+export declare const KEYMAP_EXTENSION_CONTEXT: unique symbol;
+export interface KeymapExtensionContext<TTarget extends object, TEvent extends KeymapEvent> {
+    state: State<TTarget, TEvent>;
+    host: KeymapHost<TTarget, TEvent>;
+    conditions: ConditionService<TTarget, TEvent>;
+    catalog: CommandCatalogService<TTarget, TEvent>;
+    activation: ActivationService<TTarget, TEvent>;
+}
+export interface KeymapExtensionProvider<TTarget extends object, TEvent extends KeymapEvent> {
+    [KEYMAP_EXTENSION_CONTEXT](): KeymapExtensionContext<TTarget, TEvent>;
+}

package/src/services/layer-diagnostics.d.ts

@@ -0,0 +1,10 @@
+import type { CommandCatalogService } from "./command-catalog.js";
+import type { LayerDiagnostics } from "./layers.js";
+import type { NotificationService } from "./notify.js";
+import type { KeymapEvent, LayerAnalyzer } from "../types.js";
+export interface LayerDiagnosticsCore<TTarget extends object, TEvent extends KeymapEvent> extends LayerDiagnostics<TTarget, TEvent> {
+    prependLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
+    appendLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
+    clearLayerAnalyzers(): void;
+}
+export declare function createLayerDiagnostics<TTarget extends object, TEvent extends KeymapEvent>(notify: NotificationService<TTarget, TEvent>, commands: CommandCatalogService<TTarget, TEvent>): LayerDiagnosticsCore<TTarget, TEvent>;

package/src/services/layers.d.ts

@@ -2,40 +2,32 @@ 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 { Binding, BindingState, KeymapEvent, KeymapHost, Layer, ResolvedKeyToken, CommandState } 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>;
+    diagnostics?: LayerDiagnostics<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>);
+export interface AnalyzeLayerOptions<TTarget extends object, TEvent extends KeymapEvent> {
+    target?: TTarget;
+    order: number;
+    commands: readonly CommandState<TTarget, TEvent>[];
+    sourceBindings: readonly Binding<TTarget, TEvent>[];
+    bindings: readonly BindingState<TTarget, TEvent>[];
+    hasTokenBindings: boolean;
+}
+export interface LayerDiagnostics<TTarget extends object, TEvent extends KeymapEvent> {
+    analyzeLayer(options: AnalyzeLayerOptions<TTarget, TEvent>): void;
+}
+export interface LayerService<TTarget extends object, TEvent extends KeymapEvent> {
     registerLayer(layer: Layer<TTarget, TEvent>): () => void;
     applyTokenState(nextTokens: Map<string, ResolvedKeyToken>): void;
     recompileBindings(): void;
-    prependLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
-    appendLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
-    clearLayerAnalyzers(): void;
     cleanup(): void;
-    private normalizeTargetMode;
-    private runLayerAnalyzers;
-    private compileLayerRuntimeState;
-    private compileLayerBindings;
-    private applyCompiledBindings;
-    private indexLayer;
-    private removeLayerFromIndex;
-    private unregisterLayer;
-    private connectRuntimeMatchable;
-    private disconnectRuntimeMatchable;
-    private attachReactiveMatchers;
-    private detachReactiveMatchers;
 }
+export declare function createLayerService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, options: LayersOptions<TTarget, TEvent>): LayerService<TTarget, TEvent>;
 export {};

package/src/services/notify.d.ts

@@ -1,19 +1,17 @@
 import type { Events, HookName, Hooks, KeymapEvent } from "../types.js";
+import type { RuntimeEmitter } from "../lib/runtime-utils.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 const MAX_STATE_CHANGE_FLUSH_ITERATIONS = 1000;
-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>>);
+export interface NotificationService<TTarget extends object, TEvent extends KeymapEvent> {
     runWithStateChangeBatch<T>(fn: () => T): T;
-    queueStateChange(): void;
+    queueStateChange(options?: {
+        invalidateCaches?: boolean;
+    }): 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 declare function createNotificationService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, events: RuntimeEmitter<DiagnosticEvents<TTarget, TEvent>>, hooks: RuntimeEmitter<Hooks<TTarget, TEvent>>): NotificationService<TTarget, TEvent>;
 export {};

package/src/services/pending-sequence.d.ts

@@ -0,0 +1,4 @@
+import type { KeymapEvent, KeySequencePart, PendingSequenceCapture, PendingSequenceState } from "../types.js";
+export declare function isSamePendingSequence<TTarget extends object, TEvent extends KeymapEvent>(current: PendingSequenceState<TTarget, TEvent> | null, next: PendingSequenceState<TTarget, TEvent> | null): boolean;
+export declare function popCapture<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>): PendingSequenceCapture<TTarget, TEvent> | undefined;
+export declare function collectSequencePartsFromPending<TTarget extends object, TEvent extends KeymapEvent>(pending: PendingSequenceState<TTarget, TEvent>): KeySequencePart[];

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

@@ -1,8 +1,7 @@
 import type { KeymapEvent, KeymapHost, RegisteredLayer } from "../../types.js";
-import type { LayersState } from "../state.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 getActivationPath<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): Set<TTarget>;
-export declare function getActiveLayersForFocused<TTarget extends object, TEvent extends KeymapEvent>(state: LayersState<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): readonly RegisteredLayer<TTarget, TEvent>[];
-export declare function invalidateCachedActiveLayers<TTarget extends object, TEvent extends KeymapEvent>(state: LayersState<TTarget, TEvent>): void;
+export declare function getActiveLayersForFocused<TTarget extends object, TEvent extends KeymapEvent>(layers: readonly RegisteredLayer<TTarget, TEvent>[] | ReadonlySet<RegisteredLayer<TTarget, TEvent>>, host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): readonly RegisteredLayer<TTarget, TEvent>[];
+export declare function getSortedLayers<TTarget extends object, TEvent extends KeymapEvent>(layers: ReadonlySet<RegisteredLayer<TTarget, TEvent>>): RegisteredLayer<TTarget, TEvent>[];
 export declare function isLayerActiveForFocused<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, layer: RegisteredLayer<TTarget, TEvent>, focused: TTarget | null, activationPath?: ReadonlySet<TTarget>): boolean;

package/src/services/primitives/bindings.d.ts

@@ -0,0 +1,4 @@
+import type { Binding, BindingsValidationResult, Bindings, KeymapEvent, ParsedBinding } from "../../types.js";
+export declare function validateBindings(bindings: unknown): BindingsValidationResult;
+export declare function snapshotBindings<TTarget extends object, TEvent extends KeymapEvent>(bindings: Bindings<TTarget, TEvent>): Binding<TTarget, TEvent>[];
+export declare function snapshotParsedBinding<TTarget extends object, TEvent extends KeymapEvent>(binding: ParsedBinding<TTarget, TEvent>): ParsedBinding<TTarget, TEvent>;

package/src/services/primitives/command-normalization.d.ts

@@ -0,0 +1,3 @@
+import type { BindingCommand, KeymapEvent } from "../../types.js";
+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;

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

@@ -1,3 +1,18 @@
-import type { Attributes, EventData } from "../../types.js";
+import type { Attributes, BindingFieldContext, CommandFieldContext, EventData, KeymapEvent, LayerFieldContext, RuntimeMatcher } from "../../types.js";
+import type { ConditionService } from "../conditions.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;
+interface FieldCompilerContextOptions<TTarget extends object, TEvent extends KeymapEvent> {
+    fieldName: string;
+    conditions: ConditionService<TTarget, TEvent>;
+    requirements: EventData;
+    matchers: RuntimeMatcher[];
+    attrs?: Attributes;
+}
+export declare function createFieldCompilerContext<TTarget extends object, TEvent extends KeymapEvent>(options: FieldCompilerContextOptions<TTarget, TEvent> & {
+    attrs: Attributes;
+}): BindingFieldContext & CommandFieldContext & LayerFieldContext;
+export declare function createFieldCompilerContext<TTarget extends object, TEvent extends KeymapEvent>(options: FieldCompilerContextOptions<TTarget, TEvent> & {
+    attrs?: undefined;
+}): LayerFieldContext;
+export {};

package/src/services/primitives/pending-captures.d.ts

@@ -0,0 +1,5 @@
+import type { KeymapEvent, PendingSequenceCapture, ResolvedSequencePattern } from "../../types.js";
+export declare function patternCaptureCount<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>): number;
+export declare function captureHasMinimum<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, missingPatternResult?: boolean): boolean;
+export declare function captureHasContinuations<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, missingPatternMinimum?: boolean): boolean;
+export declare function captureIsExact<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>): boolean;

package/src/services/runtime-view.d.ts

@@ -0,0 +1,5 @@
+import type { ConditionService } from "./conditions.js";
+import type { ActiveCommandView, CommandView, State } from "./state.js";
+import type { KeymapEvent, KeymapHost } from "../types.js";
+export declare function getRegisteredCommandView<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>): CommandView<TTarget, TEvent>;
+export declare function getActiveCommandView<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, focused: TTarget | null): ActiveCommandView<TTarget, TEvent>;

package/src/services/runtime.d.ts

@@ -1,15 +1,10 @@
 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>);
+export interface RuntimeService<TTarget extends object, TEvent extends KeymapEvent> {
     getData(name: string): unknown;
     setData(name: string, value: unknown): void;
     getReadonlyData(): Readonly<EventData>;
 }
+export declare function createRuntimeService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>): RuntimeService<TTarget, TEvent>;

package/src/services/sequence-index.d.ts

@@ -0,0 +1,24 @@
+import type { BindingState, KeymapEvent, KeySequencePart, KeyMatch, PendingSequenceCapture, PendingSequencePatternCapture, RegisteredLayer, ResolvedSequencePattern, SequenceNode, SequencePatternMatch } from "../types.js";
+export interface SequenceActiveOption<TTarget extends object, TEvent extends KeymapEvent> {
+    part: KeySequencePart;
+    binding: BindingState<TTarget, TEvent>;
+    index: number;
+    exact: boolean;
+    continues: boolean;
+}
+export declare function createSequenceNode<TTarget extends object, TEvent extends KeymapEvent>(parent: SequenceNode<TTarget, TEvent> | null, stroke: KeySequencePart["stroke"] | null, match: KeySequencePart["match"] | null, pattern?: ResolvedSequencePattern<TEvent>): SequenceNode<TTarget, TEvent>;
+export declare function buildSequenceTree<TTarget extends object, TEvent extends KeymapEvent>(bindings: readonly BindingState<TTarget, TEvent>[], patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>): SequenceNode<TTarget, TEvent>;
+export declare function getCaptureNode<TTarget extends object, TEvent extends KeymapEvent>(root: SequenceNode<TTarget, TEvent>, capture: import("../types.js").PendingSequenceCapture<TTarget, TEvent>): SequenceNode<TTarget, TEvent> | undefined;
+export declare function getNodeSequence<TTarget extends object, TEvent extends KeymapEvent>(node: SequenceNode<TTarget, TEvent>): KeySequencePart[];
+export declare function getNodePresentation<TTarget extends object, TEvent extends KeymapEvent>(node: SequenceNode<TTarget, TEvent>): {
+    display: string;
+    tokenName?: string;
+};
+export declare function firstNodeForMatch<TTarget extends object, TEvent extends KeymapEvent>(root: SequenceNode<TTarget, TEvent>, match: KeyMatch): SequenceNode<TTarget, TEvent> | undefined;
+export declare function childNodes<TTarget extends object, TEvent extends KeymapEvent>(node: SequenceNode<TTarget, TEvent>): SequenceNode<TTarget, TEvent>[];
+export declare function activeOptionsForBindings<TTarget extends object, TEvent extends KeymapEvent>(bindings: readonly BindingState<TTarget, TEvent>[]): SequenceActiveOption<TTarget, TEvent>[];
+export declare function activeOptionsForCaptures<TTarget extends object, TEvent extends KeymapEvent>(captures: readonly PendingSequenceCapture<TTarget, TEvent>[], patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>): SequenceActiveOption<TTarget, TEvent>[];
+export declare function capturePriority<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, matchKeys: readonly KeyMatch[]): number;
+export declare function advanceSequenceBinding<TTarget extends object, TEvent extends KeymapEvent>(layer: RegisteredLayer<TTarget, TEvent>, binding: BindingState<TTarget, TEvent>, index: number, parts: readonly KeySequencePart[], patterns: readonly PendingSequencePatternCapture[] | undefined, matchKeys: readonly KeyMatch[], event: TEvent, matchPattern: (patternName: string, event: TEvent) => SequencePatternMatch | undefined, createPatternPart: (event: TEvent, patternName: string, match: SequencePatternMatch) => KeySequencePart): PendingSequenceCapture<TTarget, TEvent> | undefined;
+export declare function advanceSequenceCapture<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, matchKeys: readonly KeyMatch[], event: TEvent, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, matchPattern: (patternName: string, event: TEvent) => SequencePatternMatch | undefined, createPatternPart: (event: TEvent, patternName: string, match: SequencePatternMatch) => KeySequencePart): PendingSequenceCapture<TTarget, TEvent> | undefined;
+export declare function collectRootSequenceCaptures<TTarget extends object, TEvent extends KeymapEvent>(layer: RegisteredLayer<TTarget, TEvent>, matchKeys: readonly KeyMatch[], event: TEvent, matchPattern: (patternName: string, event: TEvent) => SequencePatternMatch | undefined, createPatternPart: (event: TEvent, patternName: string, match: SequencePatternMatch) => KeySequencePart): PendingSequenceCapture<TTarget, TEvent>[];