@opentui/keymap 0.2.2 → 0.2.3

package/src/opentui.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/opentui.ts"],
+  "sourcesContent": [
+    "import { CliRenderEvents, KeyEvent, RenderableEvents, type CliRenderer, type Renderable } from \"@opentui/core\"\nimport { Keymap, type HostMetadata, type HostPlatform, type KeymapHost } from \"@opentui/keymap\"\nimport { registerDefaultKeys, registerEnabledFields, registerMetadataFields } from \"@opentui/keymap/addons\"\n\nfunction createSyntheticCommandEvent(): KeyEvent {\n  return new KeyEvent({\n    name: \"command\",\n    ctrl: false,\n    meta: false,\n    shift: false,\n    option: false,\n    sequence: \"\",\n    number: false,\n    raw: \"\",\n    eventType: \"press\",\n    source: \"raw\",\n  })\n}\n\nfunction normalizeRuntimePlatform(platform: NodeJS.Platform | string | undefined): HostPlatform {\n  if (platform === \"darwin\") {\n    return \"macos\"\n  }\n\n  if (platform === \"win32\") {\n    return \"windows\"\n  }\n\n  if (platform === \"linux\") {\n    return \"linux\"\n  }\n\n  return \"unknown\"\n}\n\nfunction createOpenTuiHostMetadata(renderer: CliRenderer): HostMetadata {\n  const platform = normalizeRuntimePlatform(process.platform)\n  const hasKittyKeyboard = renderer.capabilities?.kitty_keyboard === true\n\n  return {\n    platform,\n    primaryModifier: platform === \"macos\" ? \"super\" : platform === \"unknown\" ? \"unknown\" : \"ctrl\",\n    modifiers: {\n      ctrl: \"supported\",\n      shift: \"supported\",\n      meta: \"supported\",\n      super: hasKittyKeyboard ? \"supported\" : \"unknown\",\n      hyper: hasKittyKeyboard ? \"supported\" : \"unknown\",\n    },\n  }\n}\n\nexport function createOpenTuiKeymapHost(renderer: CliRenderer): KeymapHost<Renderable, KeyEvent> {\n  return {\n    get metadata() {\n      return createOpenTuiHostMetadata(renderer)\n    },\n    rootTarget: renderer.root,\n    get isDestroyed() {\n      return renderer.isDestroyed\n    },\n    getFocusedTarget() {\n      const focused = renderer.currentFocusedRenderable\n      if (!focused || focused.isDestroyed || !focused.focused) {\n        return null\n      }\n\n      return focused\n    },\n    getParentTarget(target) {\n      return target.parent\n    },\n    isTargetDestroyed(target) {\n      return target.isDestroyed\n    },\n    onKeyPress(listener) {\n      renderer.keyInput.prependListener(\"keypress\", listener)\n      return () => {\n        renderer.keyInput.off(\"keypress\", listener)\n      }\n    },\n    onKeyRelease(listener) {\n      renderer.keyInput.prependListener(\"keyrelease\", listener)\n      return () => {\n        renderer.keyInput.off(\"keyrelease\", listener)\n      }\n    },\n    onFocusChange(listener) {\n      renderer.on(CliRenderEvents.FOCUSED_RENDERABLE, listener)\n      return () => {\n        renderer.off(CliRenderEvents.FOCUSED_RENDERABLE, listener)\n      }\n    },\n    onDestroy(listener) {\n      renderer.once(CliRenderEvents.DESTROY, listener)\n      return () => {\n        renderer.off(CliRenderEvents.DESTROY, listener)\n      }\n    },\n    onTargetDestroy(target, listener) {\n      target.once(RenderableEvents.DESTROYED, listener)\n      return () => {\n        target.off(RenderableEvents.DESTROYED, listener)\n      }\n    },\n    onRawInput(listener) {\n      renderer.prependInputHandler(listener)\n      return () => {\n        renderer.removeInputHandler(listener)\n      }\n    },\n    createCommandEvent() {\n      return createSyntheticCommandEvent()\n    },\n  }\n}\n\nexport function createOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent> {\n  if (renderer.isDestroyed) {\n    throw new Error(\"Cannot create a keymap for a destroyed renderer\")\n  }\n\n  return new Keymap(createOpenTuiKeymapHost(renderer))\n}\n\nexport function createDefaultOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent> {\n  if (renderer.isDestroyed) {\n    throw new Error(\"Cannot create a keymap for a destroyed renderer\")\n  }\n\n  const keymap = new Keymap(createOpenTuiKeymapHost(renderer))\n  registerDefaultKeys(keymap)\n  registerEnabledFields(keymap)\n  registerMetadataFields(keymap)\n  return keymap\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7616A56E1652597164756E2164756E21",
+  "names": []
+}

package/src/react/index.d.ts

@@ -1,5 +1,5 @@
 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 ActiveKey, type ActiveKeyOptions, type Layer, type Keymap, type ReactiveMatcher, type KeySequencePart, type TargetMode } from "../index.js";
 import { type DependencyList, type ReactNode } from "react";
 type OpenTuiKeymap = Keymap<Renderable, KeyEvent>;
 export interface KeymapProviderProps {
@@ -10,28 +10,14 @@ export declare function KeymapProvider({ keymap, children }: KeymapProviderProps
 export interface UseBindingsTargetRef<TRenderable extends Renderable = Renderable> {
     current: TRenderable | null;
 }
-type UseBindingsLayerBase = LayerFields<Renderable, KeyEvent>;
-export interface UseGlobalBindingsLayer extends UseBindingsLayerBase {
-    targetRef?: undefined;
+export interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<Layer<Renderable, KeyEvent>, "target" | "targetMode"> {
+    targetRef?: UseBindingsTargetRef<TRenderable>;
+    targetMode?: TargetMode;
 }
-export interface UseFocusBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode: "focus";
-    targetRef: UseBindingsTargetRef<TRenderable>;
-}
-export interface UseFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode?: "focus-within";
-    targetRef: UseBindingsTargetRef<TRenderable>;
-}
-export interface UseInferredFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetRef: UseBindingsTargetRef<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): void;
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseTargetBindingsLayer<TRenderable>, deps?: DependencyList): void;
+export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseBindingsLayer<TRenderable>, deps?: DependencyList): void;
 /**
  * Adapts any `subscribe` + `getSnapshot` store to
  * `ReactiveMatcher`. Pass `predicate` when the snapshot value is not

package/src/react/index.js

@@ -122,3 +122,6 @@ export {
   reactiveMatcherFromStore,
   KeymapProvider
 };
+
+//# debugId=88193D455507349A64756E2164756E21
+//# sourceMappingURL=index.js.map

package/src/react/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/react/index.ts"],
+  "sourcesContent": [
+    "import type { KeyEvent, Renderable } from \"@opentui/core\"\nimport {\n  type ActiveKey,\n  type ActiveKeyOptions,\n  type Layer,\n  type Keymap,\n  type ReactiveMatcher,\n  type KeySequencePart,\n  type TargetMode,\n} from \"../index.js\"\nimport {\n  createElement,\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useReducer,\n  useRef,\n  type DependencyList,\n  type ReactNode,\n} from \"react\"\n\ntype OpenTuiKeymap = Keymap<Renderable, KeyEvent>\n\nconst KeymapContext = createContext<OpenTuiKeymap | null>(null)\n\nexport interface KeymapProviderProps {\n  keymap: OpenTuiKeymap\n  children?: ReactNode\n}\n\nexport function KeymapProvider({ keymap, children }: KeymapProviderProps) {\n  return createElement(KeymapContext.Provider, { value: keymap }, children)\n}\n\nexport interface UseBindingsTargetRef<TRenderable extends Renderable = Renderable> {\n  current: TRenderable | null\n}\n\nexport interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<\n  Layer<Renderable, KeyEvent>,\n  \"target\" | \"targetMode\"\n> {\n  targetRef?: UseBindingsTargetRef<TRenderable>\n  targetMode?: TargetMode\n}\n\nfunction resolveBindingsTarget(targetRef: UseBindingsTargetRef | undefined): Renderable | undefined {\n  return targetRef?.current ?? undefined\n}\n\nexport const useKeymap = (): OpenTuiKeymap => {\n  const keymap = useContext(KeymapContext)\n\n  if (!keymap) {\n    throw new Error(\"Keymap not found. Wrap the tree in <KeymapProvider>.\")\n  }\n\n  return keymap\n}\n\n// Use the batched `state` event for derived reads. Pending-sequence changes\n// already flow through `state`, so subscribing to both would duplicate work.\nfunction useKeymapStateVersion(keymap: OpenTuiKeymap): number {\n  const [version, bumpVersion] = useReducer((value: number) => value + 1, 0)\n\n  useLayoutEffect(() => {\n    const dispose = keymap.on(\"state\", () => {\n      bumpVersion()\n    })\n\n    return () => {\n      dispose()\n    }\n  }, [keymap])\n\n  return version\n}\n\nexport const useActiveKeys = (options?: ActiveKeyOptions): readonly ActiveKey[] => {\n  const keymap = useKeymap()\n  const version = useKeymapStateVersion(keymap)\n\n  return useMemo(() => {\n    void version\n    return keymap.getActiveKeys(options)\n  }, [keymap, options, version])\n}\n\nexport const usePendingSequence = (): readonly KeySequencePart[] => {\n  const keymap = useKeymap()\n  const version = useKeymapStateVersion(keymap)\n\n  return useMemo(() => {\n    void version\n    return keymap.getPendingSequence()\n  }, [keymap, version])\n}\n\nexport function useBindings<TRenderable extends Renderable = Renderable>(\n  createLayer: () => UseBindingsLayer<TRenderable>,\n  deps: DependencyList = [],\n): void {\n  const keymap = useKeymap()\n  const layer = useMemo(createLayer, deps)\n  const layerRef = useRef(layer)\n  const disposeRef = useRef<(() => void) | undefined>(undefined)\n  const registeredLayerRef = useRef<UseBindingsLayer<TRenderable> | undefined>(undefined)\n  const registeredTargetModeRef = useRef<TargetMode | undefined>(undefined)\n  const registeredTargetRef = useRef<Renderable | undefined>(undefined)\n\n  layerRef.current = layer\n\n  const unregister = useCallback(() => {\n    disposeRef.current?.()\n    disposeRef.current = undefined\n    registeredLayerRef.current = undefined\n    registeredTargetModeRef.current = undefined\n    registeredTargetRef.current = undefined\n  }, [])\n\n  useEffect(() => {\n    const currentLayer = layerRef.current\n    const hasExplicitTarget = currentLayer.targetRef !== undefined\n    const explicitTarget = resolveBindingsTarget(currentLayer.targetRef)\n    const nextTargetMode = currentLayer.targetMode ?? (hasExplicitTarget ? \"focus-within\" : undefined)\n    const nextTarget = nextTargetMode ? explicitTarget : undefined\n\n    if (!hasExplicitTarget && nextTargetMode) {\n      throw new Error(\"useBindings local bindings need a targetRef\")\n    }\n\n    if (\n      registeredLayerRef.current === currentLayer &&\n      registeredTargetModeRef.current === nextTargetMode &&\n      registeredTargetRef.current === nextTarget\n    ) {\n      return\n    }\n\n    unregister()\n\n    if (!nextTarget && nextTargetMode) {\n      registeredLayerRef.current = currentLayer\n      registeredTargetModeRef.current = nextTargetMode\n      registeredTargetRef.current = undefined\n      return\n    }\n\n    const { targetRef: _targetRef, targetMode: _targetMode, ...baseLayer } = currentLayer\n    disposeRef.current = keymap.registerLayer(\n      !nextTargetMode\n        ? {\n            ...baseLayer,\n          }\n        : {\n            ...baseLayer,\n            target: nextTarget!,\n            targetMode: nextTargetMode,\n          },\n    )\n    registeredLayerRef.current = currentLayer\n    registeredTargetModeRef.current = nextTargetMode\n    registeredTargetRef.current = nextTarget\n  })\n\n  useEffect(() => {\n    return () => {\n      unregister()\n    }\n  }, [unregister])\n}\n\n/**\n * Adapts any `subscribe` + `getSnapshot` store to\n * `ReactiveMatcher`. Pass `predicate` when the snapshot value is not\n * already boolean.\n */\nexport function reactiveMatcherFromStore<T>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => T,\n  predicate?: (value: T) => boolean,\n): ReactiveMatcher {\n  return {\n    get() {\n      return predicate ? predicate(getSnapshot()) : Boolean(getSnapshot())\n    },\n    subscribe(onChange) {\n      return subscribe(onChange)\n    },\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "88193D455507349A64756E2164756E21",
+  "names": []
+}

package/src/runtime-modules.d.ts

@@ -1,5 +1,6 @@
 import * as keymap from "@opentui/keymap";
 import * as keymapExtras from "@opentui/keymap/extras";
+import * as keymapGraphExtra from "@opentui/keymap/extras/graph";
 import * as keymapAddons from "@opentui/keymap/addons";
 import * as keymapOpenTuiAddons from "@opentui/keymap/addons/opentui";
 import * as keymapHtml from "@opentui/keymap/html";
@@ -9,6 +10,7 @@ import * as keymapSolid from "@opentui/keymap/solid";
 export declare const runtimeModules: {
     "@opentui/keymap": typeof keymap;
     "@opentui/keymap/extras": typeof keymapExtras;
+    "@opentui/keymap/extras/graph": typeof keymapGraphExtra;
     "@opentui/keymap/addons": typeof keymapAddons;
     "@opentui/keymap/addons/opentui": typeof keymapOpenTuiAddons;
     "@opentui/keymap/html": typeof keymapHtml;

package/src/runtime-modules.js

@@ -2,6 +2,7 @@
 // src/runtime-modules.ts
 import * as keymap from "@opentui/keymap";
 import * as keymapExtras from "@opentui/keymap/extras";
+import * as keymapGraphExtra from "@opentui/keymap/extras/graph";
 import * as keymapAddons from "@opentui/keymap/addons";
 import * as keymapOpenTuiAddons from "@opentui/keymap/addons/opentui";
 import * as keymapHtml from "@opentui/keymap/html";
@@ -11,6 +12,7 @@ import * as keymapSolid from "@opentui/keymap/solid";
 var runtimeModules = {
   "@opentui/keymap": keymap,
   "@opentui/keymap/extras": keymapExtras,
+  "@opentui/keymap/extras/graph": keymapGraphExtra,
   "@opentui/keymap/addons": keymapAddons,
   "@opentui/keymap/addons/opentui": keymapOpenTuiAddons,
   "@opentui/keymap/html": keymapHtml,
@@ -21,3 +23,6 @@ var runtimeModules = {
 export {
   runtimeModules
 };
+
+//# debugId=0BF94D448A4CF4C764756E2164756E21
+//# sourceMappingURL=runtime-modules.js.map

package/src/runtime-modules.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/runtime-modules.ts"],
+  "sourcesContent": [
+    "import type { RuntimeModuleEntry } from \"@opentui/core/runtime-plugin\"\nimport * as keymap from \"@opentui/keymap\"\nimport * as keymapExtras from \"@opentui/keymap/extras\"\nimport * as keymapGraphExtra from \"@opentui/keymap/extras/graph\"\nimport * as keymapAddons from \"@opentui/keymap/addons\"\nimport * as keymapOpenTuiAddons from \"@opentui/keymap/addons/opentui\"\nimport * as keymapHtml from \"@opentui/keymap/html\"\nimport * as keymapOpenTui from \"@opentui/keymap/opentui\"\nimport * as keymapReact from \"@opentui/keymap/react\"\nimport * as keymapSolid from \"@opentui/keymap/solid\"\n\nexport const runtimeModules = {\n  \"@opentui/keymap\": keymap,\n  \"@opentui/keymap/extras\": keymapExtras,\n  \"@opentui/keymap/extras/graph\": keymapGraphExtra,\n  \"@opentui/keymap/addons\": keymapAddons,\n  \"@opentui/keymap/addons/opentui\": keymapOpenTuiAddons,\n  \"@opentui/keymap/html\": keymapHtml,\n  \"@opentui/keymap/opentui\": keymapOpenTui,\n  \"@opentui/keymap/react\": keymapReact,\n  \"@opentui/keymap/solid\": keymapSolid,\n} satisfies Record<string, RuntimeModuleEntry>\n"
+  ],
+  "mappings": ";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEO,IAAM,iBAAiB;AAAA,EAC5B,mBAAmB;AAAA,EACnB,0BAA0B;AAAA,EAC1B,gCAAgC;AAAA,EAChC,0BAA0B;AAAA,EAC1B,kCAAkC;AAAA,EAClC,wBAAwB;AAAA,EACxB,2BAA2B;AAAA,EAC3B,yBAAyB;AAAA,EACzB,yBAAyB;AAC3B;",
+  "debugId": "0BF94D448A4CF4C764756E2164756E21",
+  "names": []
+}

package/src/services/activation.d.ts

@@ -1,5 +1,5 @@
-import type { Emitter } from "../lib/emitter.js";
-import type { ActiveBinding, ActiveKey, ActiveKeyOptions, CompiledBinding, Hooks, KeymapEvent, KeymapHost, PendingSequenceCapture, KeySequencePart, PendingSequenceState, RegisteredLayer, SequenceNode } from "../types.js";
+import type { RuntimeEmitter } from "../lib/runtime-utils.js";
+import type { ActiveBinding, ActiveKey, ActiveKeyOptions, BindingState, Hooks, KeymapEvent, KeymapHost, PendingSequenceCapture, KeySequencePart, PendingSequenceState, RegisteredLayer } from "../types.js";
 import type { CommandCatalogService } from "./command-catalog.js";
 import type { ConditionService } from "./conditions.js";
 import type { NotificationService } from "./notify.js";
@@ -7,15 +7,7 @@ import type { ActiveCommandView, State } from "./state.js";
 interface ActivationOptions<TTarget extends object, TEvent extends KeymapEvent> {
     onPendingSequenceChanged?: (previous: PendingSequenceState<TTarget, TEvent> | null, next: PendingSequenceState<TTarget, TEvent> | null) => void;
 }
-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;
-    private readonly options;
-    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>, options?: ActivationOptions<TTarget, TEvent>);
+export interface ActivationService<TTarget extends object, TEvent extends KeymapEvent> {
     getFocusedTarget(): TTarget | null;
     getFocusedTargetIfAvailable(): TTarget | null;
     setPendingSequence(next: PendingSequenceState<TTarget, TEvent> | null): void;
@@ -26,30 +18,12 @@ export declare class ActivationService<TTarget extends object, TEvent extends Ke
     popPendingSequence(): boolean;
     getActiveKeys(options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
     getActiveKeysForCaptures(captures: readonly PendingSequenceCapture<TTarget, TEvent>[], options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
-    nodeHasReachableBindings(node: SequenceNode<TTarget, TEvent>, focused: TTarget | null): boolean;
+    getActiveKeysForFocused(focused: TTarget | null, options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
     getActiveLayers(focused: TTarget | null): RegisteredLayer<TTarget, TEvent>[];
-    refreshActiveLayers(focused?: TTarget | null): void;
-    invalidateActiveLayers(): void;
     isLayerActiveForFocused(layer: RegisteredLayer<TTarget, TEvent>, focused: TTarget | null): boolean;
-    layerCanCacheActiveKeys(layer: RegisteredLayer<TTarget, TEvent>): boolean;
-    activeLayersCanCacheActiveKeys(activeLayers: readonly RegisteredLayer<TTarget, TEvent>[]): boolean;
-    private collectNodesFromNode;
     collectSequencePartsFromPending(pending: PendingSequenceState<TTarget, TEvent>): KeySequencePart[];
-    collectMatchingBindings(bindings: readonly CompiledBinding<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): CompiledBinding<TTarget, TEvent>[];
-    private hasMatchingBindings;
-    private getNodePresentation;
-    private toActiveBinding;
-    collectActiveBindings(bindings: readonly CompiledBinding<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): ActiveBinding<TTarget, TEvent>[];
-    private collectActiveKeysAtRoot;
-    private collectActiveKeysFromPending;
-    private selectActiveKey;
-    private selectPrefixActiveKey;
-    private selectExactActiveKey;
-    private selectActiveBindings;
-    private createActiveKeyState;
-    private updateActiveKeyState;
-    private materializeActiveKey;
-    private invalidateCaches;
-    private notifyPendingSequenceChange;
+    collectMatchingBindings(bindings: readonly BindingState<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): BindingState<TTarget, TEvent>[];
+    collectActiveBindings(bindings: readonly BindingState<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): ActiveBinding<TTarget, TEvent>[];
 }
+export declare function createActivationService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, hooks: RuntimeEmitter<Hooks<TTarget, TEvent>>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, catalog: CommandCatalogService<TTarget, TEvent>, options?: ActivationOptions<TTarget, TEvent>): ActivationService<TTarget, TEvent>;
 export {};

package/src/services/active-key-cache.d.ts

@@ -0,0 +1,29 @@
+import type { ActiveKey, ActiveKeyOptions, KeymapEvent } from "../types.js";
+export interface ActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent> {
+    version: number;
+    notifyVersion: number;
+    focused: TTarget | null | undefined;
+    value: readonly ActiveKey<TTarget, TEvent>[];
+    targets: WeakMap<TTarget, {
+        version: number;
+        value: readonly ActiveKey<TTarget, TEvent>[];
+    }>;
+    nullTarget?: {
+        version: number;
+        value: readonly ActiveKey<TTarget, TEvent>[];
+    };
+}
+export interface ActiveKeysCaches<TTarget extends object, TEvent extends KeymapEvent> {
+    plain: ActiveKeysCache<TTarget, TEvent>;
+    bindings: ActiveKeysCache<TTarget, TEvent>;
+    metadata: ActiveKeysCache<TTarget, TEvent>;
+    bindingsAndMetadata: ActiveKeysCache<TTarget, TEvent>;
+}
+export declare function createActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(): ActiveKeysCache<TTarget, TEvent>;
+export declare function createActiveKeysCaches<TTarget extends object, TEvent extends KeymapEvent>(): ActiveKeysCaches<TTarget, TEvent>;
+export declare function getActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(caches: ActiveKeysCaches<TTarget, TEvent>, options?: ActiveKeyOptions): ActiveKeysCache<TTarget, TEvent>;
+export declare function getFocusedActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(cache: ActiveKeysCache<TTarget, TEvent>, cacheVersion: number, focused: TTarget | null): {
+    version: number;
+    value: readonly ActiveKey<TTarget, TEvent>[];
+} | undefined;
+export declare function setFocusedActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(cache: ActiveKeysCache<TTarget, TEvent>, cacheVersion: number, focused: TTarget | null, value: readonly ActiveKey<TTarget, TEvent>[]): void;

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

@@ -1,69 +1,44 @@
-import type { ActiveBinding, Attributes, CommandEntry, CommandDefinition, CommandBindingsQuery, 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 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>[];
+    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, includeRecord: boolean): {
+    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;
-    getActiveRegisteredResolvedEntries(command: string, focused: TTarget | null, includeRecord: boolean): readonly ResolvedCommandEntry<TTarget, TEvent>[] | undefined;
-    resolveRegisteredResolverFallback(command: string, includeRecord: boolean): {
-        resolved?: ResolvedBindingCommand<TTarget, TEvent>;
-        hadError: boolean;
-    };
-    resolveActiveResolverFallback(command: string, focused: TTarget | null, 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 collectCommandBindings;
-    private collectBindingForCommandEntries;
-    private collectBindingForCommandBindings;
-    private createActiveBinding;
-    private getCommandBindingAttrs;
-    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,5 +1,5 @@
 import type { Keymap } from "../keymap.js";
-import type { CompiledBinding, KeymapEvent, RegisteredLayer, RunCommandOptions, RunCommandResult } from "../types.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";
@@ -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,23 +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, StringifyOptions } 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;
     parseKeySequence(key: KeyLike): KeySequencePart[];
     formatKey(key: KeyLike, options?: StringifyOptions): string;
-    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;
+    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,27 +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, LayerBindingsTransformer, 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;
-    prependLayerBindingsTransformer(transformer: LayerBindingsTransformer<TTarget, TEvent>): () => void;
-    appendLayerBindingsTransformer(transformer: LayerBindingsTransformer<TTarget, TEvent>): () => void;
-    clearLayerBindingsTransformers(): 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>;