@opentui/keymap 0.2.1 → 0.2.3

package/src/index.js

@@ -0,0 +1,4492 @@
+// @bun
+import {
+  KEYMAP_EXTENSION_CONTEXT,
+  activeOptionsForCaptures,
+  advanceSequenceCapture,
+  buildSequenceTree,
+  captureHasContinuations,
+  captureIsExact,
+  capturePriority,
+  cloneKeySequence,
+  cloneKeyStroke,
+  collectRootSequenceCaptures,
+  createKeySequencePart,
+  createTextKeyMatch,
+  getActiveLayersForFocused,
+  getFocusedTargetIfAvailable,
+  isLayerActiveForFocused,
+  normalizeBindingTokenName,
+  resolveKeyMatch,
+  stringifyKeySequence,
+  stringifyKeyStroke
+} from "../chunks/index-frk6sdcd.js";
+
+// src/lib/runtime-utils.ts
+function createRuntimeEmitter(onError) {
+  let listeners = Object.create(null);
+  const off = (name, listener) => {
+    const current = listeners[name];
+    if (!current)
+      return;
+    const next = current.filter((candidate) => candidate !== listener);
+    if (next.length === 0)
+      delete listeners[name];
+    else if (next.length !== current.length)
+      listeners[name] = next;
+  };
+  return {
+    hook(name, listener) {
+      listeners[name] = [...listeners[name] ?? [], listener];
+      return () => off(name, listener);
+    },
+    has(name) {
+      return (listeners[name]?.length ?? 0) > 0;
+    },
+    emit(name, ...args) {
+      const current = listeners[name];
+      if (!current)
+        return;
+      for (const listener of current) {
+        try {
+          if (args.length === 0)
+            listener();
+          else
+            listener(args[0]);
+        } catch (error) {
+          onError(name, error);
+        }
+      }
+    }
+  };
+}
+function createItems() {
+  let items = [];
+  return {
+    get: () => items,
+    set: (next) => {
+      items = next;
+    },
+    remove(value) {
+      items = items.filter((candidate) => candidate !== value);
+    },
+    has: () => items.length > 0,
+    clear: () => {
+      items = [];
+    }
+  };
+}
+function createRuntimeOrderedRegistry() {
+  const items = createItems();
+  return {
+    append(value) {
+      items.set([...items.get(), value]);
+      return () => items.remove(value);
+    },
+    prepend(value) {
+      items.set([value, ...items.get()]);
+      return () => items.remove(value);
+    },
+    values: items.get,
+    has: items.has,
+    clear: items.clear
+  };
+}
+function createRuntimePriorityRegistry() {
+  const items = createItems();
+  let order = 0;
+  return {
+    register(listener, options) {
+      const registered = { ...options, listener, order: order++ };
+      items.set([...items.get(), registered].sort((left, right) => {
+        const priorityDiff = right.priority - left.priority;
+        return priorityDiff || left.order - right.order;
+      }));
+      return () => items.remove(registered);
+    },
+    entries: items.get,
+    has: items.has,
+    clear: items.clear
+  };
+}
+
+// src/services/primitives/bindings.ts
+function isKeyLike(value) {
+  return typeof value === "string" || !!value && typeof value === "object" && !Array.isArray(value);
+}
+function validateBindings(bindings) {
+  if (!Array.isArray(bindings)) {
+    return { ok: false, reason: "Invalid keymap bindings: expected an array of binding objects" };
+  }
+  for (const [index, binding] of bindings.entries()) {
+    if (!binding || typeof binding !== "object" || Array.isArray(binding)) {
+      return { ok: false, reason: `Invalid keymap binding at index ${index}: expected a binding object` };
+    }
+    if (!isKeyLike(binding.key)) {
+      return {
+        ok: false,
+        reason: `Invalid keymap binding at index ${index}: expected "key" to be a string or keystroke object`
+      };
+    }
+  }
+  return { ok: true };
+}
+function snapshotBindings(bindings) {
+  const validation = validateBindings(bindings);
+  if (!validation.ok) {
+    throw new Error(validation.reason);
+  }
+  return bindings.map((binding) => ({
+    ...binding,
+    key: typeof binding.key === "string" ? binding.key : { ...binding.key }
+  }));
+}
+function snapshotParsedBinding(binding) {
+  return {
+    ...binding,
+    sequence: cloneKeySequence(binding.sequence)
+  };
+}
+
+// src/services/layer-diagnostics.ts
+function createLayerDiagnostics(notify, commands) {
+  const analyzers = createRuntimeOrderedRegistry();
+  return {
+    prependLayerAnalyzer(analyzer) {
+      return analyzers.prepend(analyzer);
+    },
+    appendLayerAnalyzer(analyzer) {
+      return analyzers.append(analyzer);
+    },
+    clearLayerAnalyzers() {
+      analyzers.clear();
+    },
+    analyzeLayer(options) {
+      const registeredAnalyzers = analyzers.values();
+      if (registeredAnalyzers.length === 0)
+        return;
+      const bindings = buildLayerBindingAnalyses(options.bindings);
+      const ctx = {
+        target: options.target,
+        order: options.order,
+        sourceBindings: options.sourceBindings,
+        bindings,
+        hasTokenBindings: options.hasTokenBindings,
+        checkCommandResolution(command) {
+          return commands.getCommandResolutionStatus(command, options.commands);
+        },
+        warn(code, warning, message) {
+          notify.emitWarning(code, warning, message);
+        },
+        warnOnce(key, code, warning, message) {
+          notify.warnOnce(key, code, warning, message);
+        },
+        error(code, error, message) {
+          notify.emitError(code, error, message);
+        }
+      };
+      for (const analyzer of registeredAnalyzers) {
+        try {
+          analyzer(ctx);
+        } catch (error) {
+          notify.emitError("layer-analyzer-error", error, "[Keymap] Error in layer analyzer:");
+        }
+      }
+    }
+  };
+}
+function buildLayerBindingAnalyses(bindings) {
+  return bindings.map((binding) => ({
+    sequence: cloneKeySequence(binding.sequence),
+    command: binding.command,
+    attrs: binding.attrs,
+    event: binding.event,
+    preventDefault: binding.preventDefault,
+    fallthrough: binding.fallthrough,
+    parsedBinding: snapshotParsedBinding(binding.parsedBinding),
+    sourceTarget: binding.sourceTarget,
+    sourceLayerOrder: binding.sourceLayerOrder,
+    bindingIndex: binding.bindingIndex,
+    hasCommandAtSequence: bindings.some((candidate) => {
+      return candidate.event === "press" && candidate.command !== undefined && sameSequence(candidate, binding);
+    }),
+    hasContinuations: bindings.some((candidate) => {
+      return candidate.event === "press" && isPrefix(binding, candidate);
+    })
+  }));
+}
+function sameSequence(left, right) {
+  return left.sequence.length === right.sequence.length && left.sequence.every((part, index) => part.match === right.sequence[index]?.match);
+}
+function isPrefix(left, right) {
+  return left.sequence.length < right.sequence.length && left.sequence.every((part, index) => part.match === right.sequence[index]?.match);
+}
+
+// src/services/active-key-cache.ts
+function createActiveKeysCache() {
+  return {
+    version: -1,
+    notifyVersion: -1,
+    focused: undefined,
+    value: [],
+    targets: new WeakMap
+  };
+}
+function createActiveKeysCaches() {
+  return {
+    plain: createActiveKeysCache(),
+    bindings: createActiveKeysCache(),
+    metadata: createActiveKeysCache(),
+    bindingsAndMetadata: createActiveKeysCache()
+  };
+}
+function getActiveKeysCache(caches, options) {
+  if (options === undefined) {
+    return caches.plain;
+  }
+  const includeBindings = options.includeBindings === true;
+  const includeMetadata = options.includeMetadata === true;
+  return includeBindings ? includeMetadata ? caches.bindingsAndMetadata : caches.bindings : includeMetadata ? caches.metadata : caches.plain;
+}
+function getFocusedActiveKeysCache(cache, cacheVersion, focused) {
+  const cached = focused ? cache.targets.get(focused) : cache.nullTarget;
+  return cached?.version === cacheVersion ? cached : undefined;
+}
+function setFocusedActiveKeysCache(cache, cacheVersion, focused, value) {
+  const cached = { version: cacheVersion, value };
+  if (focused) {
+    cache.targets.set(focused, cached);
+  } else {
+    cache.nullTarget = cached;
+  }
+}
+
+// src/services/pending-sequence.ts
+function isSamePendingSequence(current, next) {
+  if (current === next) {
+    return true;
+  }
+  if (!current || !next) {
+    return false;
+  }
+  if (current.captures.length !== next.captures.length) {
+    return false;
+  }
+  for (let index = 0;index < current.captures.length; index += 1) {
+    const left = current.captures[index];
+    const right = next.captures[index];
+    if (!left || !right || left.layer !== right.layer || left.binding !== right.binding || left.index !== right.index || left.parts.length !== right.parts.length) {
+      return false;
+    }
+    for (let partIndex = 0;partIndex < left.parts.length; partIndex += 1) {
+      if (left.parts[partIndex]?.match !== right.parts[partIndex]?.match) {
+        return false;
+      }
+    }
+    const leftPatterns = left.patterns ?? [];
+    const rightPatterns = right.patterns ?? [];
+    if (leftPatterns.length !== rightPatterns.length) {
+      return false;
+    }
+    for (let patternIndex = 0;patternIndex < leftPatterns.length; patternIndex += 1) {
+      const leftPattern = leftPatterns[patternIndex];
+      const rightPattern = rightPatterns[patternIndex];
+      if (!leftPattern || !rightPattern || leftPattern.name !== rightPattern.name) {
+        return false;
+      }
+      if (leftPattern.values.length !== rightPattern.values.length) {
+        return false;
+      }
+      for (let valueIndex = 0;valueIndex < leftPattern.values.length; valueIndex += 1) {
+        if (!Object.is(leftPattern.values[valueIndex], rightPattern.values[valueIndex])) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function popCapture(capture) {
+  const lastPart = capture.parts.at(-1);
+  if (!lastPart || capture.parts.length <= 1) {
+    return;
+  }
+  let index = capture.index - 1;
+  let patterns = capture.patterns;
+  if (lastPart.patternName) {
+    const lastPattern = patterns?.at(-1);
+    if (lastPattern?.name === lastPart.patternName) {
+      if (lastPattern.values.length > 1) {
+        index = capture.index;
+        patterns = [
+          ...(patterns ?? []).slice(0, -1),
+          {
+            ...lastPattern,
+            values: lastPattern.values.slice(0, -1),
+            parts: lastPattern.parts.slice(0, -1)
+          }
+        ];
+      } else {
+        patterns = (patterns ?? []).slice(0, -1);
+      }
+    }
+  }
+  return {
+    layer: capture.layer,
+    binding: capture.binding,
+    index,
+    parts: capture.parts.slice(0, -1),
+    patterns
+  };
+}
+function collectSequencePartsFromPending(pending) {
+  const firstCapture = pending.captures[0];
+  if (!firstCapture || firstCapture.parts.length === 0) {
+    return [];
+  }
+  const parts = [];
+  for (let index = 0;index < firstCapture.parts.length; index += 1) {
+    const firstPart = firstCapture.parts[index];
+    if (!firstPart)
+      continue;
+    let display;
+    let tokenName;
+    let hasDisplayConflict = false;
+    let hasTokenConflict = false;
+    for (const capture of pending.captures) {
+      const part = capture.parts[index];
+      if (!part) {
+        continue;
+      }
+      if (display === undefined) {
+        display = part.display;
+        tokenName = part.tokenName;
+        continue;
+      }
+      if (!hasDisplayConflict && display !== part.display) {
+        hasDisplayConflict = true;
+      }
+      if (!hasTokenConflict && tokenName !== part.tokenName) {
+        hasTokenConflict = true;
+      }
+    }
+    if (display === undefined || hasDisplayConflict) {
+      display = stringifyKeyStroke(firstPart.stroke);
+    }
+    if (hasTokenConflict) {
+      tokenName = undefined;
+    }
+    parts.push(createKeySequencePart(firstPart.stroke, {
+      display,
+      match: firstPart.match,
+      tokenName
+    }));
+  }
+  return parts;
+}
+
+// src/services/activation.ts
+function getLiveHost(host) {
+  if (host.isDestroyed) {
+    throw new Error("Cannot use a keymap after its host was destroyed");
+  }
+  return host;
+}
+function createActivationService(state, host, hooks, notify, conditions, catalog, options = {}) {
+  const activeKeysCaches = createActiveKeysCaches();
+  let pendingSequenceCacheVersion = -1;
+  let pendingSequenceCache = [];
+  const getFocusedTarget = () => {
+    return getLiveHost(host).getFocusedTarget();
+  };
+  const getFocusedTargetIfAvailable2 = () => {
+    return getFocusedTargetIfAvailable(host);
+  };
+  const setPendingSequence = (next) => {
+    const previous = state.pending;
+    if (isSamePendingSequence(previous, next)) {
+      return;
+    }
+    state.pending = next;
+    options.onPendingSequenceChanged?.(previous, next);
+    notifyPendingSequenceChange();
+    notify.queueStateChange();
+  };
+  const ensureValidPendingSequence = () => {
+    const pending = state.pending;
+    if (!pending) {
+      return;
+    }
+    const focused = getFocusedTarget();
+    const activeView = catalog.getActiveCommandView(focused);
+    const captures = pending.captures.filter((capture) => {
+      return state.layers.has(capture.layer) && isActiveLayerForFocused(capture.layer, focused) && conditions.matchesConditions(capture.layer) && bindingMatchesRuntimeState(capture.binding, focused, activeView) && captureHasContinuations(capture, state.patterns);
+    });
+    if (captures.length === 0) {
+      setPendingSequence(null);
+      return;
+    }
+    if (captures.length !== pending.captures.length) {
+      setPendingSequence({ captures });
+    }
+    return state.pending ?? undefined;
+  };
+  const revalidatePendingSequenceIfNeeded = () => {
+    if (host.isDestroyed || !state.pending) {
+      return;
+    }
+    ensureValidPendingSequence();
+  };
+  const hasPendingSequenceState = () => {
+    return !host.isDestroyed && state.pending !== null;
+  };
+  const getPendingSequence = () => {
+    if (pendingSequenceCacheVersion === state.cacheVersion) {
+      return pendingSequenceCache;
+    }
+    const pending = ensureValidPendingSequence();
+    const sequence = pending ? collectSequencePartsFromPending(pending) : [];
+    if (!pending || allRegisteredLayersCanCacheActiveKeys()) {
+      pendingSequenceCacheVersion = state.cacheVersion;
+      pendingSequenceCache = sequence;
+    }
+    return sequence;
+  };
+  const popPendingSequence = () => {
+    const pending = ensureValidPendingSequence();
+    if (!pending) {
+      return false;
+    }
+    const firstCapture = pending.captures[0];
+    if (!firstCapture || firstCapture.parts.length <= 1) {
+      setPendingSequence(null);
+      return true;
+    }
+    const nextCaptures = [];
+    for (const capture of pending.captures) {
+      const nextCapture = popCapture(capture);
+      if (!nextCapture) {
+        continue;
+      }
+      nextCaptures.push(nextCapture);
+    }
+    if (nextCaptures.length === 0) {
+      setPendingSequence(null);
+      return true;
+    }
+    setPendingSequence({ captures: nextCaptures });
+    return true;
+  };
+  const getActiveKeys = (options2) => {
+    const includeBindings = options2?.includeBindings === true;
+    const includeMetadata = options2?.includeMetadata === true;
+    const cache = getActiveKeysCache(activeKeysCaches, options2);
+    if (cache.notifyVersion === state.derivedVersion) {
+      return cache.value;
+    }
+    return collectActiveKeysForCache(cache, includeBindings, includeMetadata);
+  };
+  const collectActiveKeysForCache = (cache, includeBindings, includeMetadata) => {
+    if (host.isDestroyed) {
+      getLiveHost(host);
+    }
+    const focused = getFocusedTarget();
+    const cached = getFocusedActiveKeysCache(cache, state.cacheVersion, focused);
+    if (cached) {
+      cache.notifyVersion = state.derivedVersion;
+      cache.version = state.cacheVersion;
+      cache.focused = focused;
+      cache.value = cached.value;
+      return cached.value;
+    }
+    const activeView = catalog.getActiveCommandView(focused);
+    const pending = ensureValidPendingSequence();
+    const activeLayers = pending ? [] : getActiveLayers(focused);
+    const activeKeys = pending ? collectActiveKeysFromPending(pending.captures, includeBindings, includeMetadata, focused, activeView) : collectActiveKeysAtRoot(activeLayers, includeBindings, includeMetadata, focused, activeView);
+    const canUseCache = pending ? allRegisteredLayersCanCacheActiveKeys() : activeLayersCanCacheActiveKeys(activeLayers);
+    if (canUseCache) {
+      cache.version = state.cacheVersion;
+      cache.notifyVersion = state.derivedVersion;
+      cache.focused = focused;
+      cache.value = activeKeys;
+      setFocusedActiveKeysCache(cache, state.cacheVersion, focused, activeKeys);
+    }
+    return activeKeys;
+  };
+  const getActiveKeysForCaptures = (captures, options2) => {
+    const includeBindings = options2?.includeBindings === true;
+    const includeMetadata = options2?.includeMetadata === true;
+    const focused = getFocusedTarget();
+    const activeView = catalog.getActiveCommandView(focused);
+    return collectActiveKeysFromPending(captures, includeBindings, includeMetadata, focused, activeView);
+  };
+  const getActiveKeysForFocused = (focused, options2) => {
+    const includeBindings = options2?.includeBindings === true;
+    const includeMetadata = options2?.includeMetadata === true;
+    const currentFocused = getFocusedTargetIfAvailable2();
+    const pending = focused === currentFocused ? ensureValidPendingSequence() : undefined;
+    const activeView = catalog.getActiveCommandView(focused);
+    if (pending) {
+      return collectActiveKeysFromPending(pending.captures, includeBindings, includeMetadata, focused, activeView);
+    }
+    return collectActiveKeysAtRoot(getActiveLayers(focused), includeBindings, includeMetadata, focused, activeView);
+  };
+  const getActiveLayers = (focused) => {
+    if (state.activeLayersCacheVersion === state.cacheVersion && state.activeLayersCacheFocused === focused) {
+      return state.activeLayersCache;
+    }
+    state.activeLayersCacheVersion = state.cacheVersion;
+    state.activeLayersCacheFocused = focused;
+    state.activeLayersCache = getActiveLayersForFocused(state.sortedLayers, host, focused);
+    return state.activeLayersCache;
+  };
+  const isActiveLayerForFocused = (layer, focused) => {
+    return isLayerActiveForFocused(host, layer, focused);
+  };
+  const activeLayersCanCacheActiveKeys = (activeLayers) => {
+    return !state.commandResolvers.has() && state.activeKeyCacheBlockers === 0;
+  };
+  const allRegisteredLayersCanCacheActiveKeys = () => {
+    return !state.commandResolvers.has() && state.activeKeyCacheBlockers === 0;
+  };
+  const collectMatchingBindings = (bindings, focused, activeView) => {
+    const matches = [];
+    for (const binding of bindings) {
+      if (conditions.matchesConditions(binding) && catalog.isBindingVisible(binding, focused, activeView)) {
+        matches.push(binding);
+      }
+    }
+    return matches;
+  };
+  const bindingMatchesRuntimeState = (binding, focused, activeView) => {
+    return conditions.matchesConditions(binding) && catalog.isBindingVisible(binding, focused, activeView);
+  };
+  const getPartPresentation = (bindings, partIndex) => {
+    let display;
+    let tokenName;
+    let hasDisplayConflict = false;
+    let hasTokenConflict = false;
+    for (const binding of bindings) {
+      const part = binding.sequence[partIndex];
+      if (!part) {
+        continue;
+      }
+      if (display === undefined) {
+        display = part.display;
+        tokenName = part.tokenName;
+        continue;
+      }
+      if (!hasDisplayConflict && display !== part.display) {
+        hasDisplayConflict = true;
+      }
+      if (!hasTokenConflict && tokenName !== part.tokenName) {
+        hasTokenConflict = true;
+      }
+    }
+    if (display === undefined || hasDisplayConflict) {
+      const stroke = bindings[0]?.sequence[partIndex]?.stroke;
+      display = stroke ? stringifyKeyStroke(stroke) : "";
+    }
+    if (hasTokenConflict) {
+      tokenName = undefined;
+    }
+    return {
+      display,
+      tokenName
+    };
+  };
+  const toActiveBinding = (binding, focused, activeView) => {
+    return {
+      sequence: binding.sequence,
+      command: binding.command,
+      commandAttrs: catalog.getBindingCommandAttrs(binding, focused, activeView),
+      attrs: binding.attrs,
+      event: binding.event,
+      preventDefault: binding.preventDefault,
+      fallthrough: binding.fallthrough
+    };
+  };
+  const collectActiveBindings = (bindings, focused, activeView) => {
+    return bindings.map((binding) => toActiveBinding(binding, focused, activeView));
+  };
+  const collectActiveKeysAtRoot = (activeLayers, includeBindings, includeMetadata, focused, activeView) => {
+    const activeKeys = new Map;
+    const stopped = new Set;
+    for (const layer of activeLayers) {
+      if (layer.root.children.size === 0 && layer.root.patternChildren.length === 0 || !conditions.matchesConditions(layer)) {
+        continue;
+      }
+      collectActiveKeyNodes(layer.root.children.values(), activeKeys, stopped, includeBindings, focused, activeView);
+      collectActiveKeyNodes(layer.root.patternChildren, activeKeys, stopped, includeBindings, focused, activeView);
+    }
+    return materializeActiveKeys(activeKeys, includeBindings, includeMetadata, focused, activeView);
+  };
+  const collectActiveKeyNodes = (nodes, activeKeys, stopped, includeBindings, focused, activeView) => {
+    for (const node of nodes) {
+      const bindingKey = node.match;
+      if (!bindingKey || stopped.has(bindingKey) || !node.stroke) {
+        continue;
+      }
+      const selection = selectActiveKeyNode(node, includeBindings, focused, activeView);
+      if (!selection) {
+        continue;
+      }
+      const existing = activeKeys.get(bindingKey);
+      if (!existing) {
+        activeKeys.set(bindingKey, createActiveKeyState(node.stroke, selection, includeBindings));
+      } else {
+        updateActiveKeyState(existing, selection, includeBindings);
+      }
+      if (selection.stop) {
+        stopped.add(bindingKey);
+      }
+    }
+  };
+  const selectActiveKeyNode = (node, includeBindings, focused, activeView) => {
+    const continues = node.children.size > 0 || node.patternChildren.length > 0;
+    if (!continues) {
+      const selected2 = selectActiveBindings(nodeExactBindingsNeedPrefilter(node) ? collectMatchingBindings(node.bindings, focused, activeView) : node.bindings, focused, activeView);
+      if (!selected2) {
+        return;
+      }
+      const presentation2 = getPartPresentation(selected2.bindings, node.depth - 1);
+      return {
+        display: presentation2.display,
+        tokenName: presentation2.tokenName,
+        continues: false,
+        firstBinding: selected2.bindings[0],
+        commandBinding: selected2.commandBinding,
+        bindings: includeBindings ? [...selected2.bindings] : undefined,
+        stop: selected2.stop
+      };
+    }
+    const reachableBindings = collectMatchingBindings(node.reachableBindings, focused, activeView);
+    if (reachableBindings.length === 0) {
+      return;
+    }
+    const selected = selectActiveBindings(node.bindings, focused, activeView);
+    const presentation = getPartPresentation(reachableBindings, node.depth - 1);
+    return {
+      display: presentation.display,
+      tokenName: presentation.tokenName,
+      continues: true,
+      firstBinding: selected?.bindings[0],
+      commandBinding: selected?.commandBinding,
+      bindings: includeBindings && selected ? [...selected.bindings] : undefined,
+      stop: true
+    };
+  };
+  const nodeExactBindingsNeedPrefilter = (node) => {
+    if (state.commandResolvers.has()) {
+      return true;
+    }
+    for (const binding of node.bindings) {
+      if (binding.matchers.length > 0) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const collectActiveKeysFromPending = (captures, includeBindings, includeMetadata, focused, activeView) => {
+    const activeKeys = new Map;
+    const stopped = new Set;
+    collectActiveKeyOptions(activeOptionsForCaptures(captures, state.patterns), activeKeys, stopped, includeBindings, focused, activeView);
+    return materializeActiveKeys(activeKeys, includeBindings, includeMetadata, focused, activeView);
+  };
+  const collectActiveKeyOptions = (options2, activeKeys, stopped, includeBindings, focused, activeView) => {
+    const seen = new Set;
+    for (const option of options2) {
+      if (seen.has(option.part.match)) {
+        continue;
+      }
+      seen.add(option.part.match);
+      collectActiveKeyOption(option, options2, activeKeys, stopped, includeBindings, focused, activeView);
+    }
+  };
+  const collectActiveKeyOption = (option, siblingOptions, activeKeys, stopped, includeBindings, focused, activeView) => {
+    const bindingKey = option.part.match;
+    if (stopped.has(bindingKey)) {
+      return;
+    }
+    const selection = selectActiveKeyOption(option, siblingOptions, includeBindings, focused, activeView);
+    if (!selection) {
+      return;
+    }
+    const existing = activeKeys.get(bindingKey);
+    if (!existing) {
+      activeKeys.set(bindingKey, createActiveKeyState(option.part.stroke, selection, includeBindings));
+    } else {
+      updateActiveKeyState(existing, selection, includeBindings);
+    }
+    if (selection.stop) {
+      stopped.add(bindingKey);
+    }
+  };
+  const materializeActiveKeys = (activeKeys, includeBindings, includeMetadata, focused, activeView) => {
+    const materialized = [];
+    for (const state2 of activeKeys.values()) {
+      const activeKey = materializeActiveKey(state2, includeBindings, includeMetadata, focused, activeView);
+      if (activeKey) {
+        materialized.push(activeKey);
+      }
+    }
+    return materialized;
+  };
+  const selectActiveKeyOption = (option, siblingOptions, includeBindings, focused, activeView) => {
+    const matchingOptions = siblingOptions.filter((candidate) => candidate.part.match === option.part.match);
+    const exactBindings = matchingOptions.filter((candidate) => candidate.exact).map((candidate) => candidate.binding);
+    const selected = selectActiveBindings(exactBindings, focused, activeView);
+    const continues = matchingOptions.some((candidate) => candidate.continues);
+    if (!continues && !selected) {
+      return;
+    }
+    const presentation = getOptionPresentation(matchingOptions);
+    return {
+      display: presentation.display,
+      tokenName: presentation.tokenName,
+      continues,
+      firstBinding: selected?.bindings[0],
+      commandBinding: selected?.commandBinding,
+      bindings: includeBindings && selected ? [...selected.bindings] : undefined,
+      stop: continues || selected?.stop === true
+    };
+  };
+  const getOptionPresentation = (options2) => {
+    let display;
+    let tokenName;
+    let hasDisplayConflict = false;
+    let hasTokenConflict = false;
+    for (const option of options2) {
+      const part = option.part;
+      if (display === undefined) {
+        display = part.display;
+        tokenName = part.tokenName;
+        continue;
+      }
+      if (!hasDisplayConflict && display !== part.display) {
+        hasDisplayConflict = true;
+      }
+      if (!hasTokenConflict && tokenName !== part.tokenName) {
+        hasTokenConflict = true;
+      }
+    }
+    const firstPart = options2[0]?.part;
+    if (display === undefined || hasDisplayConflict) {
+      display = firstPart ? stringifyKeyStroke(firstPart.stroke) : "";
+    }
+    if (hasTokenConflict) {
+      tokenName = undefined;
+    }
+    return { display, tokenName };
+  };
+  const selectActiveBindings = (bindings, focused, activeView) => {
+    const selected = [];
+    let commandBinding;
+    for (const binding of bindings) {
+      if (!conditions.matchesConditions(binding) || !catalog.isBindingVisible(binding, focused, activeView)) {
+        continue;
+      }
+      selected.push(binding);
+      if (binding.command === undefined) {
+        continue;
+      }
+      commandBinding ??= binding;
+      if (!binding.fallthrough) {
+        return { bindings: selected, commandBinding, stop: true };
+      }
+    }
+    if (selected.length === 0) {
+      return;
+    }
+    return { bindings: selected, commandBinding, stop: false };
+  };
+  const createActiveKeyState = (stroke, selection, includeBindings) => {
+    return {
+      stroke,
+      display: selection.display,
+      tokenName: selection.tokenName,
+      continues: selection.continues,
+      firstBinding: selection.firstBinding,
+      commandBinding: selection.commandBinding,
+      bindings: includeBindings && selection.bindings ? [...selection.bindings] : undefined
+    };
+  };
+  const updateActiveKeyState = (state2, selection, includeBindings) => {
+    if (!state2.firstBinding && selection.firstBinding) {
+      state2.firstBinding = selection.firstBinding;
+    }
+    if (!state2.commandBinding && selection.commandBinding) {
+      state2.commandBinding = selection.commandBinding;
+    }
+    if (selection.continues) {
+      state2.continues = true;
+    }
+    if (!includeBindings || !selection.bindings || selection.bindings.length === 0) {
+      return;
+    }
+    if (!state2.bindings) {
+      state2.bindings = [...selection.bindings];
+      return;
+    }
+    state2.bindings.push(...selection.bindings);
+  };
+  const materializeActiveKey = (state2, includeBindings, includeMetadata, focused, activeView) => {
+    if (!state2.commandBinding && !state2.continues) {
+      return;
+    }
+    const activeKey = {
+      stroke: cloneKeyStroke(state2.stroke),
+      display: state2.display,
+      continues: state2.continues
+    };
+    if (state2.tokenName) {
+      activeKey.tokenName = state2.tokenName;
+    }
+    if (state2.commandBinding) {
+      activeKey.command = state2.commandBinding.command;
+    }
+    if (includeBindings && state2.bindings && state2.bindings.length > 0) {
+      activeKey.bindings = state2.bindings.length === 1 ? [toActiveBinding(state2.bindings[0], focused, activeView)] : collectActiveBindings(state2.bindings, focused, activeView);
+    }
+    if (includeMetadata) {
+      if (state2.firstBinding?.attrs) {
+        activeKey.bindingAttrs = state2.firstBinding.attrs;
+      }
+      const commandAttrs = state2.commandBinding ? catalog.getBindingCommandAttrs(state2.commandBinding, focused, activeView) : undefined;
+      if (commandAttrs) {
+        activeKey.commandAttrs = commandAttrs;
+      }
+    }
+    return activeKey;
+  };
+  const notifyPendingSequenceChange = () => {
+    if (!hooks.has("pendingSequence")) {
+      return;
+    }
+    hooks.emit("pendingSequence", state.pending ? collectSequencePartsFromPending(state.pending) : []);
+  };
+  return {
+    getFocusedTarget,
+    getFocusedTargetIfAvailable: getFocusedTargetIfAvailable2,
+    setPendingSequence,
+    ensureValidPendingSequence,
+    revalidatePendingSequenceIfNeeded,
+    hasPendingSequenceState,
+    getPendingSequence,
+    popPendingSequence,
+    getActiveKeys,
+    getActiveKeysForCaptures,
+    getActiveKeysForFocused,
+    getActiveLayers,
+    isLayerActiveForFocused: isActiveLayerForFocused,
+    collectSequencePartsFromPending,
+    collectMatchingBindings,
+    collectActiveBindings
+  };
+}
+
+// src/schema.ts
+var RESERVED_COMMAND_FIELDS = new Set(["name", "run", "fields", "attrs", "rejectedResult"]);
+var RESERVED_BINDING_FIELDS = new Set(["key", "cmd", "event", "preventDefault", "fallthrough"]);
+var RESERVED_LAYER_FIELDS = new Set(["target", "targetMode", "priority", "bindings", "commands"]);
+
+// src/services/primitives/command-normalization.ts
+function normalizeBindingCommand(command) {
+  if (command === undefined || typeof command === "function") {
+    return command;
+  }
+  const trimmed = command.trim();
+  if (!trimmed) {
+    throw new Error("Invalid keymap command: command cannot be empty");
+  }
+  return trimmed;
+}
+function normalizeCommandName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new Error("Invalid keymap command name: name cannot be empty");
+  }
+  if (/\s/.test(trimmed)) {
+    throw new Error(`Invalid keymap command name "${name}": command names cannot contain whitespace`);
+  }
+  return trimmed;
+}
+
+// src/services/runtime-view.ts
+function pushCommandEntry(target, name, entry) {
+  const existing = target.get(name);
+  if (existing)
+    existing.push(entry);
+  else
+    target.set(name, [entry]);
+}
+function getRegisteredCommandView(state) {
+  const entries = [];
+  const chainsByName = new Map;
+  for (const layer of state.layers) {
+    for (const commandState of layer.commands) {
+      const entry = { layer, commandState };
+      entries.push(entry);
+      pushCommandEntry(chainsByName, commandState.command.name, entry);
+    }
+  }
+  return { entries, chainsByName };
+}
+function collectActiveCommands(layers, conditions, checkLayerConditions) {
+  const entries = [];
+  const reachable = [];
+  const reachableByName = new Map;
+  const chainsByName = new Map;
+  for (const layer of layers) {
+    if (layer.commands.length === 0)
+      continue;
+    if (checkLayerConditions && !conditions.matchesConditions(layer))
+      continue;
+    for (const commandState of layer.commands) {
+      if (!conditions.matchesConditions(commandState))
+        continue;
+      const entry = { layer, commandState };
+      entries.push(entry);
+      pushCommandEntry(chainsByName, commandState.command.name, entry);
+      if (!reachableByName.has(commandState.command.name)) {
+        reachableByName.set(commandState.command.name, entry);
+        reachable.push(entry);
+      }
+    }
+  }
+  return { layers, entries, reachable, reachableByName, chainsByName };
+}
+function getActiveCommandView(state, host, conditions, focused) {
+  if (state.activeLayersCacheVersion !== state.cacheVersion || state.activeLayersCacheFocused !== focused) {
+    state.activeLayersCacheVersion = state.cacheVersion;
+    state.activeLayersCacheFocused = focused;
+    state.activeLayersCache = getActiveLayersForFocused(state.sortedLayers, host, focused);
+  }
+  return collectActiveCommands(state.activeLayersCache, conditions, true);
+}
+
+// src/services/primitives/field-invariants.ts
+function mergeRequirement(target, name, value, source) {
+  if (Object.prototype.hasOwnProperty.call(target, name) && !Object.is(target[name], value)) {
+    throw new Error(`Conflicting keymap requirement for "${name}" from ${source}`);
+  }
+  target[name] = value;
+}
+function mergeAttribute(target, name, value, source) {
+  if (Object.prototype.hasOwnProperty.call(target, name) && !Object.is(target[name], value)) {
+    throw new Error(`Conflicting keymap attribute for "${name}" from ${source}`);
+  }
+  target[name] = value;
+}
+function createFieldCompilerContext(options) {
+  const source = `field ${options.fieldName}`;
+  return {
+    require(name, value) {
+      mergeRequirement(options.requirements, name, value, source);
+    },
+    attr(name, value) {
+      if (!options.attrs) {
+        throw new Error(`Keymap ${source} cannot publish attrs`);
+      }
+      mergeAttribute(options.attrs, name, value, source);
+    },
+    activeWhen(matcher) {
+      options.matchers.push(options.conditions.buildRuntimeMatcher(matcher, source));
+    }
+  };
+}
+
+// src/services/values.ts
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function getErrorMessage(error, fallback) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return fallback;
+}
+function isPromiseLike(value) {
+  if (!value) {
+    return false;
+  }
+  if (typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return typeof value.then === "function";
+}
+function snapshotDataValue(value, options) {
+  const deep = options?.deep === true;
+  const freeze = options?.freeze === true;
+  const preserveNonPlainObjects = options?.preserveNonPlainObjects === true;
+  if (Array.isArray(value)) {
+    const cloned = deep ? value.map((entry) => snapshotDataValue(entry, options)) : [...value];
+    return freeze ? Object.freeze(cloned) : cloned;
+  }
+  if (value && typeof value === "object") {
+    if (preserveNonPlainObjects && !isPlainObject(value)) {
+      return value;
+    }
+    const cloned = {};
+    for (const [key, entry] of Object.entries(value)) {
+      cloned[key] = deep ? snapshotDataValue(entry, options) : entry;
+    }
+    return freeze ? Object.freeze(cloned) : cloned;
+  }
+  return value;
+}
+
+// src/services/command-catalog.ts
+var DEFAULT_COMMAND_SEARCH_FIELDS = ["name"];
+var EMPTY_COMMAND_FIELDS = Object.freeze({});
+var commandSearchCache = new WeakMap;
+function createCommandCatalogService(state, host, notify, conditions, options) {
+  let registeredViewVersion = -1;
+  let registeredView;
+  let activeViewVersion = -1;
+  let activeViewFocused;
+  let activeView;
+  let registeredBindingsCacheVersion = -1;
+  let registeredBindingsCacheCommands;
+  let registeredBindingsCache;
+  let registeredBindingsByCommandVersion = -1;
+  let registeredBindingsByCommand;
+  let registeredResolvedCacheVersion = -1;
+  let registeredResolvedCache = new Map;
+  const normalizeLayerCommands = (commands) => {
+    return normalizeCommands({
+      commands,
+      commandFields: state.commandFields,
+      conditions,
+      onError: (code, error, message) => {
+        notify.emitError(code, error, message);
+      }
+    });
+  };
+  const prependCommandResolver = (resolver) => {
+    return mutateCommandResolvers(() => state.commandResolvers.prepend(resolver), resolver);
+  };
+  const appendCommandResolver = (resolver) => {
+    return mutateCommandResolvers(() => state.commandResolvers.append(resolver), resolver);
+  };
+  const clearCommandResolvers = () => {
+    if (!state.commandResolvers.has()) {
+      return;
+    }
+    notify.runWithStateChangeBatch(() => {
+      state.commandResolvers.clear();
+      options.onCommandResolversChanged();
+      notify.queueStateChange();
+    });
+  };
+  const getCommands = (query) => {
+    return getFilteredCommandEntries(query).map((entry) => getCommand(entry.commandState));
+  };
+  const getCommandEntries = (query) => {
+    const context = getCommandQueryContext(query);
+    const filteredEntries = getFilteredCommandEntries(query, context);
+    if (filteredEntries.length === 0) {
+      return [];
+    }
+    const grouped = filteredEntries.map((entry) => ({
+      entry,
+      command: getCommand(entry.commandState),
+      commandAttrs: entry.commandState.attrs,
+      bindings: []
+    }));
+    const indexesByName = new Map;
+    for (const [index, item] of grouped.entries()) {
+      const existing = indexesByName.get(item.command.name);
+      if (existing) {
+        existing.push(index);
+      } else {
+        indexesByName.set(item.command.name, [index]);
+      }
+    }
+    if (indexesByName.size > 0) {
+      collectCommandEntryBindings(grouped, indexesByName, context);
+    }
+    return grouped.map((item) => ({
+      command: item.command,
+      bindings: item.bindings
+    }));
+  };
+  const getCommandBindings = (query) => {
+    if (query.visibility === "registered" && registeredBindingsCacheVersion === state.derivedVersion && registeredBindingsCacheCommands === query.commands && registeredBindingsCache) {
+      return registeredBindingsCache;
+    }
+    const bindingsByCommand = new Map;
+    for (const command of query.commands) {
+      if (!bindingsByCommand.has(command)) {
+        bindingsByCommand.set(command, []);
+      }
+    }
+    if (bindingsByCommand.size === 0) {
+      return bindingsByCommand;
+    }
+    collectCommandBindings(bindingsByCommand, getCommandQueryContext(query));
+    if (query.visibility === "registered") {
+      registeredBindingsCacheVersion = state.derivedVersion;
+      registeredBindingsCacheCommands = query.commands;
+      registeredBindingsCache = bindingsByCommand;
+    }
+    return bindingsByCommand;
+  };
+  const getResolvedCommandChain = (command, focused, execution) => {
+    const view = getActiveCommandView2(focused);
+    if (execution) {
+      const resolved2 = [];
+      const chain = view.chainsByName.get(command);
+      if (chain) {
+        for (const entry of chain) {
+          resolved2.push({
+            target: entry.layer.target,
+            command: entry.commandState.command,
+            attrs: entry.commandState.attrs,
+            payload: execution.payload
+          });
+        }
+      }
+      const fallback2 = resolveCommandWithResolversForMode(command, focused, { mode: "active", execution });
+      if (fallback2.resolved) {
+        resolved2.push(fallback2.resolved);
+      }
+      return { entries: resolved2.length > 0 ? resolved2 : undefined, hadError: fallback2.hadError };
+    }
+    const resolved = [];
+    for (const entry of view.chainsByName.get(command) ?? []) {
+      resolved.push({
+        target: entry.layer.target,
+        command: entry.commandState.command,
+        attrs: entry.commandState.attrs
+      });
+    }
+    const fallback = resolveCommandWithResolversForMode(command, focused, { mode: "active" });
+    if (fallback.resolved) {
+      resolved.push(fallback.resolved);
+    }
+    return { entries: resolved.length > 0 ? resolved : undefined, hadError: fallback.hadError };
+  };
+  const getRegisteredResolvedEntries = (command) => {
+    if (registeredResolvedCacheVersion !== state.derivedVersion) {
+      registeredResolvedCacheVersion = state.derivedVersion;
+      registeredResolvedCache = new Map;
+    }
+    if (registeredResolvedCache.has(command)) {
+      return registeredResolvedCache.get(command) ?? undefined;
+    }
+    const resolved = resolveRegisteredEntries(getRegisteredCommandChain(command));
+    registeredResolvedCache.set(command, resolved ?? null);
+    return resolved;
+  };
+  const getActiveRegisteredResolvedEntries = (command, focused) => {
+    return resolveRegisteredEntries(getActiveCommandView2(focused).chainsByName.get(command));
+  };
+  const resolveRegisteredResolverFallback = (command, execution) => {
+    return resolveCommandWithResolversForMode(command, null, { mode: "registered", execution });
+  };
+  const resolveActiveResolverFallback = (command, focused, execution) => {
+    return resolveCommandWithResolversForMode(command, focused, { mode: "active", execution });
+  };
+  const getTopCommand = (command, focused) => {
+    const top = getTopResolvedCommand(command, focused);
+    return top?.command;
+  };
+  const getCommandByName = (command) => {
+    const top = getCommandEntry(command);
+    return top?.commandState.command;
+  };
+  const getDispatchUnavailableCommandState = (command, focused, includeCommand) => {
+    const view = getCommandView();
+    const chain = view.chainsByName.get(command);
+    if (!chain || chain.length === 0) {
+      return;
+    }
+    let inactiveEntry;
+    let disabledEntry;
+    for (const entry of chain) {
+      if (!isLayerActiveForFocused(host, entry.layer, focused)) {
+        inactiveEntry ??= entry;
+        continue;
+      }
+      if (!conditions.matchesConditions(entry.layer) || !conditions.matchesConditions(entry.commandState)) {
+        disabledEntry ??= entry;
+      }
+    }
+    const unavailableEntry = disabledEntry ?? inactiveEntry;
+    if (!unavailableEntry) {
+      return;
+    }
+    return {
+      reason: disabledEntry ? "disabled" : "inactive",
+      command: includeCommand ? unavailableEntry.commandState.command : undefined
+    };
+  };
+  const getActiveCommandView2 = (focused) => {
+    if (activeViewVersion === state.derivedVersion && activeViewFocused === focused && activeView) {
+      return activeView;
+    }
+    const view = getActiveCommandView(state, host, conditions, focused);
+    if (activeCommandViewCanCache()) {
+      activeViewVersion = state.derivedVersion;
+      activeViewFocused = focused;
+      activeView = view;
+    }
+    return view;
+  };
+  const getCommandView = () => {
+    if (registeredViewVersion === state.derivedVersion && registeredView) {
+      return registeredView;
+    }
+    registeredViewVersion = state.derivedVersion;
+    registeredView = getRegisteredCommandView(state);
+    return registeredView;
+  };
+  const activeCommandViewCanCache = () => {
+    return state.activeCommandViewCacheBlockers === 0;
+  };
+  const isBindingVisible = (binding, focused, activeView2) => {
+    if (binding.command === undefined || binding.run) {
+      return true;
+    }
+    if (typeof binding.command !== "string") {
+      return false;
+    }
+    if (activeView2.reachableByName.has(binding.command)) {
+      return true;
+    }
+    return getFallbackResolvedCommand(binding.command, focused, "active") !== undefined;
+  };
+  const getBindingCommandAttrs = (binding, focused, activeView2) => {
+    if (typeof binding.command !== "string") {
+      return;
+    }
+    const active = activeView2.reachableByName.get(binding.command);
+    if (active) {
+      return active.commandState.attrs;
+    }
+    const fallback = getFallbackResolvedCommand(binding.command, focused, "active");
+    return fallback?.attrs;
+  };
+  const getCommandResolutionStatus = (command, layerCommands) => {
+    if (layerCommands?.some((state2) => state2.command.name === command) || getCommandView().chainsByName.has(command)) {
+      return "resolved";
+    }
+    const lookup = resolveCommandWithResolversForMode(command, getFocusedTargetIfAvailable(host));
+    if (lookup.resolved || lookup.hadError) {
+      return lookup.resolved ? "resolved" : "error";
+    }
+    return "unresolved";
+  };
+  const mutateCommandResolvers = (register, resolver) => {
+    return notify.runWithStateChangeBatch(() => {
+      const off = register();
+      options.onCommandResolversChanged();
+      notify.queueStateChange();
+      return () => {
+        notify.runWithStateChangeBatch(() => {
+          off();
+          if (state.commandResolvers.values().includes(resolver)) {
+            return;
+          }
+          options.onCommandResolversChanged();
+          notify.queueStateChange();
+        });
+      };
+    });
+  };
+  const getTopResolvedCommand = (command, focused) => {
+    const activeView2 = getActiveCommandView2(focused);
+    const active = activeView2.reachableByName.get(command);
+    if (active) {
+      return {
+        target: active.layer.target,
+        command: active.commandState.command,
+        attrs: active.commandState.attrs
+      };
+    }
+    return getFallbackResolvedCommand(command, focused, "active");
+  };
+  const getCommandEntry = (command) => {
+    return getRegisteredCommandChain(command)?.[0];
+  };
+  const getRegisteredCommandChain = (command) => {
+    const entries = [];
+    for (const layer of state.sortedLayers) {
+      for (const commandState of layer.commands) {
+        if (commandState.command.name === command) {
+          entries.push({ layer, commandState });
+        }
+      }
+    }
+    return entries.length > 0 ? entries : undefined;
+  };
+  const resolveRegisteredEntries = (chain) => {
+    if (!chain?.length) {
+      return;
+    }
+    return chain.map((entry) => ({
+      target: entry.layer.target,
+      command: entry.commandState.command,
+      attrs: entry.commandState.attrs
+    }));
+  };
+  const getFallbackResolvedCommand = (command, focused, mode) => {
+    const lookup = resolveCommandWithResolversForMode(command, focused, { mode });
+    return lookup.resolved;
+  };
+  const getRegisteredLayerCommandEntries = () => {
+    return getCommandView().entries;
+  };
+  const getRegisteredBindingsByCommand = () => {
+    if (registeredBindingsByCommandVersion === state.derivedVersion && registeredBindingsByCommand) {
+      return registeredBindingsByCommand;
+    }
+    const bindingsByCommand = new Map;
+    for (const layer of state.layers) {
+      for (const binding of layer.bindings) {
+        if (typeof binding.command !== "string") {
+          continue;
+        }
+        const bindings = bindingsByCommand.get(binding.command);
+        if (bindings) {
+          bindings.push(binding);
+        } else {
+          bindingsByCommand.set(binding.command, [binding]);
+        }
+      }
+    }
+    registeredBindingsByCommandVersion = state.derivedVersion;
+    registeredBindingsByCommand = bindingsByCommand;
+    return bindingsByCommand;
+  };
+  const getCommandQueryContext = (query) => {
+    const visibility = query?.visibility ?? "reachable";
+    const focused = query && Object.prototype.hasOwnProperty.call(query, "focused") ? query.focused ?? null : getFocusedTargetIfAvailable(host);
+    if (visibility === "registered") {
+      return { visibility, focused };
+    }
+    return {
+      visibility,
+      focused,
+      activeView: getActiveCommandView2(focused)
+    };
+  };
+  const getFilteredCommandEntries = (query, context = getCommandQueryContext(query)) => {
+    let entries;
+    if (context.visibility === "registered") {
+      entries = getRegisteredLayerCommandEntries();
+    } else if (context.visibility === "active") {
+      entries = context.activeView?.entries ?? [];
+    } else {
+      entries = context.activeView?.reachable ?? [];
+    }
+    return queryLayerCommandEntries({
+      entries,
+      query,
+      getCommand: (command) => getCommand(command),
+      onFilterError: (error) => {
+        notify.emitError("command-query-filter-error", error, "[Keymap] Error in command query filter:");
+      }
+    });
+  };
+  const collectCommandEntryBindings = (grouped, indexesByName, context) => {
+    visitCommandQueryBindings(context, (binding) => {
+      collectBindingForCommandEntries(grouped, indexesByName, binding);
+    });
+  };
+  const collectCommandBindings = (bindingsByCommand, context) => {
+    if (context.visibility === "registered") {
+      const registeredBindings = getRegisteredBindingsByCommand();
+      for (const [command, bindings] of bindingsByCommand) {
+        const commandAttrs = getCommandView().chainsByName.get(command)?.[0]?.commandState.attrs;
+        for (const binding of registeredBindings.get(command) ?? []) {
+          bindings.push(createActiveBinding(binding, commandAttrs));
+        }
+      }
+      return;
+    }
+    visitCommandQueryBindings(context, (binding) => {
+      collectBindingForCommandBindings(bindingsByCommand, binding, context);
+    });
+  };
+  const visitCommandQueryBindings = (context, visit) => {
+    if (context.visibility === "registered") {
+      for (const layer of state.layers) {
+        for (const binding of layer.bindings)
+          visit(binding);
+      }
+      return;
+    }
+    const activeView2 = context.activeView;
+    if (!activeView2) {
+      return;
+    }
+    for (const layer of activeView2.layers) {
+      if (layer.bindings.length === 0 || !conditions.matchesConditions(layer)) {
+        continue;
+      }
+      for (const binding of layer.bindings) {
+        if (conditions.matchesConditions(binding) && isBindingVisible(binding, context.focused, activeView2)) {
+          visit(binding);
+        }
+      }
+    }
+  };
+  const collectBindingForCommandEntries = (grouped, indexesByName, binding) => {
+    if (typeof binding.command !== "string") {
+      return;
+    }
+    const indexes = indexesByName.get(binding.command);
+    if (!indexes || indexes.length === 0) {
+      return;
+    }
+    for (const index of indexes) {
+      const item = grouped[index];
+      if (!item) {
+        continue;
+      }
+      item.bindings.push(createActiveBinding(binding, item.commandAttrs));
+    }
+  };
+  const collectBindingForCommandBindings = (bindingsByCommand, binding, context) => {
+    if (typeof binding.command !== "string") {
+      return;
+    }
+    const bindings = bindingsByCommand.get(binding.command);
+    if (!bindings) {
+      return;
+    }
+    bindings.push(createActiveBinding(binding, getCommandBindingAttrsForQuery(binding, context)));
+  };
+  const createActiveBinding = (binding, commandAttrs) => {
+    return {
+      sequence: binding.sequence,
+      command: binding.command,
+      commandAttrs,
+      attrs: binding.attrs,
+      event: binding.event,
+      preventDefault: binding.preventDefault,
+      fallthrough: binding.fallthrough
+    };
+  };
+  const getCommandBindingAttrsForQuery = (binding, context) => {
+    if (typeof binding.command !== "string") {
+      return;
+    }
+    if (context.visibility === "registered") {
+      return getCommandView().chainsByName.get(binding.command)?.[0]?.commandState.attrs;
+    }
+    const activeView2 = context.activeView;
+    if (!activeView2) {
+      return;
+    }
+    return getBindingCommandAttrs(binding, context.focused, activeView2);
+  };
+  const resolveCommandWithResolversForMode = (command, focused, options2) => {
+    const mode = options2?.mode ?? "active";
+    const execution = options2?.execution ?? { input: command };
+    const lookup = resolveCommandWithResolvers(command, state.commandResolvers.values(), () => createCommandResolverContext(focused, mode, execution), (error) => {
+      notify.emitError("command-resolver-error", error, `[Keymap] Error in command resolver for "${command}":`);
+    });
+    let resolved = lookup.resolved;
+    if (resolved) {
+      const entry = getCommandEntryForMode(resolved.command.name, focused, mode);
+      if (entry?.commandState.command === resolved.command && resolved.target === undefined) {
+        resolved = { ...resolved, target: entry.layer.target };
+        lookup.resolved = resolved;
+      }
+    }
+    if (resolved && !resolved.attrs) {
+      const attrs = getCommandStateAttrs(resolved.command.name, focused, mode) ?? getResolverCommandAttrs(resolved.command);
+      if (attrs) {
+        lookup.resolved = { ...resolved, attrs };
+      }
+    }
+    return lookup;
+  };
+  const getCommandStateAttrs = (command, focused, mode) => {
+    if (mode === "registered") {
+      return getCommandEntry(command)?.commandState.attrs;
+    }
+    return getActiveCommandView2(focused).reachableByName.get(command)?.commandState.attrs;
+  };
+  const getCommandEntryForMode = (command, focused, mode) => {
+    if (mode === "registered") {
+      return getCommandEntry(command);
+    }
+    return getActiveCommandView2(focused).reachableByName.get(command);
+  };
+  const createCommandResolverContext = (focused, mode, execution) => {
+    let input = execution.input;
+    let payload = execution.payload;
+    return {
+      context: {
+        get input() {
+          return input;
+        },
+        get payload() {
+          return payload;
+        },
+        setInput(nextInput) {
+          input = nextInput;
+        },
+        setPayload(nextPayload) {
+          payload = nextPayload;
+        },
+        getCommand: (name) => {
+          if (mode === "registered") {
+            return getCommandByName(name);
+          }
+          return getTopCommand(name, focused);
+        }
+      },
+      getExecutionFields() {
+        return { input, payload };
+      }
+    };
+  };
+  return {
+    normalizeCommands: normalizeLayerCommands,
+    prependCommandResolver,
+    appendCommandResolver,
+    clearCommandResolvers,
+    getCommands,
+    getCommandEntries,
+    getCommandBindings,
+    getResolvedCommandChain,
+    getRegisteredResolvedEntries,
+    getActiveRegisteredResolvedEntries,
+    resolveRegisteredResolverFallback,
+    resolveActiveResolverFallback,
+    getTopCommand,
+    getDispatchUnavailableCommandState,
+    getActiveCommandView: getActiveCommandView2,
+    isBindingVisible,
+    getBindingCommandAttrs,
+    getCommandResolutionStatus
+  };
+}
+function getCommand(state) {
+  return state.command;
+}
+function normalizeCommands(options) {
+  const normalizedCommands = [];
+  const seen = new Set;
+  for (const command of options.commands) {
+    try {
+      const mergedRequires = {};
+      const matchers = [];
+      const normalizedName = normalizeCommandName(command.name);
+      const fields = getCommandFields(command);
+      const attrs = {};
+      if (seen.has(normalizedName)) {
+        options.onError("duplicate-command", { command: normalizedName }, `Duplicate keymap command "${normalizedName}" in the same layer`);
+        continue;
+      }
+      command.name = normalizedName;
+      for (const [fieldName, value] of Object.entries(fields)) {
+        if (value === undefined) {
+          continue;
+        }
+        const compiler = options.commandFields.get(fieldName);
+        if (!compiler) {
+          continue;
+        }
+        compiler(value, createFieldCompilerContext({
+          fieldName,
+          conditions: options.conditions,
+          requirements: mergedRequires,
+          matchers,
+          attrs
+        }));
+      }
+      const commandState = {
+        command,
+        fields,
+        attrs: Object.keys(attrs).length === 0 ? undefined : attrs,
+        requires: Object.entries(mergedRequires),
+        matchers
+      };
+      seen.add(commandState.command.name);
+      normalizedCommands.push(commandState);
+    } catch (error) {
+      options.onError("register-command-failed", error, getErrorMessage(error, `Failed to register keymap command "${String(command.name)}"`));
+      continue;
+    }
+  }
+  return normalizedCommands;
+}
+function resolveCommandWithResolvers(command, resolvers, createContext, onResolverError) {
+  if (resolvers.length === 0) {
+    return { hadError: false };
+  }
+  let hadError = false;
+  for (const resolver of resolvers) {
+    let resolvedCommand;
+    const attempt = createContext();
+    try {
+      resolvedCommand = resolver(command, attempt.context);
+    } catch (error) {
+      hadError = true;
+      onResolverError(error);
+      continue;
+    }
+    if (resolvedCommand) {
+      return { hadError, resolved: getResolverCommandEntry(resolvedCommand, attempt.getExecutionFields()) };
+    }
+  }
+  return { hadError };
+}
+function getCommandFields(command) {
+  const fields = {};
+  for (const [name, value] of Object.entries(command)) {
+    if (!RESERVED_COMMAND_FIELDS.has(name) && value !== undefined) {
+      fields[name] = value;
+    }
+  }
+  return Object.keys(fields).length === 0 ? EMPTY_COMMAND_FIELDS : fields;
+}
+function getResolverCommandEntry(command, execution) {
+  return {
+    command,
+    input: execution.input,
+    payload: execution.payload
+  };
+}
+function getResolverCommandAttrs(command) {
+  const fields = getCommandFields(command);
+  return fields === EMPTY_COMMAND_FIELDS ? undefined : fields;
+}
+function queryLayerCommandEntries(options) {
+  const namespace = options.query?.namespace;
+  const limit = normalizeQueryLimit(options.query?.limit);
+  if (limit === 0) {
+    return [];
+  }
+  const normalizedSearch = options.query?.search?.trim().toLowerCase() ?? "";
+  let searchKeys = DEFAULT_COMMAND_SEARCH_FIELDS;
+  if (options.query?.searchIn && options.query.searchIn.length > 0) {
+    searchKeys = options.query.searchIn;
+  }
+  const filter = options.query?.filter;
+  let filterEntries;
+  let filterPredicate;
+  let exactNameFilter;
+  if (typeof filter === "function") {
+    filterPredicate = filter;
+  } else if (filter) {
+    const entries = Object.entries(filter);
+    const remainingEntries = [];
+    for (const [key, matcher] of entries) {
+      if (key === "name") {
+        if (typeof matcher === "string") {
+          exactNameFilter = new Set([matcher]);
+          continue;
+        }
+        if (Array.isArray(matcher)) {
+          const names = new Set;
+          for (const value of matcher) {
+            if (typeof value === "string") {
+              names.add(value);
+            }
+          }
+          exactNameFilter = names;
+          continue;
+        }
+      }
+      remainingEntries.push([key, matcher]);
+    }
+    filterEntries = remainingEntries.length > 0 ? remainingEntries : undefined;
+  }
+  const results = [];
+  for (const entry of options.entries) {
+    const commandState = entry.commandState;
+    if (!commandMatchesNamespace(commandState, namespace)) {
+      continue;
+    }
+    if (!commandMatchesSearch(commandState, normalizedSearch, searchKeys)) {
+      continue;
+    }
+    if (exactNameFilter && !exactNameFilter.has(commandState.command.name)) {
+      continue;
+    }
+    if (!commandMatchesFilters(commandState, filterEntries, options)) {
+      continue;
+    }
+    if (filterPredicate) {
+      let matches = false;
+      try {
+        matches = filterPredicate(options.getCommand(commandState));
+      } catch (error) {
+        options.onFilterError(error);
+        continue;
+      }
+      if (!matches) {
+        continue;
+      }
+    }
+    results.push(entry);
+    if (limit !== undefined && results.length >= limit) {
+      break;
+    }
+  }
+  return results;
+}
+function normalizeQueryLimit(value) {
+  if (value === undefined) {
+    return;
+  }
+  const limit = Math.floor(Number(value));
+  if (!Number.isFinite(limit) || limit <= 0) {
+    return 0;
+  }
+  return limit;
+}
+function commandMatchesSearch(commandState, search, searchKeys) {
+  if (!search) {
+    return true;
+  }
+  for (const key of searchKeys) {
+    if (commandKeyMatchesSearch(commandState, key, search)) {
+      return true;
+    }
+  }
+  return false;
+}
+function commandMatchesNamespace(commandState, namespace) {
+  if (namespace === undefined) {
+    return true;
+  }
+  const fields = commandState.fields;
+  if (!Object.prototype.hasOwnProperty.call(fields, "namespace")) {
+    return false;
+  }
+  return valueMatchesFilter(fields.namespace, namespace);
+}
+function commandMatchesFilters(commandState, filters, options) {
+  if (!filters) {
+    return true;
+  }
+  for (const [key, matcher] of filters) {
+    if (!commandKeyMatchesQuery(commandState, key, matcher, options)) {
+      return false;
+    }
+  }
+  return true;
+}
+function commandKeyMatchesSearch(commandState, key, search) {
+  return getCommandSearchText(commandState, key)?.includes(search) === true;
+}
+function getCommandSearchText(commandState, key) {
+  let cache = commandSearchCache.get(commandState);
+  if (!cache) {
+    cache = new Map;
+    commandSearchCache.set(commandState, cache);
+  }
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+  const fields = commandState.fields;
+  const attrs = commandState.attrs;
+  let value;
+  if (key === "name") {
+    value = commandState.command.name;
+  } else if (Object.prototype.hasOwnProperty.call(fields, key)) {
+    value = fields[key];
+  } else if (attrs && Object.prototype.hasOwnProperty.call(attrs, key)) {
+    value = attrs[key];
+  }
+  const text = toSearchText(value);
+  cache.set(key, text);
+  return text;
+}
+function toSearchText(value) {
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const entry of value) {
+      const text = toSearchText(entry);
+      if (text !== undefined) {
+        parts.push(text);
+      }
+    }
+    return parts.length > 0 ? parts.join("\x00") : undefined;
+  }
+  if (typeof value === "string") {
+    return value.toLowerCase();
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value).toLowerCase();
+  }
+  return;
+}
+function runCommandQueryPredicate(matcher, value, command, onFilterError) {
+  try {
+    return matcher(value, command);
+  } catch (error) {
+    onFilterError(error);
+    return false;
+  }
+}
+function commandKeyMatchesQuery(commandState, key, matcher, options) {
+  if (typeof matcher === "function") {
+    return commandKeyMatchesPredicate(commandState, key, matcher, options);
+  }
+  return commandKeyMatchesExact(commandState, key, matcher);
+}
+function commandKeyMatchesPredicate(commandState, key, matcher, options) {
+  const command = commandState.command;
+  const fields = commandState.fields;
+  const attrs = commandState.attrs;
+  let commandView;
+  let foundValue = false;
+  const getCommandView = () => commandView ??= options.getCommand(commandState);
+  if (key === "name") {
+    foundValue = true;
+    if (runCommandQueryPredicate(matcher, command.name, getCommandView(), options.onFilterError)) {
+      return true;
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(fields, key)) {
+    foundValue = true;
+    if (runCommandQueryPredicate(matcher, fields[key], getCommandView(), options.onFilterError)) {
+      return true;
+    }
+  }
+  if (attrs && Object.prototype.hasOwnProperty.call(attrs, key)) {
+    foundValue = true;
+    if (runCommandQueryPredicate(matcher, attrs[key], getCommandView(), options.onFilterError)) {
+      return true;
+    }
+  }
+  return !foundValue && runCommandQueryPredicate(matcher, undefined, getCommandView(), options.onFilterError);
+}
+function commandKeyMatchesExact(commandState, key, matcher) {
+  const command = commandState.command;
+  const fields = commandState.fields;
+  const attrs = commandState.attrs;
+  if (key === "name" && valueMatchesFilter(command.name, matcher)) {
+    return true;
+  }
+  if (Object.prototype.hasOwnProperty.call(fields, key) && valueMatchesFilter(fields[key], matcher)) {
+    return true;
+  }
+  return !!attrs && Object.prototype.hasOwnProperty.call(attrs, key) && valueMatchesFilter(attrs[key], matcher);
+}
+function valueMatchesFilter(value, matcher) {
+  if (Array.isArray(matcher)) {
+    return matcher.some((expected) => valueMatchesExact(value, expected));
+  }
+  return valueMatchesExact(value, matcher);
+}
+function valueMatchesExact(value, expected) {
+  if (Array.isArray(value)) {
+    return value.some((entry) => valueMatchesExact(entry, expected));
+  }
+  return Object.is(value, expected);
+}
+
+// src/services/command-executor.ts
+function createCommandExecutorService(notify, runtime, activation, catalog, options) {
+  const createCommandContext = (event, focused, target, data, input, payload) => {
+    return {
+      keymap: options.keymap,
+      event,
+      focused,
+      target,
+      data,
+      input,
+      payload
+    };
+  };
+  const executeResolvedCommand = (commandName, command, context, includeCommand) => {
+    const commandView = typeof command === "function" ? undefined : command;
+    const run = typeof command === "function" ? command : command.run;
+    const resultCommand = includeCommand ? commandView : undefined;
+    let result;
+    try {
+      result = run(commandView ? { ...context, command: commandView } : context);
+    } catch (error) {
+      notify.emitError("command-execution-error", error, `[Keymap] Error running command "${commandName}":`);
+      return {
+        status: "error",
+        result: resultCommand ? { ok: false, reason: "error", command: resultCommand } : { ok: false, reason: "error" }
+      };
+    }
+    if (isPromiseLike(result)) {
+      result.catch((error) => {
+        notify.emitError("async-command-error", error, `[Keymap] Async error in command "${commandName}":`);
+      });
+      return {
+        status: "handled",
+        result: resultCommand ? { ok: true, command: resultCommand } : { ok: true }
+      };
+    }
+    if (isRunCommandResult(result)) {
+      let commandResult = result;
+      if (!result.ok && result.reason !== "not-found" && includeCommand && commandView && !result.command) {
+        commandResult = { ...result, command: commandView };
+      } else if (result.ok && includeCommand && commandView && !result.command) {
+        commandResult = { ...result, command: commandView };
+      }
+      return {
+        status: result.ok ? "handled" : "rejected",
+        result: commandResult
+      };
+    }
+    if (result === false) {
+      return {
+        status: "rejected",
+        result: resultCommand ? { ok: false, reason: "rejected", command: resultCommand } : { ok: false, reason: "rejected" }
+      };
+    }
+    return {
+      status: "handled",
+      result: resultCommand ? { ok: true, command: resultCommand } : { ok: true }
+    };
+  };
+  const executeCommandChain = (commandName, chain, event, focused, target, data, payload, includeCommand) => {
+    let rejected;
+    for (const entry of chain ?? []) {
+      const executed = executeResolvedCommand(commandName, entry.command, createCommandContext(event, focused, target ?? entry.target ?? null, data, commandName, payload), includeCommand);
+      if (executed.status === "handled" || executed.status === "error") {
+        return [executed.result, rejected];
+      }
+      rejected = executed.result;
+    }
+    return [undefined, rejected];
+  };
+  const executeProgrammaticCommand = (cmd, commandOptions, mode) => {
+    let normalized;
+    try {
+      normalized = normalizeBindingCommand(cmd);
+    } catch {
+      return { ok: false, reason: "invalid-args" };
+    }
+    if (typeof normalized !== "string") {
+      return { ok: false, reason: "not-found" };
+    }
+    const includeCommand = commandOptions?.includeCommand === true;
+    const focused = commandOptions?.focused ?? activation.getFocusedTargetIfAvailable();
+    const event = commandOptions?.event ?? options.createCommandEvent();
+    const data = runtime.getReadonlyData();
+    const payload = commandOptions?.payload;
+    const chain = mode === "registered" ? catalog.getRegisteredResolvedEntries(normalized) : catalog.getActiveRegisteredResolvedEntries(normalized, focused);
+    const [done, rejected] = executeCommandChain(normalized, chain, event, focused, commandOptions?.target, data, payload, includeCommand);
+    if (done) {
+      return done;
+    }
+    let rejectedResult = rejected;
+    const fallback = mode === "registered" ? catalog.resolveRegisteredResolverFallback(normalized, { input: normalized, payload }) : catalog.resolveActiveResolverFallback(normalized, focused, { input: normalized, payload });
+    if (fallback.resolved) {
+      const result = executeResolvedCommand(normalized, fallback.resolved.command, createCommandContext(event, focused, commandOptions?.target ?? fallback.resolved.target ?? null, data, fallback.resolved.input ?? normalized, fallback.resolved.payload), includeCommand);
+      if (result.status === "handled" || result.status === "error") {
+        return result.result;
+      }
+      rejectedResult = result.result;
+    }
+    if (fallback.hadError) {
+      return { ok: false, reason: "error" };
+    }
+    if (mode === "active") {
+      const unavailable = catalog.getDispatchUnavailableCommandState(normalized, focused, includeCommand);
+      if (unavailable) {
+        return unavailable.command ? { ok: false, reason: unavailable.reason, command: unavailable.command } : { ok: false, reason: unavailable.reason };
+      }
+    }
+    return rejectedResult ?? { ok: false, reason: "not-found" };
+  };
+  return {
+    runCommand(cmd, commandOptions) {
+      return executeProgrammaticCommand(cmd, commandOptions, "registered");
+    },
+    dispatchCommand(cmd, commandOptions) {
+      return executeProgrammaticCommand(cmd, commandOptions, "active");
+    },
+    runBinding(bindingLayer, binding, event, focused, payload) {
+      const data = runtime.getReadonlyData();
+      if (binding.run) {
+        const result = executeResolvedCommand(typeof binding.command === "string" ? binding.command : "<function>", binding.run, createCommandContext(event, focused, bindingLayer.target ?? null, data, typeof binding.command === "string" ? binding.command : "<function>", payload), false);
+        if (result.status === "rejected") {
+          return false;
+        }
+        applyBindingEventEffects(binding, event);
+        return true;
+      }
+      if (typeof binding.command !== "string") {
+        return false;
+      }
+      const chain = catalog.getResolvedCommandChain(binding.command, focused, payload === undefined ? undefined : { input: binding.command, payload }).entries;
+      for (const entry of chain ?? []) {
+        const result = executeResolvedCommand(binding.command, entry.command, createCommandContext(event, focused, entry.target ?? bindingLayer.target ?? null, data, entry.input ?? binding.command, entry.payload), false);
+        if (result.status === "rejected") {
+          continue;
+        }
+        applyBindingEventEffects(binding, event);
+        return true;
+      }
+      return false;
+    }
+  };
+}
+function isRunCommandResult(value) {
+  return typeof value === "object" && value !== null && "ok" in value;
+}
+function applyBindingEventEffects(binding, event) {
+  if (!binding.preventDefault) {
+    return;
+  }
+  event.preventDefault();
+  event.stopPropagation();
+}
+
+// src/services/compiler.ts
+var EMPTY_COMPILE_FIELDS = Object.freeze({});
+var EMPTY_REQUIRES = [];
+var EMPTY_MATCHERS = [];
+function snapshotAttributes(attrs) {
+  if (Object.keys(attrs).length === 0) {
+    return;
+  }
+  return snapshotDataValue(attrs, { freeze: true });
+}
+function createCompilerService(state, notify, conditions, options) {
+  const parseTokenKey = (key) => {
+    return parseSingleKeyPartWithParsers(key, state.bindingParsers.values(), {
+      tokens: state.tokens,
+      patterns: state.patterns,
+      layer: EMPTY_COMPILE_FIELDS,
+      parseObjectKey: (value, options2) => parseObjectKeyPart(value, options2)
+    });
+  };
+  const parseKeySequence = (key) => {
+    if (typeof key !== "string") {
+      return [parseObjectKeyPart(key)];
+    }
+    const parsed = parseBindingSequenceWithParsers(key, state.bindingParsers.values(), {
+      tokens: state.tokens,
+      patterns: state.patterns,
+      layer: EMPTY_COMPILE_FIELDS,
+      parseObjectKey: (value, options2) => parseObjectKeyPart(value, options2)
+    });
+    for (const tokenName of parsed.unknownTokens) {
+      options.warnUnknownToken(tokenName, key);
+    }
+    return parsed.parts;
+  };
+  const formatKey = (key, options2) => {
+    return stringifyKeySequence(parseKeySequence(key), options2);
+  };
+  const compileBindings = (bindings, tokens, sourceTarget, sourceLayerOrder, compileFields) => {
+    const bindingStates = [];
+    let hasTokenBindings = false;
+    const bindingExpanders = state.bindingExpanders.values();
+    const bindingParsers = state.bindingParsers.values();
+    const bindingFieldCompilers = state.bindingFields;
+    const allowExactPrefixAmbiguity = state.disambiguationResolvers.has();
+    const warnUnknownField = options.warnUnknownField;
+    const warnUnknownToken = options.warnUnknownToken;
+    for (const [bindingIndex, binding] of bindings.entries()) {
+      let expandedBindingKeys;
+      try {
+        expandedBindingKeys = expandBindingKeyWithExpanders(binding.key, bindingExpanders, {
+          layer: compileFields
+        });
+      } catch (error) {
+        notify.emitError("binding-expand-error", error, getErrorMessage(error, "Failed to expand keymap binding"));
+        continue;
+      }
+      for (const expandedBindingKey of expandedBindingKeys) {
+        const expandedKey = expandedBindingKey.key;
+        let parsed;
+        try {
+          parsed = typeof expandedKey === "string" ? parseBindingSequenceWithParsers(expandedKey, bindingParsers, {
+            tokens,
+            patterns: state.patterns,
+            layer: compileFields,
+            parseObjectKey: (value, options2) => parseObjectKeyPart(value, options2)
+          }) : {
+            parts: [parseObjectKeyPart(expandedKey)],
+            usedTokens: [],
+            unknownTokens: [],
+            hasTokenBindings: false
+          };
+          parsed = applyExpansionDisplays(parsed, expandedBindingKey);
+        } catch (error) {
+          notify.emitError("binding-parse-error", error, getErrorMessage(error, "Failed to parse keymap binding"));
+          continue;
+        }
+        const sequence = parsed.parts;
+        hasTokenBindings ||= parsed.hasTokenBindings;
+        for (const tokenName of parsed.unknownTokens) {
+          warnUnknownToken(tokenName, typeof expandedKey === "string" ? expandedKey : String(expandedKey.name));
+        }
+        for (const compiledInput of applyBindingTransformers(binding, sequence, tokens, bindingParsers, compileFields)) {
+          try {
+            const event = normalizeBindingEvent(compiledInput.event);
+            const compiledSequence = compiledInput.sequence;
+            const mergedRequires = {};
+            const mergedAttrs = {};
+            const matchers = [];
+            for (const fieldName in compiledInput) {
+              if (fieldName === "sequence") {
+                continue;
+              }
+              if (RESERVED_BINDING_FIELDS.has(fieldName)) {
+                continue;
+              }
+              const value = compiledInput[fieldName];
+              if (value === undefined) {
+                continue;
+              }
+              const compiler = bindingFieldCompilers.get(fieldName);
+              if (!compiler) {
+                warnUnknownField("binding", fieldName);
+                continue;
+              }
+              compiler(value, createFieldCompilerContext({
+                fieldName,
+                conditions,
+                requirements: mergedRequires,
+                matchers,
+                attrs: mergedAttrs
+              }));
+            }
+            const attrs = Object.keys(mergedAttrs).length > 0 ? snapshotAttributes(mergedAttrs) : undefined;
+            const command = normalizeBindingCommand(compiledInput.cmd);
+            const compiledBinding = {
+              binding,
+              sequence: compiledSequence,
+              command,
+              event,
+              parsedBinding: snapshotParsedBinding(compiledInput),
+              sourceTarget,
+              sourceLayerOrder,
+              bindingIndex,
+              requires: Object.keys(mergedRequires).length > 0 ? Object.entries(mergedRequires) : EMPTY_REQUIRES,
+              matchers: matchers.length > 0 ? matchers : EMPTY_MATCHERS,
+              preventDefault: compiledInput.preventDefault !== false,
+              fallthrough: compiledInput.fallthrough ?? false
+            };
+            if (attrs) {
+              compiledBinding.attrs = attrs;
+            }
+            if (typeof command === "function") {
+              compiledBinding.run = command;
+            }
+            if (compiledSequence.length === 0) {
+              continue;
+            }
+            if (event === "release" && compiledSequence.length > 1) {
+              throw new Error("Keymap release bindings only support a single key stroke");
+            }
+            const terminalPattern = compiledSequence.at(-1);
+            if (terminalPattern?.patternName) {
+              const pattern = state.patterns.get(terminalPattern.patternName);
+              if (pattern && pattern.max !== pattern.min) {
+                throw new Error("Keymap unbounded sequence patterns must be followed by a concrete continuation");
+              }
+            }
+            if (event === "press" && !allowExactPrefixAmbiguity) {
+              validateExactPrefixAmbiguity(bindingStates, compiledBinding);
+            }
+            bindingStates.push(compiledBinding);
+          } catch (error) {
+            notify.emitError("binding-compile-error", error, getErrorMessage(error, "Failed to compile keymap binding"));
+          }
+        }
+      }
+    }
+    return {
+      bindings: bindingStates,
+      hasTokenBindings
+    };
+  };
+  const parseObjectKeyPart = (key, options2) => {
+    return createKeySequencePart(key, options2);
+  };
+  const normalizeBindingEvent = (event) => {
+    if (event === undefined || event === "press") {
+      return "press";
+    }
+    if (event === "release") {
+      return "release";
+    }
+    throw new Error(`Invalid keymap binding event "${String(event)}": expected "press" or "release"`);
+  };
+  const applyBindingTransformers = (binding, sequence, tokens, bindingParsers, compileFields) => {
+    const bindingTransformers = state.bindingTransformers.values();
+    if (bindingTransformers.length === 0) {
+      return [{ ...binding, sequence: cloneKeySequence(sequence) }];
+    }
+    const parsedBinding = {
+      ...binding,
+      sequence: cloneKeySequence(sequence)
+    };
+    const extraBindings = [];
+    let keepOriginal = true;
+    const layer = compileFields ?? EMPTY_COMPILE_FIELDS;
+    for (const transformer of bindingTransformers) {
+      try {
+        transformer(parsedBinding, {
+          layer,
+          parseKey: (key) => {
+            return parseSingleKeyPartWithParsers(key, bindingParsers, {
+              tokens,
+              patterns: state.patterns,
+              layer,
+              parseObjectKey: (value, options2) => parseObjectKeyPart(value, options2)
+            });
+          },
+          add: (nextBinding) => {
+            extraBindings.push(snapshotParsedBinding(nextBinding));
+          },
+          skipOriginal: () => {
+            keepOriginal = false;
+          }
+        });
+      } catch (error) {
+        notify.emitError("binding-transformer-error", error, "[Keymap] Error in binding transformer:");
+      }
+    }
+    if (!keepOriginal) {
+      return extraBindings;
+    }
+    if (extraBindings.length === 0) {
+      return [parsedBinding];
+    }
+    return [parsedBinding, ...extraBindings];
+  };
+  return { parseTokenKey, parseKeySequence, formatKey, compileBindings };
+}
+function sequenceMatchesPrefix(left, right) {
+  if (left.length >= right.length) {
+    return false;
+  }
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index]?.match !== right[index]?.match) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateExactPrefixAmbiguity(bindings, next) {
+  for (const existing of bindings) {
+    if (existing.event !== "press") {
+      continue;
+    }
+    if (existing.command !== undefined && sequenceMatchesPrefix(existing.sequence, next.sequence) || next.command !== undefined && sequenceMatchesPrefix(next.sequence, existing.sequence)) {
+      throw new Error("Keymap bindings cannot use the same sequence as both an exact match and a prefix in the same layer");
+    }
+  }
+}
+function expandBindingKeyWithExpanders(key, expanders, options) {
+  if (typeof key !== "string" || expanders.length === 0) {
+    return [{ key }];
+  }
+  const layer = options?.layer ?? EMPTY_COMPILE_FIELDS;
+  let candidates = [{ key }];
+  for (const expander of expanders) {
+    const nextCandidates = [];
+    for (const candidate of candidates) {
+      const result = expander({
+        input: candidate.key,
+        displays: candidate.displays,
+        layer
+      });
+      if (!result) {
+        nextCandidates.push(candidate);
+        continue;
+      }
+      if (result.length === 0) {
+        throw new Error(`Keymap binding expander must return at least one key sequence for "${candidate.key}"`);
+      }
+      for (const expanded of result) {
+        if (!expanded || typeof expanded !== "object" || Array.isArray(expanded) || typeof expanded.key !== "string") {
+          throw new Error(`Keymap binding expander must return expansion objects with string keys for "${candidate.key}"`);
+        }
+        if (expanded.displays !== undefined) {
+          if (!Array.isArray(expanded.displays)) {
+            throw new Error(`Keymap binding expander displays must be an array of strings for "${candidate.key}"`);
+          }
+          for (const display of expanded.displays) {
+            if (typeof display !== "string") {
+              throw new Error(`Keymap binding expander displays must be an array of strings for "${candidate.key}"`);
+            }
+          }
+        }
+        nextCandidates.push(expanded);
+      }
+    }
+    candidates = nextCandidates;
+  }
+  return candidates;
+}
+function applyExpansionDisplays(parsed, expansion) {
+  if (!expansion.displays) {
+    return parsed;
+  }
+  if (expansion.displays.length !== parsed.parts.length) {
+    throw new Error(`Keymap binding expansion displays length must match parsed sequence length for "${String(expansion.key)}"`);
+  }
+  return {
+    ...parsed,
+    parts: parsed.parts.map((part, index) => ({
+      ...part,
+      display: expansion.displays[index]
+    }))
+  };
+}
+function parseBindingSequenceWithParsers(key, parsers, options) {
+  if (key.length === 0) {
+    throw new Error("Invalid key sequence: sequence cannot be empty");
+  }
+  if (parsers.length === 0) {
+    throw new Error("No keymap binding parsers are registered");
+  }
+  const tokens = options.tokens ?? new Map;
+  const patterns = options.patterns ?? new Map;
+  const layer = options.layer ?? EMPTY_COMPILE_FIELDS;
+  const parseObjectKey = options.parseObjectKey;
+  const parts = [];
+  const usedTokens = new Set;
+  const unknownTokens = new Set;
+  let index = 0;
+  while (index < key.length) {
+    let matched = false;
+    for (const parser of parsers) {
+      const result = parser({
+        input: key,
+        index,
+        layer,
+        tokens,
+        patterns,
+        normalizeTokenName: normalizeBindingTokenName,
+        createMatch: createTextKeyMatch,
+        parseObjectKey
+      });
+      if (!result) {
+        continue;
+      }
+      if (result.nextIndex <= index || result.nextIndex > key.length) {
+        throw new Error(`Keymap binding parser must advance the input for "${key}" at index ${index}`);
+      }
+      parts.push(...result.parts);
+      for (const tokenName of result.usedTokens ?? []) {
+        usedTokens.add(tokenName);
+      }
+      for (const tokenName of result.unknownTokens ?? []) {
+        unknownTokens.add(tokenName);
+      }
+      index = result.nextIndex;
+      matched = true;
+      break;
+    }
+    if (!matched) {
+      throw new Error(`No keymap binding parser handled input at index ${index} in "${key}"`);
+    }
+  }
+  return {
+    parts,
+    usedTokens: [...usedTokens],
+    unknownTokens: [...unknownTokens],
+    hasTokenBindings: usedTokens.size > 0 || unknownTokens.size > 0
+  };
+}
+function parseSingleKeyPartWithParsers(key, parsers, options) {
+  if (typeof key !== "string") {
+    return options.parseObjectKey(key);
+  }
+  const { parts } = parseBindingSequenceWithParsers(key, parsers, options);
+  const [part] = parts;
+  if (!part || parts.length !== 1) {
+    throw new Error(`Invalid key "${String(key)}": expected a single key stroke`);
+  }
+  return part;
+}
+
+// src/services/conditions.ts
+function isReactiveMatcher(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.get === "function" && typeof candidate.subscribe === "function";
+}
+function createConditionService(state, notify) {
+  const hasNoConditions = (target) => {
+    return target.requires.length === 0 && target.matchers.length === 0;
+  };
+  const matchesRuntimeMatcher = (matcher) => {
+    try {
+      return matcher.match();
+    } catch (error) {
+      notify.emitError("runtime-matcher-error", error, `[Keymap] Error evaluating runtime matcher from ${matcher.source}:`);
+      return false;
+    }
+  };
+  const matchesRuntimeMatchers = (target) => {
+    if (target.matchers.length === 0) {
+      return true;
+    }
+    if (target.matchers.length === 1) {
+      const [matcher] = target.matchers;
+      return matcher ? matchesRuntimeMatcher(matcher) : true;
+    }
+    for (const matcher of target.matchers) {
+      if (!matchesRuntimeMatcher(matcher)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const matchRequirements = (requires) => {
+    if (requires.length === 0) {
+      return true;
+    }
+    for (const [name, value] of requires) {
+      if (!Object.is(state.data[name], value)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const matchesConditions = (target) => {
+    return hasNoConditions(target) || matchRequirements(target.requires) && matchesRuntimeMatchers(target);
+  };
+  return {
+    buildRuntimeMatcher(matcher, source) {
+      if (typeof matcher === "function") {
+        return { source, match: matcher };
+      }
+      if (isReactiveMatcher(matcher)) {
+        return {
+          source,
+          match: () => matcher.get(),
+          subscribe: (onChange) => matcher.subscribe(onChange)
+        };
+      }
+      throw new Error(`Keymap ${source} expected a function or a reactive matcher`);
+    },
+    matchesConditions
+  };
+}
+
+// src/types.ts
+var KEY_DISAMBIGUATION_DECISION = Symbol("keymap-disambiguation-decision");
+var KEY_DEFERRED_DISAMBIGUATION_DECISION = Symbol("keymap-deferred-disambiguation-decision");
+
+// src/services/dispatch-decisions.ts
+function createSyncDecision(action, handler) {
+  return {
+    [KEY_DISAMBIGUATION_DECISION]: true,
+    action,
+    handler
+  };
+}
+function createDeferredDecision(action) {
+  return {
+    [KEY_DEFERRED_DISAMBIGUATION_DECISION]: true,
+    action
+  };
+}
+function isSyncDecision(value) {
+  return !!value && typeof value === "object" && value[KEY_DISAMBIGUATION_DECISION] === true;
+}
+function isDeferredDecision(value) {
+  return !!value && typeof value === "object" && value[KEY_DEFERRED_DISAMBIGUATION_DECISION] === true;
+}
+function sleepWithSignal(ms, signal) {
+  if (signal.aborted) {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, Math.max(0, ms));
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", onAbort);
+      resolve(false);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/services/dispatch-patterns.ts
+function matchSequencePattern(patterns, notify, patternName, event) {
+  const pattern = patterns.get(patternName);
+  if (!pattern) {
+    return;
+  }
+  try {
+    return pattern.matcher(event);
+  } catch (error) {
+    notify.emitError("sequence-pattern-match-error", error, `[Keymap] Error matching sequence pattern "${pattern.name}":`);
+    return;
+  }
+}
+function createPatternEventPart(patterns, event, patternName, match) {
+  const pattern = patterns.get(patternName);
+  const payloadKey = pattern?.payloadKey ?? patternName;
+  const part = createKeySequencePart({
+    name: event.name,
+    ctrl: event.ctrl,
+    shift: event.shift,
+    meta: event.meta,
+    super: event.super ?? false,
+    hyper: event.hyper || undefined
+  }, { display: match.display ?? String(match.value ?? event.name) });
+  return { ...part, patternName, payloadKey };
+}
+function createSequencePayload(patterns, notify, capture) {
+  if (!capture?.patterns || capture.patterns.length === 0) {
+    return;
+  }
+  const payload = {};
+  let hasPayload = false;
+  for (const captured of capture.patterns) {
+    const pattern = patterns.get(captured.name);
+    let value;
+    try {
+      value = pattern?.finalize ? pattern.finalize(captured.values) : captured.values.length === 1 ? captured.values[0] : [...captured.values];
+    } catch (error) {
+      notify.emitError("sequence-pattern-finalize-error", error, `[Keymap] Error finalizing sequence pattern "${captured.name}":`);
+      continue;
+    }
+    const existing = payload[captured.payloadKey];
+    if (existing === undefined) {
+      payload[captured.payloadKey] = value;
+      hasPayload = true;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      payload[captured.payloadKey] = [existing, value];
+    }
+  }
+  return hasPayload ? payload : undefined;
+}
+
+// src/services/dispatch.ts
+function createDispatchService(state, notify, runtime, activation, conditions, executor, compiler, catalog, layers, hooks) {
+  const eventMatchResolverContext = {
+    resolveKey: (key) => compiler.parseTokenKey(key).match
+  };
+  let pendingDisambiguation = null;
+  let nextPendingDisambiguationId = 0;
+  function intercept(name, fn, options) {
+    if (name === "key") {
+      const keyOptions = options;
+      return state.keyHooks.register(fn, {
+        priority: keyOptions?.priority ?? 0,
+        release: keyOptions?.release ?? false
+      });
+    }
+    if (name === "key:after") {
+      const keyOptions = options;
+      return state.keyAfterHooks.register(fn, {
+        priority: keyOptions?.priority ?? 0,
+        release: keyOptions?.release ?? false
+      });
+    }
+    const rawOptions = options;
+    return state.rawHooks.register(fn, {
+      priority: rawOptions?.priority ?? 0
+    });
+  }
+  function prependEventMatchResolver(resolver) {
+    return state.eventMatchResolvers.prepend(resolver);
+  }
+  function appendEventMatchResolver(resolver) {
+    return state.eventMatchResolvers.append(resolver);
+  }
+  function clearEventMatchResolvers() {
+    state.eventMatchResolvers.clear();
+  }
+  function prependDisambiguationResolver(resolver) {
+    return mutateDisambiguationResolvers(() => state.disambiguationResolvers.prepend(resolver), resolver);
+  }
+  function appendDisambiguationResolver(resolver) {
+    return mutateDisambiguationResolvers(() => state.disambiguationResolvers.append(resolver), resolver);
+  }
+  function clearDisambiguationResolvers() {
+    if (!state.disambiguationResolvers.has()) {
+      return;
+    }
+    notify.runWithStateChangeBatch(() => {
+      state.disambiguationResolvers.clear();
+      layers.recompileBindings();
+    });
+  }
+  function handlePendingSequenceChange(_previous, _next) {
+    if (!pendingDisambiguation) {
+      return;
+    }
+    cancelPendingDisambiguation();
+  }
+  function handleRawSequence(sequence) {
+    const hooks2 = state.rawHooks.entries();
+    if (hooks2.length === 0) {
+      return false;
+    }
+    let stopped = false;
+    const context = {
+      sequence,
+      stop() {
+        stopped = true;
+      }
+    };
+    for (const hook of hooks2) {
+      try {
+        hook.listener(context);
+      } catch (error) {
+        notify.emitError("raw-intercept-error", error, "[Keymap] Error in raw intercept listener:");
+      }
+      if (stopped) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function createDispatchBinding(binding, focused) {
+    return {
+      sequence: cloneKeySequence(binding.sequence),
+      command: binding.command,
+      commandAttrs: catalog.getBindingCommandAttrs(binding, focused, catalog.getActiveCommandView(focused)),
+      attrs: binding.attrs,
+      event: binding.event,
+      preventDefault: binding.preventDefault,
+      fallthrough: binding.fallthrough,
+      sourceLayerOrder: binding.sourceLayerOrder,
+      bindingIndex: binding.bindingIndex
+    };
+  }
+  function emitDispatchEvent(event) {
+    if (!hooks.has("dispatch")) {
+      return;
+    }
+    hooks.emit("dispatch", event);
+  }
+  function emitBindingDispatch(phase, layer, binding, focused) {
+    if (!hooks.has("dispatch")) {
+      return;
+    }
+    emitDispatchEvent({
+      phase,
+      event: binding.event,
+      focused,
+      layer: {
+        order: layer.order,
+        priority: layer.priority,
+        target: layer.target,
+        targetMode: layer.targetMode
+      },
+      binding: createDispatchBinding(binding, focused),
+      sequence: cloneKeySequence(binding.sequence),
+      command: binding.command
+    });
+  }
+  function emitSequenceDispatch(phase, captures, focused) {
+    if (!hooks.has("dispatch")) {
+      return;
+    }
+    const first = captures[0];
+    const sequence = captures.length > 0 ? activation.collectSequencePartsFromPending({ captures }) : [];
+    emitDispatchEvent({
+      phase,
+      event: "press",
+      focused,
+      layer: first ? {
+        order: first.layer.order,
+        priority: first.layer.priority,
+        target: first.layer.target,
+        targetMode: first.layer.targetMode
+      } : undefined,
+      sequence
+    });
+  }
+  function getKeyAfterHooks(release) {
+    const hooks2 = state.keyAfterHooks.entries();
+    for (const hook of hooks2) {
+      if (hook.release === release) {
+        return hooks2;
+      }
+    }
+    return;
+  }
+  function getOutcomeSequence(outcome) {
+    if (outcome.sequence) {
+      return cloneKeySequence(outcome.sequence);
+    }
+    if (outcome.captures) {
+      return activation.collectSequencePartsFromPending({ captures: outcome.captures });
+    }
+    return [];
+  }
+  function createSequenceOutcome(reason, captures) {
+    return {
+      handled: reason !== "sequence-miss",
+      reason,
+      captures
+    };
+  }
+  function createBindingOutcome(binding, handled) {
+    return {
+      handled,
+      reason: handled ? "binding-handled" : "binding-rejected",
+      sequence: binding.sequence
+    };
+  }
+  function preferDispatchOutcome(current, next) {
+    if (next.handled || current.reason === "no-match") {
+      return next;
+    }
+    return current;
+  }
+  function emitKeyAfter(hooks2, event, release, focused, outcome) {
+    const context = {
+      event,
+      eventType: release ? "release" : "press",
+      focused,
+      handled: outcome.handled,
+      reason: outcome.reason,
+      sequence: getOutcomeSequence(outcome),
+      pendingSequence: activation.getPendingSequence(),
+      setData: (name, value) => {
+        runtime.setData(name, value);
+      },
+      getData: (name) => {
+        return runtime.getData(name);
+      },
+      consume: (options) => {
+        const shouldPreventDefault = options?.preventDefault ?? true;
+        const shouldStopPropagation = options?.stopPropagation ?? true;
+        if (shouldPreventDefault) {
+          event.preventDefault();
+        }
+        if (shouldStopPropagation) {
+          event.stopPropagation();
+        }
+      }
+    };
+    for (const hook of hooks2) {
+      if (hook.release !== release) {
+        continue;
+      }
+      try {
+        hook.listener(context);
+      } catch (error) {
+        notify.emitError("key-after-intercept-error", error, "[Keymap] Error in key:after intercept listener:");
+      }
+    }
+  }
+  function noMatchOutcome() {
+    return { handled: false, reason: "no-match" };
+  }
+  function consumeSequenceEvent(event) {
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  function holdSequence(phase, captures, focused, event) {
+    activation.setPendingSequence({ captures });
+    const outcome = createSequenceOutcome("sequence-pending", captures);
+    emitSequenceDispatch(phase, captures, focused);
+    consumeSequenceEvent(event);
+    return outcome;
+  }
+  function clearSequence(reason, captures, focused, event) {
+    const outcome = createSequenceOutcome(reason, captures);
+    emitSequenceDispatch("sequence-clear", captures, focused);
+    activation.setPendingSequence(null);
+    consumeSequenceEvent(event);
+    return outcome;
+  }
+  function handleKeyEvent(event, release) {
+    if (!release) {
+      cancelPendingDisambiguation();
+    }
+    const afterHooks = getKeyAfterHooks(release);
+    const afterFocused = afterHooks ? activation.getFocusedTarget() : null;
+    const hooks2 = state.keyHooks.entries();
+    const context = {
+      event,
+      setData: (name, value) => {
+        runtime.setData(name, value);
+      },
+      getData: (name) => {
+        return runtime.getData(name);
+      },
+      consume: (options) => {
+        const shouldPreventDefault = options?.preventDefault ?? true;
+        const shouldStopPropagation = options?.stopPropagation ?? true;
+        if (shouldPreventDefault) {
+          event.preventDefault();
+        }
+        if (shouldStopPropagation) {
+          event.stopPropagation();
+        }
+      }
+    };
+    for (const hook of hooks2) {
+      if (hook.release !== release) {
+        continue;
+      }
+      try {
+        hook.listener(context);
+      } catch (error) {
+        notify.emitError("key-intercept-error", error, "[Keymap] Error in key intercept listener:");
+      }
+      if (event.propagationStopped) {
+        if (afterHooks) {
+          emitKeyAfter(afterHooks, event, release, afterFocused, {
+            handled: true,
+            reason: "intercept-consumed",
+            sequence: []
+          });
+        }
+        return;
+      }
+    }
+    if (release) {
+      const outcome2 = dispatchReleaseLayers(event);
+      if (afterHooks) {
+        emitKeyAfter(afterHooks, event, release, afterFocused, outcome2);
+      }
+      return;
+    }
+    const outcome = dispatchLayers(event);
+    if (afterHooks) {
+      emitKeyAfter(afterHooks, event, release, afterFocused, outcome);
+    }
+  }
+  function mutateDisambiguationResolvers(register, resolver) {
+    return notify.runWithStateChangeBatch(() => {
+      const hadResolvers = state.disambiguationResolvers.has();
+      const off = register();
+      if (!hadResolvers && state.disambiguationResolvers.has()) {
+        layers.recompileBindings();
+      }
+      return () => {
+        notify.runWithStateChangeBatch(() => {
+          const hadBeforeRemoval = state.disambiguationResolvers.has();
+          off();
+          if (state.disambiguationResolvers.values().includes(resolver)) {
+            return;
+          }
+          if (hadBeforeRemoval && !state.disambiguationResolvers.has()) {
+            layers.recompileBindings();
+          }
+        });
+      };
+    });
+  }
+  function dispatchReleaseLayers(event) {
+    const focused = activation.getFocusedTarget();
+    const activeLayers = activation.getActiveLayers(focused);
+    const matchKeys = resolveEventMatchKeys(event);
+    let outcome = noMatchOutcome();
+    layerLoop:
+      for (const layer of activeLayers) {
+        if (layer.bindings.length === 0) {
+          continue;
+        }
+        if (!conditions.matchesConditions(layer)) {
+          continue;
+        }
+        for (const strokeKey of matchKeys) {
+          const result = runReleaseBindings(layer, strokeKey, event, focused);
+          outcome = preferDispatchOutcome(outcome, result.outcome);
+          if (!result.handled) {
+            continue;
+          }
+          if (result.stop) {
+            return outcome;
+          }
+          continue layerLoop;
+        }
+      }
+    return outcome;
+  }
+  function dispatchLayers(event) {
+    const focused = activation.getFocusedTarget();
+    const pending = activation.ensureValidPendingSequence();
+    const matchKeys = resolveEventMatchKeys(event);
+    if (pending) {
+      return dispatchPendingSequence(pending, matchKeys, event, focused);
+    }
+    const activeLayers = activation.getActiveLayers(focused);
+    return dispatchFromRoot(activeLayers, matchKeys, event, focused);
+  }
+  function dispatchPendingSequence(pending, matchKeys, event, focused) {
+    const activeView = catalog.getActiveCommandView(focused);
+    const advancedCaptures = [];
+    for (const capture of pending.captures) {
+      const advanced = advanceSequenceCapture(capture, matchKeys, event, state.patterns, matchPattern, createPatternEventPart2);
+      if (!advanced) {
+        continue;
+      }
+      advancedCaptures.push(advanced);
+    }
+    const bestPriority = advancedCaptures.reduce((best, capture) => Math.min(best, capturePriority(capture, matchKeys)), Number.POSITIVE_INFINITY);
+    const prioritizedCaptures = advancedCaptures.filter((capture) => capturePriority(capture, matchKeys) === bestPriority);
+    if (prioritizedCaptures.length === 0 || !prioritizedCaptures.some((capture) => captureIsReachable(capture, focused, activeView))) {
+      const outcome = createSequenceOutcome("sequence-miss", pending.captures);
+      emitSequenceDispatch("sequence-clear", pending.captures, focused);
+      activation.setPendingSequence(null);
+      return outcome;
+    }
+    return dispatchPendingCapturesFromIndex(prioritizedCaptures, 0, false, event, focused);
+  }
+  function dispatchPendingCapturesFromIndex(advancedCaptures, startIndex, handledExact, event, focused) {
+    let hasHandledExact = handledExact;
+    let outcome = noMatchOutcome();
+    const processedExact = new Set;
+    for (let index = startIndex;index < advancedCaptures.length; index += 1) {
+      const capture = advancedCaptures[index];
+      if (!capture || processedExact.has(capture)) {
+        continue;
+      }
+      const continuationCapturesForPrefix = collectContinuationCapturesForPrefix(advancedCaptures, index, capture);
+      if (continuationCapturesForPrefix.length > 0) {
+        if (hasHandledExact) {
+          continue;
+        }
+        const exactCaptures2 = collectExactCapturesForPrefix(advancedCaptures, capture);
+        const resolvedOutcome = tryResolvePendingAmbiguity(advancedCaptures, index, continuationCapturesForPrefix, exactCaptures2, event, focused, hasHandledExact);
+        if (resolvedOutcome) {
+          return resolvedOutcome;
+        }
+        return holdSequence("sequence-advance", continuationCapturesForPrefix, focused, event);
+      }
+      if (!captureIsExact(capture, state.patterns)) {
+        continue;
+      }
+      const exactCaptures = collectExactCapturesForPrefix(advancedCaptures, capture);
+      for (const exact of exactCaptures)
+        processedExact.add(exact);
+      const result = runCaptureBindings(capture.layer, exactCaptures, event, focused);
+      outcome = preferDispatchOutcome(outcome, result.outcome);
+      if (!result.handled) {
+        continue;
+      }
+      hasHandledExact = true;
+      if (result.stop) {
+        emitSequenceDispatch("sequence-clear", advancedCaptures, focused);
+        activation.setPendingSequence(null);
+        return outcome;
+      }
+    }
+    emitSequenceDispatch("sequence-clear", advancedCaptures, focused);
+    activation.setPendingSequence(null);
+    return outcome;
+  }
+  function dispatchFromRoot(activeLayers, matchKeys, event, focused) {
+    return dispatchFromRootAtIndex(activeLayers, 0, matchKeys, event, focused);
+  }
+  function dispatchFromRootAtIndex(activeLayers, startIndex, matchKeys, event, focused) {
+    const activeView = catalog.getActiveCommandView(focused);
+    let outcome = noMatchOutcome();
+    for (let index = startIndex;index < activeLayers.length; index += 1) {
+      const layer = activeLayers[index];
+      if (!layer) {
+        continue;
+      }
+      if (!conditions.matchesConditions(layer)) {
+        continue;
+      }
+      const captures = collectRootCaptures(layer, matchKeys, event, focused, activeView);
+      if (captures.length === 0) {
+        continue;
+      }
+      const layerContinuationCaptures = captures.filter((capture) => captureHasContinuations(capture, state.patterns, false));
+      if (layerContinuationCaptures.length > 0) {
+        const exactCaptures2 = captures.filter((capture) => captureIsExact(capture, state.patterns));
+        const continuationCaptures = collectPendingCapturesFromRoot(activeLayers, index, matchKeys, event, focused);
+        const resolvedOutcome = tryResolveRootAmbiguity(activeLayers, index, matchKeys, continuationCaptures, exactCaptures2, event, focused);
+        if (resolvedOutcome) {
+          return resolvedOutcome;
+        }
+        return holdSequence("sequence-start", continuationCaptures, focused, event);
+      }
+      const exactCaptures = captures.filter((capture) => captureIsExact(capture, state.patterns));
+      const result = runCaptureBindings(layer, exactCaptures, event, focused);
+      outcome = preferDispatchOutcome(outcome, result.outcome);
+      if (!result.handled) {
+        continue;
+      }
+      if (result.stop) {
+        return outcome;
+      }
+    }
+    return outcome;
+  }
+  function tryResolveRootAmbiguity(activeLayers, layerIndex, matchKeys, continuationCaptures, exactCaptures, event, focused) {
+    const applyExact = () => {
+      activation.setPendingSequence(null);
+      const layer = exactCaptures[0]?.layer;
+      if (!layer)
+        return noMatchOutcome();
+      const result = runCaptureBindings(layer, exactCaptures, event, focused);
+      if (!result.stop) {
+        return preferDispatchOutcome(result.outcome, dispatchFromRootAtIndex(activeLayers, layerIndex + 1, matchKeys, event, focused));
+      }
+      return result.outcome;
+    };
+    return tryResolveAmbiguity({
+      event,
+      focused,
+      continuationCaptures,
+      exactBindingsSource: exactCaptures.map((capture) => capture.binding),
+      sequencePhase: "sequence-start",
+      runExact: applyExact
+    });
+  }
+  function tryResolvePendingAmbiguity(advancedCaptures, captureIndex, continuationCaptures, exactCaptures, event, focused, handledExact) {
+    const applyExact = () => {
+      activation.setPendingSequence(null);
+      const layer = exactCaptures[0]?.layer;
+      if (!layer)
+        return noMatchOutcome();
+      const result = runCaptureBindings(layer, exactCaptures, event, focused);
+      if (result.stop) {
+        return result.outcome;
+      }
+      return preferDispatchOutcome(result.outcome, dispatchPendingCapturesFromIndex(advancedCaptures, captureIndex + 1, handledExact || result.handled, event, focused));
+    };
+    return tryResolveAmbiguity({
+      event,
+      focused,
+      continuationCaptures,
+      exactBindingsSource: exactCaptures.map((capture) => capture.binding),
+      sequencePhase: "sequence-advance",
+      runExact: applyExact
+    });
+  }
+  function tryResolveAmbiguity(options) {
+    const { event, focused, continuationCaptures, exactBindingsSource, sequencePhase, runExact } = options;
+    if (!state.disambiguationResolvers.has() || continuationCaptures.length === 0) {
+      return;
+    }
+    const activeView = catalog.getActiveCommandView(focused);
+    const exactBindings = activation.collectMatchingBindings(exactBindingsSource, focused, activeView);
+    if (!exactBindings.some((binding) => binding.command !== undefined)) {
+      return;
+    }
+    const continueSequence = () => {
+      return holdSequence(sequencePhase, continuationCaptures, focused, event);
+    };
+    const clear = () => {
+      return clearSequence("sequence-cleared", continuationCaptures, focused, event);
+    };
+    let sequence;
+    const getSequence = () => {
+      sequence ??= activation.collectSequencePartsFromPending({ captures: continuationCaptures });
+      return sequence;
+    };
+    const decision = resolveDisambiguation({
+      event,
+      focused,
+      getSequence,
+      exactBindings,
+      continuationCaptures,
+      activeView
+    });
+    if (!decision) {
+      warnUnresolvedAmbiguity(getSequence());
+      return continueSequence();
+    }
+    return applySyncDecision(decision, continuationCaptures, runExact, continueSequence, clear, focused, getSequence);
+  }
+  function applySyncDecision(decision, continuationCaptures, runExact, continueSequence, clear, focused, getSequence) {
+    if (decision.action === "run-exact") {
+      return runExact();
+    }
+    if (decision.action === "continue-sequence") {
+      return continueSequence();
+    }
+    if (decision.action === "clear") {
+      return clear();
+    }
+    const outcome = continueSequence();
+    scheduleDeferredDisambiguation(continuationCaptures, decision.handler, focused, getSequence(), (nextDecision) => {
+      if (!nextDecision) {
+        return;
+      }
+      if (nextDecision.action === "run-exact") {
+        runExact();
+        return;
+      }
+      if (nextDecision.action === "continue-sequence") {
+        continueSequence();
+        return;
+      }
+      clear();
+    });
+    return outcome;
+  }
+  function resolveDisambiguation(options) {
+    let sequence;
+    let exact;
+    let continuations;
+    let strokePart;
+    const ctx = {
+      event: options.event,
+      focused: options.focused,
+      get sequence() {
+        sequence ??= cloneKeySequence(options.getSequence());
+        return sequence;
+      },
+      get stroke() {
+        const stroke = options.getSequence().at(-1);
+        if (!stroke) {
+          throw new Error("Disambiguation context expected a non-empty sequence");
+        }
+        strokePart ??= {
+          ...stroke,
+          stroke: cloneKeyStroke(stroke.stroke)
+        };
+        return strokePart;
+      },
+      get exact() {
+        exact ??= activation.collectActiveBindings(options.exactBindings, options.focused, options.activeView).map((binding) => ({
+          ...binding,
+          sequence: cloneKeySequence(binding.sequence)
+        }));
+        return exact;
+      },
+      get continuations() {
+        continuations ??= activation.getActiveKeysForCaptures(options.continuationCaptures, {
+          includeBindings: true,
+          includeMetadata: true
+        });
+        return continuations;
+      },
+      getData: (name) => {
+        return runtime.getData(name);
+      },
+      setData: (name, value) => {
+        runtime.setData(name, value);
+      },
+      runExact: () => createSyncDecision("run-exact"),
+      continueSequence: () => createSyncDecision("continue-sequence"),
+      clear: () => createSyncDecision("clear"),
+      defer: (run) => createSyncDecision("defer", run)
+    };
+    for (const resolver of state.disambiguationResolvers.values()) {
+      let result;
+      try {
+        result = resolver(ctx);
+      } catch (error) {
+        notify.emitError("disambiguation-resolver-error", error, "[Keymap] Error in disambiguation resolver:");
+        continue;
+      }
+      if (result === undefined) {
+        continue;
+      }
+      if (isPromiseLike(result)) {
+        notify.emitError("invalid-disambiguation-resolver-return", result, "[Keymap] Disambiguation resolvers must return synchronously; use ctx.defer(...) for async handling");
+        continue;
+      }
+      if (!isSyncDecision(result)) {
+        notify.emitError("invalid-disambiguation-decision", result, "[Keymap] Invalid disambiguation decision returned by resolver:");
+        continue;
+      }
+      return result;
+    }
+    return;
+  }
+  function scheduleDeferredDisambiguation(captures, handler, focused, sequence, apply) {
+    cancelPendingDisambiguation();
+    const controller = new AbortController;
+    const pending = {
+      id: nextPendingDisambiguationId++,
+      controller,
+      captures,
+      apply
+    };
+    pendingDisambiguation = pending;
+    queueMicrotask(() => {
+      executeDeferredDisambiguation(pending, handler, focused, sequence);
+    });
+  }
+  function executeDeferredDisambiguation(pending, handler, focused, sequence) {
+    if (!isPendingDisambiguationCurrent(pending)) {
+      return;
+    }
+    const ctx = {
+      signal: pending.controller.signal,
+      sequence: cloneKeySequence(sequence),
+      focused,
+      sleep: (ms) => {
+        return sleepWithSignal(ms, pending.controller.signal);
+      },
+      runExact: () => createDeferredDecision("run-exact"),
+      continueSequence: () => createDeferredDecision("continue-sequence"),
+      clear: () => createDeferredDecision("clear")
+    };
+    let result;
+    try {
+      result = handler(ctx);
+    } catch (error) {
+      if (isPendingDisambiguationCurrent(pending)) {
+        notify.emitError("deferred-disambiguation-error", error, "[Keymap] Error in deferred disambiguation handler:");
+        finishPendingDisambiguation(pending);
+      }
+      return;
+    }
+    if (isPromiseLike(result)) {
+      result.then((resolved) => {
+        applyDeferredDisambiguationResult(pending, resolved);
+      }).catch((error) => {
+        if (!isPendingDisambiguationCurrent(pending)) {
+          return;
+        }
+        notify.emitError("deferred-disambiguation-error", error, "[Keymap] Error in deferred disambiguation handler:");
+        finishPendingDisambiguation(pending);
+      });
+      return;
+    }
+    applyDeferredDisambiguationResult(pending, result);
+  }
+  function applyDeferredDisambiguationResult(pending, result) {
+    if (!isPendingDisambiguationCurrent(pending)) {
+      return;
+    }
+    if (result !== undefined && !isDeferredDecision(result)) {
+      notify.emitError("invalid-deferred-disambiguation-decision", result, "[Keymap] Invalid deferred disambiguation decision returned by handler:");
+      finishPendingDisambiguation(pending);
+      return;
+    }
+    finishPendingDisambiguation(pending);
+    pending.apply(result);
+  }
+  function finishPendingDisambiguation(pending) {
+    if (!isPendingDisambiguationCurrent(pending)) {
+      return;
+    }
+    pendingDisambiguation = null;
+  }
+  function cancelPendingDisambiguation() {
+    const pending = pendingDisambiguation;
+    if (!pending) {
+      return;
+    }
+    pendingDisambiguation = null;
+    pending.controller.abort();
+  }
+  function isPendingDisambiguationCurrent(pending) {
+    return pendingDisambiguation === pending;
+  }
+  function warnUnresolvedAmbiguity(sequence) {
+    const display = stringifyKeySequence(sequence, { preferDisplay: true });
+    notify.warnOnce(`unresolved-disambiguation:${display}`, "unresolved-disambiguation", { sequence: display }, `[Keymap] Ambiguous exact/prefix sequence "${display}" fell back to prefix handling because no disambiguation resolver resolved it`);
+  }
+  function collectPendingCapturesFromRoot(activeLayers, startIndex, matchKeys, event, focused) {
+    const captures = [];
+    const activeView = catalog.getActiveCommandView(focused);
+    for (let index = startIndex;index < activeLayers.length; index += 1) {
+      const layer = activeLayers[index];
+      if (!layer) {
+        continue;
+      }
+      if (!conditions.matchesConditions(layer)) {
+        continue;
+      }
+      for (const capture of collectRootCaptures(layer, matchKeys, event, focused, activeView)) {
+        if (captureHasContinuations(capture, state.patterns, false)) {
+          captures.push(capture);
+        }
+      }
+    }
+    return captures;
+  }
+  function collectContinuationCapturesForPrefix(captures, startIndex, prefix) {
+    return captures.filter((candidate, candidateIndex) => {
+      return candidateIndex >= startIndex && captureHasContinuations(candidate, state.patterns, false) && sameParts(candidate.parts, prefix.parts);
+    });
+  }
+  function collectExactCapturesForPrefix(captures, prefix) {
+    return captures.filter((capture) => {
+      return capture.layer === prefix.layer && captureIsExact(capture, state.patterns) && sameParts(capture.parts, prefix.parts);
+    });
+  }
+  function resolveEventMatchKeys(event) {
+    const resolvers = state.eventMatchResolvers.values();
+    if (resolvers.length === 0) {
+      return [];
+    }
+    if (resolvers.length === 1) {
+      return resolveSingleEventMatchKeys(resolvers[0], event, eventMatchResolverContext, notify);
+    }
+    const keys = [];
+    const seen = new Set;
+    for (const resolver of resolvers) {
+      let resolved;
+      try {
+        resolved = resolver(event, eventMatchResolverContext);
+      } catch (error) {
+        notify.emitError("event-match-resolver-error", error, "[Keymap] Error in event match resolver:");
+        continue;
+      }
+      if (!resolved || resolved.length === 0) {
+        continue;
+      }
+      for (const candidate of resolved) {
+        if (typeof candidate !== "string") {
+          notify.emitError("invalid-event-match-resolver-candidate", candidate, "[Keymap] Invalid event match resolver candidate:");
+          continue;
+        }
+        if (seen.has(candidate)) {
+          continue;
+        }
+        seen.add(candidate);
+        keys.push(candidate);
+      }
+    }
+    return keys;
+  }
+  function runReleaseBindings(layer, strokeKey, event, focused) {
+    let handled = false;
+    let outcome = noMatchOutcome();
+    for (const binding of layer.bindings) {
+      if (binding.event !== "release") {
+        continue;
+      }
+      const firstPart = binding.sequence[0];
+      if (!firstPart || firstPart.match !== strokeKey) {
+        continue;
+      }
+      if (!conditions.matchesConditions(binding)) {
+        continue;
+      }
+      const bindingHandled = executor.runBinding(layer, binding, event, focused);
+      outcome = preferDispatchOutcome(outcome, createBindingOutcome(binding, bindingHandled));
+      if (!bindingHandled) {
+        emitBindingDispatch("binding-reject", layer, binding, focused);
+        continue;
+      }
+      emitBindingDispatch("binding-execute", layer, binding, focused);
+      handled = true;
+      if (!binding.fallthrough) {
+        return { handled: true, stop: true, outcome };
+      }
+    }
+    return { handled, stop: false, outcome };
+  }
+  function matchPattern(patternName, event) {
+    return matchSequencePattern(state.patterns, notify, patternName, event);
+  }
+  function createPatternEventPart2(event, patternName, match) {
+    return createPatternEventPart(state.patterns, event, patternName, match);
+  }
+  function collectRootCaptures(layer, matchKeys, event, focused, activeView) {
+    const captures = collectRootSequenceCaptures(layer, matchKeys, event, matchPattern, createPatternEventPart2);
+    return captures.some((capture) => captureIsReachable(capture, focused, activeView)) ? captures : [];
+  }
+  function createSequencePayload2(capture) {
+    return createSequencePayload(state.patterns, notify, capture);
+  }
+  function bindingMatchesRuntimeState(binding, focused, activeView) {
+    return conditions.matchesConditions(binding) && catalog.isBindingVisible(binding, focused, activeView);
+  }
+  function captureIsReachable(capture, focused, activeView) {
+    return bindingMatchesRuntimeState(capture.binding, focused, activeView);
+  }
+  function runCaptureBindings(layer, captures, event, focused) {
+    let handled = false;
+    let outcome = noMatchOutcome();
+    for (const capture of captures) {
+      const binding = capture.binding;
+      if (!conditions.matchesConditions(binding)) {
+        continue;
+      }
+      const bindingHandled = executor.runBinding(layer, binding, event, focused, createSequencePayload2(capture));
+      outcome = preferDispatchOutcome(outcome, createBindingOutcome(binding, bindingHandled));
+      if (!bindingHandled) {
+        emitBindingDispatch("binding-reject", layer, binding, focused);
+        continue;
+      }
+      emitBindingDispatch("binding-execute", layer, binding, focused);
+      handled = true;
+      if (!binding.fallthrough) {
+        return { handled: true, stop: true, outcome };
+      }
+    }
+    return { handled, stop: false, outcome };
+  }
+  return {
+    intercept,
+    prependEventMatchResolver,
+    appendEventMatchResolver,
+    clearEventMatchResolvers,
+    prependDisambiguationResolver,
+    appendDisambiguationResolver,
+    clearDisambiguationResolvers,
+    handlePendingSequenceChange,
+    handleRawSequence,
+    handleKeyEvent
+  };
+}
+function resolveSingleEventMatchKeys(resolver, event, ctx, notify) {
+  let resolved;
+  try {
+    resolved = resolver(event, ctx);
+  } catch (error) {
+    notify.emitError("event-match-resolver-error", error, "[Keymap] Error in event match resolver:");
+    return [];
+  }
+  if (!resolved || resolved.length === 0) {
+    return [];
+  }
+  if (resolved.length === 1) {
+    const [candidate] = resolved;
+    if (typeof candidate !== "string") {
+      notify.emitError("invalid-event-match-resolver-candidate", candidate, "[Keymap] Invalid event match resolver candidate:");
+      return [];
+    }
+    return [candidate];
+  }
+  const keys = [];
+  const seen = new Set;
+  for (const candidate of resolved) {
+    if (typeof candidate !== "string") {
+      notify.emitError("invalid-event-match-resolver-candidate", candidate, "[Keymap] Invalid event match resolver candidate:");
+      continue;
+    }
+    if (seen.has(candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    keys.push(candidate);
+  }
+  return keys;
+}
+function sameParts(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index]?.match !== right[index]?.match) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/services/environment.ts
+var NOOP = () => {};
+function normalizePatternLimit(name, field, value, fallback) {
+  if (value === undefined) {
+    return fallback;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new Error(`Keymap sequence pattern "${name}" ${field} must be a non-negative integer`);
+  }
+  return value;
+}
+function registerFieldCompilers(fields, options) {
+  const { kind, reservedFields, registeredFields, emitError } = options;
+  const entries = Object.entries(fields);
+  const registered = [];
+  for (const [name, compiler] of entries) {
+    if (reservedFields.has(name)) {
+      emitError(`reserved-${kind}-field`, { field: name, kind }, `Keymap ${kind} field "${name}" is reserved`);
+      continue;
+    }
+    if (registeredFields.has(name)) {
+      emitError(`duplicate-${kind}-field`, { field: name, kind }, `Keymap ${kind} field "${name}" is already registered`);
+      continue;
+    }
+    registeredFields.set(name, compiler);
+    registered.push([name, compiler]);
+  }
+  return () => {
+    for (const [name, compiler] of registered) {
+      const current = registeredFields.get(name);
+      if (current === compiler) {
+        registeredFields.delete(name);
+      }
+    }
+  };
+}
+function registerToken(state, notify, compiler, layers, token) {
+  let normalizedToken;
+  try {
+    normalizedToken = normalizeBindingTokenName(token.name);
+  } catch (error) {
+    notify.emitError("token-name-normalize-error", error, getErrorMessage(error, "Failed to register keymap token"));
+    return NOOP;
+  }
+  if (state.tokens.has(normalizedToken) || state.patterns.has(normalizedToken)) {
+    notify.emitError("duplicate-token", { token: normalizedToken }, `Keymap token "${normalizedToken}" is already registered`);
+    return NOOP;
+  }
+  let parsedToken;
+  try {
+    parsedToken = compiler.parseTokenKey(token.key);
+    if (parsedToken.patternName) {
+      throw new Error(`Invalid key "${String(token.key)}": expected a concrete key stroke`);
+    }
+  } catch (error) {
+    notify.emitError("token-parse-error", error, getErrorMessage(error, `Failed to register keymap token "${normalizedToken}"`));
+    return NOOP;
+  }
+  const registeredToken = {
+    stroke: parsedToken.stroke,
+    match: parsedToken.match
+  };
+  const nextTokens = new Map(state.tokens);
+  nextTokens.set(normalizedToken, registeredToken);
+  try {
+    layers.applyTokenState(nextTokens);
+  } catch (error) {
+    notify.emitError("token-register-error", error, getErrorMessage(error, `Failed to register keymap token "${normalizedToken}"`));
+    return NOOP;
+  }
+  return () => {
+    const current = state.tokens.get(normalizedToken);
+    if (current !== registeredToken) {
+      return;
+    }
+    const nextTokens2 = new Map(state.tokens);
+    nextTokens2.delete(normalizedToken);
+    try {
+      layers.applyTokenState(nextTokens2);
+    } catch (error) {
+      notify.emitError("token-unregister-error", error, getErrorMessage(error, `Failed to unregister keymap token "${normalizedToken}"`));
+    }
+  };
+}
+function registerSequencePattern(state, notify, layers, pattern) {
+  let normalizedName;
+  let resolvedPattern;
+  try {
+    normalizedName = normalizeBindingTokenName(pattern.name);
+    const min = normalizePatternLimit(normalizedName, "min", pattern.min, 1);
+    const max = normalizePatternLimit(normalizedName, "max", pattern.max, Number.MAX_SAFE_INTEGER);
+    if (max < min) {
+      throw new Error(`Keymap sequence pattern "${normalizedName}" max must be greater than or equal to min`);
+    }
+    resolvedPattern = {
+      name: normalizedName,
+      display: pattern.display,
+      payloadKey: pattern.payloadKey ?? normalizedName,
+      match: createTextKeyMatch(`pattern:${normalizedName}`),
+      min,
+      max,
+      matcher: (event) => pattern.match(event),
+      finalize: pattern.finalize
+    };
+  } catch (error) {
+    notify.emitError("sequence-pattern-register-error", error, getErrorMessage(error, "Failed to register keymap sequence pattern"));
+    return NOOP;
+  }
+  if (state.tokens.has(normalizedName) || state.patterns.has(normalizedName)) {
+    notify.emitError("duplicate-sequence-pattern", { pattern: normalizedName }, `Keymap sequence pattern "${normalizedName}" is already registered`);
+    return NOOP;
+  }
+  state.patterns.set(normalizedName, resolvedPattern);
+  layers.recompileBindings();
+  return () => {
+    const current = state.patterns.get(normalizedName);
+    if (current !== resolvedPattern) {
+      return;
+    }
+    state.patterns.delete(normalizedName);
+    layers.recompileBindings();
+  };
+}
+function registerFields(state, notify, kind, fields) {
+  const reservedFields = kind === "layer" ? RESERVED_LAYER_FIELDS : kind === "binding" ? RESERVED_BINDING_FIELDS : RESERVED_COMMAND_FIELDS;
+  const registeredFields = kind === "layer" ? state.layerFields : kind === "binding" ? state.bindingFields : state.commandFields;
+  return registerFieldCompilers(fields, {
+    kind,
+    reservedFields,
+    registeredFields,
+    emitError: (code, error, message) => notify.emitError(code, error, message)
+  });
+}
+
+// src/services/layers.ts
+var NOOP2 = () => {};
+function compareLayers(left, right) {
+  const priorityDiff = right.priority - left.priority;
+  return priorityDiff || right.order - left.order;
+}
+function layerBlocksActiveKeyCache(layer) {
+  if (layer.matchers.length > 0)
+    return true;
+  for (const command of layer.commands)
+    if (command.matchers.length > 0)
+      return true;
+  for (const binding of layer.bindings)
+    if (binding.matchers.length > 0)
+      return true;
+  return false;
+}
+function layerBlocksActiveCommandViewCache(layer) {
+  if (layer.commands.length === 0)
+    return false;
+  if (layer.matchers.length > 0)
+    return true;
+  for (const command of layer.commands)
+    if (command.matchers.length > 0)
+      return true;
+  return false;
+}
+function createLayerService(state, notify, conditions, activation, options) {
+  const registerLayer = (layer) => {
+    return notify.runWithStateChangeBatch(() => {
+      const target = layer.target;
+      if (target && options.host.isTargetDestroyed(target)) {
+        notify.emitError("destroyed-layer-target", { target }, "Cannot register a keymap layer for a destroyed keymap target");
+        return NOOP2;
+      }
+      let sourceBindings;
+      let requires;
+      let matchers;
+      let fields;
+      let attrs;
+      let commands;
+      let targetMode;
+      try {
+        targetMode = normalizeTargetMode(layer);
+        sourceBindings = applyLayerBindingsTransformers(snapshotBindings(layer.bindings ?? []), layer);
+        const sourceCommands = applyCommandTransformers(layer.commands ?? [], layer);
+        commands = sourceCommands.length === 0 ? [] : options.commands.normalizeCommands(sourceCommands);
+        ({ requires, matchers, fields, attrs } = compileLayerRuntimeState(layer));
+      } catch (error) {
+        notify.emitError("register-layer-failed", error, getErrorMessage(error, "Failed to register keymap layer"));
+        return NOOP2;
+      }
+      const order = state.order++;
+      const bindingStates = options.compiler.compileBindings(sourceBindings, state.tokens, target, order, fields);
+      if (bindingStates.bindings.length === 0 && !bindingStates.hasTokenBindings && commands.length === 0) {
+        return NOOP2;
+      }
+      options.diagnostics?.analyzeLayer({
+        target,
+        order,
+        commands,
+        sourceBindings,
+        bindings: bindingStates.bindings,
+        hasTokenBindings: bindingStates.hasTokenBindings
+      });
+      const registeredLayer = {
+        order,
+        target,
+        targetMode,
+        priority: layer.priority ?? 0,
+        requires,
+        matchers,
+        fields,
+        attrs,
+        commands,
+        sourceBindings,
+        bindings: bindingStates.bindings,
+        root: buildSequenceTree(bindingStates.bindings, state.patterns),
+        hasTokenBindings: bindingStates.hasTokenBindings,
+        activeKeyCacheBlocked: false,
+        activeCommandViewCacheBlocked: false
+      };
+      updateCacheBlockers(registeredLayer);
+      state.layers.add(registeredLayer);
+      state.sortedLayers = [...state.sortedLayers, registeredLayer].sort(compareLayers);
+      attachReactiveMatchers(registeredLayer);
+      for (const command of registeredLayer.commands) {
+        attachReactiveMatchers(command);
+      }
+      for (const binding of registeredLayer.bindings) {
+        attachReactiveMatchers(binding);
+      }
+      if (target) {
+        const onTargetDestroy = () => {
+          unregisterLayer(registeredLayer);
+        };
+        registeredLayer.offTargetDestroy = options.host.onTargetDestroy(target, onTargetDestroy);
+      }
+      if (registeredLayer.commands.length > 0) {
+        activation.ensureValidPendingSequence();
+      }
+      notify.queueStateChange();
+      return () => {
+        unregisterLayer(registeredLayer);
+      };
+    });
+  };
+  const applyTokenState = (nextTokens) => {
+    notify.runWithStateChangeBatch(() => {
+      const nextCompilations = new Map;
+      for (const layer of state.layers) {
+        if (!layer.hasTokenBindings) {
+          continue;
+        }
+        nextCompilations.set(layer, compileLayerBindings(layer, nextTokens));
+      }
+      state.tokens = nextTokens;
+      let shouldClearPending = false;
+      for (const [layer, compilation] of nextCompilations) {
+        if (applyBindingStates(layer, compilation)) {
+          shouldClearPending = true;
+        }
+      }
+      if (shouldClearPending) {
+        activation.setPendingSequence(null);
+      }
+      if (nextCompilations.size > 0) {
+        notify.queueStateChange();
+      }
+    });
+  };
+  const recompileBindings = () => {
+    notify.runWithStateChangeBatch(() => {
+      let recompiledLayers = 0;
+      let shouldClearPending = false;
+      for (const layer of state.layers) {
+        if (layer.sourceBindings.length === 0) {
+          continue;
+        }
+        const compilation = compileLayerBindings(layer, state.tokens);
+        if (applyBindingStates(layer, compilation)) {
+          shouldClearPending = true;
+        }
+        recompiledLayers += 1;
+      }
+      if (shouldClearPending) {
+        activation.setPendingSequence(null);
+      }
+      if (recompiledLayers > 0) {
+        notify.queueStateChange();
+      }
+    });
+  };
+  const cleanup = () => {
+    for (const layer of state.layers) {
+      detachReactiveMatchers(layer);
+      for (const command of layer.commands) {
+        detachReactiveMatchers(command);
+      }
+      for (const binding of layer.bindings) {
+        detachReactiveMatchers(binding);
+      }
+      layer.offTargetDestroy?.();
+      layer.offTargetDestroy = undefined;
+    }
+  };
+  const normalizeTargetMode = (layer) => {
+    if (layer.targetMode) {
+      if (!layer.target) {
+        throw new Error(`Keymap targetMode "${layer.targetMode}" requires a target`);
+      }
+      return layer.targetMode;
+    }
+    return layer.target ? "focus-within" : undefined;
+  };
+  const applyLayerBindingsTransformers = (bindings, layer) => {
+    const transformers = state.layerBindingsTransformers.values();
+    if (transformers.length === 0) {
+      return bindings;
+    }
+    let current = bindings;
+    for (const transformer of transformers) {
+      const next = transformer(current, {
+        layer,
+        validateBindings: (bindings2) => validateBindings(bindings2)
+      });
+      if (!next) {
+        continue;
+      }
+      current = snapshotBindings(next);
+    }
+    return current;
+  };
+  const applyCommandTransformers = (commands, layer) => {
+    const transformers = state.commandTransformers.values();
+    if (commands.length === 0 || transformers.length === 0) {
+      return commands;
+    }
+    const transformedCommands = [];
+    for (const command of commands) {
+      const transformedCommand = { ...command };
+      const extraCommands = [];
+      let keepOriginal = true;
+      for (const transformer of transformers) {
+        try {
+          transformer(transformedCommand, {
+            layer,
+            add(nextCommand) {
+              extraCommands.push({ ...nextCommand });
+            },
+            skipOriginal() {
+              keepOriginal = false;
+            }
+          });
+        } catch (error) {
+          notify.emitError("command-transformer-error", error, "[Keymap] Error in command transformer:");
+        }
+      }
+      if (keepOriginal) {
+        transformedCommands.push(transformedCommand);
+      }
+      transformedCommands.push(...extraCommands);
+    }
+    return transformedCommands;
+  };
+  const compileLayerRuntimeState = (layer) => {
+    const mergedRequires = {};
+    const matchers = [];
+    const fields = Object.create(null);
+    const attrs = {};
+    for (const [fieldName, value] of Object.entries(layer)) {
+      if (RESERVED_LAYER_FIELDS.has(fieldName)) {
+        continue;
+      }
+      if (value === undefined) {
+        continue;
+      }
+      fields[fieldName] = snapshotDataValue(value);
+      const compiler = state.layerFields.get(fieldName);
+      if (!compiler) {
+        options.warnUnknownField("layer", fieldName);
+        continue;
+      }
+      compiler(value, createFieldCompilerContext({
+        fieldName,
+        conditions,
+        requirements: mergedRequires,
+        matchers,
+        attrs
+      }));
+    }
+    return {
+      requires: Object.entries(mergedRequires),
+      matchers,
+      fields: Object.keys(fields).length > 0 ? Object.freeze(fields) : undefined,
+      attrs: Object.keys(attrs).length > 0 ? snapshotDataValue(attrs, { freeze: true }) : undefined
+    };
+  };
+  const compileLayerBindings = (layer, tokens) => {
+    return options.compiler.compileBindings(layer.sourceBindings, tokens, layer.target, layer.order, layer.fields);
+  };
+  const applyBindingStates = (layer, compilation) => {
+    options.diagnostics?.analyzeLayer({
+      target: layer.target,
+      order: layer.order,
+      commands: layer.commands,
+      sourceBindings: layer.sourceBindings,
+      bindings: compilation.bindings,
+      hasTokenBindings: compilation.hasTokenBindings
+    });
+    untrackCacheBlockers(layer);
+    for (const binding of layer.bindings) {
+      detachReactiveMatchers(binding);
+    }
+    layer.bindings = compilation.bindings;
+    layer.root = buildSequenceTree(compilation.bindings, state.patterns);
+    layer.hasTokenBindings = compilation.hasTokenBindings;
+    updateCacheBlockers(layer);
+    for (const binding of layer.bindings) {
+      attachReactiveMatchers(binding);
+    }
+    return state.pending?.captures.some((capture) => capture.layer === layer) ?? false;
+  };
+  const unregisterLayer = (layer) => {
+    notify.runWithStateChangeBatch(() => {
+      if (!state.layers.delete(layer)) {
+        return;
+      }
+      state.sortedLayers = state.sortedLayers.filter((candidate) => candidate !== layer);
+      untrackCacheBlockers(layer);
+      detachReactiveMatchers(layer);
+      for (const command of layer.commands) {
+        detachReactiveMatchers(command);
+      }
+      for (const binding of layer.bindings) {
+        detachReactiveMatchers(binding);
+      }
+      layer.offTargetDestroy?.();
+      layer.offTargetDestroy = undefined;
+      if (state.pending?.captures.some((capture) => capture.layer === layer)) {
+        activation.setPendingSequence(null);
+      } else if (layer.commands.length > 0 && !options.host.isDestroyed) {
+        activation.ensureValidPendingSequence();
+      }
+      notify.queueStateChange();
+    });
+  };
+  const attachReactiveMatchers = (target) => {
+    for (const matcher of target.matchers) {
+      if (!matcher.subscribe) {
+        continue;
+      }
+      try {
+        matcher.dispose = matcher.subscribe(() => {
+          if (!activation.hasPendingSequenceState()) {
+            notify.queueStateChange();
+            return;
+          }
+          notify.runWithStateChangeBatch(() => {
+            activation.revalidatePendingSequenceIfNeeded();
+            notify.queueStateChange();
+          });
+        });
+      } catch (error) {
+        notify.emitError("reactive-matcher-subscribe-error", error, getErrorMessage(error, `Failed to subscribe to reactive matcher from ${matcher.source}`));
+      }
+    }
+  };
+  const updateCacheBlockers = (layer) => {
+    const activeKeyBlocked = layerBlocksActiveKeyCache(layer);
+    const activeCommandViewBlocked = layerBlocksActiveCommandViewCache(layer);
+    layer.activeKeyCacheBlocked = activeKeyBlocked;
+    layer.activeCommandViewCacheBlocked = activeCommandViewBlocked;
+    if (activeKeyBlocked)
+      state.activeKeyCacheBlockers += 1;
+    if (activeCommandViewBlocked)
+      state.activeCommandViewCacheBlockers += 1;
+  };
+  const untrackCacheBlockers = (layer) => {
+    if (layer.activeKeyCacheBlocked) {
+      state.activeKeyCacheBlockers -= 1;
+      layer.activeKeyCacheBlocked = false;
+    }
+    if (layer.activeCommandViewCacheBlocked) {
+      state.activeCommandViewCacheBlockers -= 1;
+      layer.activeCommandViewCacheBlocked = false;
+    }
+  };
+  const detachReactiveMatchers = (target) => {
+    for (const matcher of target.matchers) {
+      if (!matcher.dispose) {
+        continue;
+      }
+      try {
+        matcher.dispose();
+      } catch (error) {
+        notify.emitError("reactive-matcher-dispose-error", error, getErrorMessage(error, `Failed to dispose reactive matcher from ${matcher.source}`));
+      }
+      matcher.dispose = undefined;
+    }
+  };
+  return { registerLayer, applyTokenState, recompileBindings, cleanup };
+}
+
+// src/services/notify.ts
+var MAX_STATE_CHANGE_FLUSH_ITERATIONS = 1000;
+function createNotificationService(state, events, hooks) {
+  const emitWarning = (code, warning, message) => {
+    if (!events.has("warning")) {
+      const consoleMessage = `[${code}] ${message}`;
+      if (warning instanceof Error) {
+        console.warn(consoleMessage, warning);
+      } else {
+        console.warn(consoleMessage);
+      }
+      return;
+    }
+    events.emit("warning", { code, message, warning });
+  };
+  const emitError = (code, error, message) => {
+    if (!events.has("error")) {
+      const consoleMessage = `[${code}] ${message}`;
+      if (error instanceof Error) {
+        console.error(consoleMessage, error);
+      } else {
+        console.error(consoleMessage);
+      }
+      return;
+    }
+    events.emit("error", { code, message, error });
+  };
+  const flushStateChange = () => {
+    if (!state.stateChangePending || state.stateChangeDepth > 0 || state.flushingStateChange) {
+      return;
+    }
+    state.flushingStateChange = true;
+    try {
+      let iterations = 0;
+      while (state.stateChangePending && state.stateChangeDepth === 0) {
+        if (iterations >= MAX_STATE_CHANGE_FLUSH_ITERATIONS) {
+          state.stateChangePending = false;
+          emitError("state-change-feedback-loop", { iterations: MAX_STATE_CHANGE_FLUSH_ITERATIONS }, `[Keymap] Possible infinite state listener feedback loop detected after ${MAX_STATE_CHANGE_FLUSH_ITERATIONS} iterations; pending state notifications were dropped`);
+          break;
+        }
+        iterations += 1;
+        state.stateChangePending = false;
+        hooks.emit("state");
+      }
+    } finally {
+      state.flushingStateChange = false;
+    }
+  };
+  return {
+    runWithStateChangeBatch(fn) {
+      state.stateChangeDepth += 1;
+      try {
+        return fn();
+      } finally {
+        state.stateChangeDepth -= 1;
+        if (state.stateChangeDepth === 0) {
+          flushStateChange();
+        }
+      }
+    },
+    queueStateChange(options) {
+      state.derivedVersion += 1;
+      if (options?.invalidateCaches !== false) {
+        state.cacheVersion += 1;
+      }
+      if (!hooks.has("state")) {
+        return;
+      }
+      state.stateChangePending = true;
+      if (state.stateChangeDepth === 0 && !state.flushingStateChange) {
+        flushStateChange();
+      }
+    },
+    emitWarning,
+    emitError,
+    reportListenerError(name, error) {
+      if (name === "state") {
+        emitError("state-listener-error", error, "[Keymap] Error in state listener:");
+        return;
+      }
+      if (name === "pendingSequence") {
+        emitError("pending-sequence-listener-error", error, "[Keymap] Error in pending sequence listener:");
+        return;
+      }
+      if (name === "dispatch") {
+        emitError("dispatch-listener-error", error, "[Keymap] Error in dispatch listener:");
+      }
+    },
+    warnOnce(key, code, warning, message) {
+      if (state.usedWarningKeys.has(key)) {
+        return;
+      }
+      state.usedWarningKeys.add(key);
+      emitWarning(code, warning, message);
+    }
+  };
+}
+
+// src/services/runtime.ts
+function createRuntimeService(state, notify, activation) {
+  return {
+    getData(name) {
+      return state.data[name];
+    },
+    setData(name, value) {
+      notify.runWithStateChangeBatch(() => {
+        if (value === undefined) {
+          if (!(name in state.data)) {
+            return;
+          }
+          delete state.data[name];
+          state.dataVersion += 1;
+          activation.ensureValidPendingSequence();
+          notify.queueStateChange();
+          return;
+        }
+        if (Object.is(state.data[name], value)) {
+          return;
+        }
+        state.data[name] = value;
+        state.dataVersion += 1;
+        activation.ensureValidPendingSequence();
+        notify.queueStateChange();
+      });
+    },
+    getReadonlyData() {
+      if (state.readonlyDataVersion === state.dataVersion) {
+        return state.readonlyData;
+      }
+      state.readonlyData = Object.freeze({ ...state.data });
+      state.readonlyDataVersion = state.dataVersion;
+      return state.readonlyData;
+    }
+  };
+}
+
+// src/services/state.ts
+var EMPTY_DATA = Object.freeze({});
+function createKeymapState() {
+  return {
+    order: 0,
+    tokens: new Map,
+    patterns: new Map,
+    layerFields: new Map,
+    layerBindingsTransformers: createRuntimeOrderedRegistry(),
+    bindingExpanders: createRuntimeOrderedRegistry(),
+    bindingParsers: createRuntimeOrderedRegistry(),
+    bindingTransformers: createRuntimeOrderedRegistry(),
+    bindingFields: new Map,
+    commandTransformers: createRuntimeOrderedRegistry(),
+    commandFields: new Map,
+    eventMatchResolvers: createRuntimeOrderedRegistry(),
+    disambiguationResolvers: createRuntimeOrderedRegistry(),
+    keyHooks: createRuntimePriorityRegistry(),
+    keyAfterHooks: createRuntimePriorityRegistry(),
+    rawHooks: createRuntimePriorityRegistry(),
+    layers: new Set,
+    sortedLayers: [],
+    activeLayersCacheVersion: -1,
+    activeLayersCacheFocused: undefined,
+    activeLayersCache: [],
+    activeKeyCacheBlockers: 0,
+    activeCommandViewCacheBlockers: 0,
+    commandResolvers: createRuntimeOrderedRegistry(),
+    pending: null,
+    data: {},
+    dataVersion: 0,
+    readonlyDataVersion: -1,
+    readonlyData: EMPTY_DATA,
+    cacheVersion: 0,
+    derivedVersion: 0,
+    stateChangeDepth: 0,
+    stateChangePending: false,
+    flushingStateChange: false,
+    usedWarningKeys: new Set
+  };
+}
+
+// src/keymap.ts
+function getKeyMatchKey(input) {
+  return resolveKeyMatch(input);
+}
+
+class Keymap {
+  #state = createKeymapState();
+  #cleanedUp = false;
+  #resources = new Map;
+  #cleanupListeners = [];
+  #events = createRuntimeEmitter(() => {});
+  #hooks;
+  #notify;
+  #activation;
+  #runtime;
+  #conditions;
+  #catalog;
+  #executor;
+  #compiler;
+  #dispatch;
+  #layers;
+  #layerDiagnostics;
+  #keypressListener;
+  #keyreleaseListener;
+  #rawListener;
+  #focusedTargetListener;
+  #host;
+  getPendingSequence;
+  getActiveKeys;
+  constructor(host) {
+    this.#host = host;
+    if (host.isDestroyed) {
+      throw new Error("Cannot create a keymap for a destroyed host");
+    }
+    this.#hooks = createRuntimeEmitter((name, error) => {
+      this.#notify.reportListenerError(name, error);
+    });
+    this.#notify = createNotificationService(this.#state, this.#events, this.#hooks);
+    this.#conditions = createConditionService(this.#state, this.#notify);
+    this.#catalog = createCommandCatalogService(this.#state, this.#host, this.#notify, this.#conditions, {
+      onCommandResolversChanged: () => {
+        this.#activation.ensureValidPendingSequence();
+      }
+    });
+    this.#activation = createActivationService(this.#state, this.#host, this.#hooks, this.#notify, this.#conditions, this.#catalog, {
+      onPendingSequenceChanged: (previous, next) => {
+        this.#dispatch?.handlePendingSequenceChange(previous, next);
+      }
+    });
+    this.#runtime = createRuntimeService(this.#state, this.#notify, this.#activation);
+    this.#executor = createCommandExecutorService(this.#notify, this.#runtime, this.#activation, this.#catalog, {
+      keymap: this,
+      createCommandEvent: () => this.#host.createCommandEvent()
+    });
+    this.#compiler = createCompilerService(this.#state, this.#notify, this.#conditions, {
+      warnUnknownField: (kind, fieldName) => {
+        this.#warnUnknownField(kind, fieldName);
+      },
+      warnUnknownToken: (token, sequence) => {
+        this.#warnUnknownToken(token, sequence);
+      }
+    });
+    this.#layerDiagnostics = createLayerDiagnostics(this.#notify, this.#catalog);
+    this.#layers = createLayerService(this.#state, this.#notify, this.#conditions, this.#activation, {
+      compiler: this.#compiler,
+      commands: this.#catalog,
+      host: this.#host,
+      diagnostics: this.#layerDiagnostics,
+      warnUnknownField: (kind, fieldName) => {
+        this.#warnUnknownField(kind, fieldName);
+      }
+    });
+    this.#dispatch = createDispatchService(this.#state, this.#notify, this.#runtime, this.#activation, this.#conditions, this.#executor, this.#compiler, this.#catalog, this.#layers, this.#hooks);
+    this.getPendingSequence = this.#activation.getPendingSequence;
+    this.getActiveKeys = this.#activation.getActiveKeys;
+    this.#keypressListener = (event) => {
+      this.#dispatch.handleKeyEvent(event, false);
+    };
+    this.#keyreleaseListener = (event) => {
+      this.#dispatch.handleKeyEvent(event, true);
+    };
+    this.#rawListener = (sequence) => {
+      return this.#dispatch.handleRawSequence(sequence);
+    };
+    this.#focusedTargetListener = (focused) => {
+      this.#handleFocusedTargetChange(focused);
+    };
+    this.#cleanupListeners.push(this.#host.onKeyPress(this.#keypressListener));
+    this.#cleanupListeners.push(this.#host.onKeyRelease(this.#keyreleaseListener));
+    if (this.#host.onRawInput) {
+      this.#cleanupListeners.push(this.#host.onRawInput(this.#rawListener));
+    }
+    this.#cleanupListeners.push(this.#host.onFocusChange(this.#focusedTargetListener));
+    if (this.#host.onDestroy) {
+      this.#cleanupListeners.push(this.#host.onDestroy(() => {
+        this.#cleanup();
+      }));
+    }
+  }
+  [KEYMAP_EXTENSION_CONTEXT]() {
+    return {
+      state: this.#state,
+      host: this.#host,
+      conditions: this.#conditions,
+      catalog: this.#catalog,
+      activation: this.#activation
+    };
+  }
+  #cleanup() {
+    if (this.#cleanedUp) {
+      return;
+    }
+    this.#cleanedUp = true;
+    this.#activation.setPendingSequence(null);
+    for (const resource of this.#resources.values()) {
+      resource.dispose();
+    }
+    this.#resources.clear();
+    this.#layers.cleanup();
+    for (const cleanupListener of this.#cleanupListeners.splice(0)) {
+      cleanupListener();
+    }
+  }
+  setData(name, value) {
+    this.#runtime.setData(name, value);
+  }
+  getData(name) {
+    return this.#runtime.getData(name);
+  }
+  getHostMetadata() {
+    return this.#host.metadata;
+  }
+  hasPendingSequence() {
+    return this.#activation.ensureValidPendingSequence() !== undefined;
+  }
+  createKeyMatcher(key) {
+    const match = this.#compiler.parseTokenKey(key).match;
+    return (input) => {
+      if (!input) {
+        return false;
+      }
+      return getKeyMatchKey(input) === match;
+    };
+  }
+  parseKeySequence(key) {
+    return this.#compiler.parseKeySequence(key);
+  }
+  formatKey(key, options) {
+    return this.#compiler.formatKey(key, options);
+  }
+  clearPendingSequence() {
+    this.#activation.setPendingSequence(null);
+  }
+  popPendingSequence() {
+    return this.#activation.popPendingSequence();
+  }
+  getCommands(query) {
+    return this.#catalog.getCommands(query);
+  }
+  getCommandEntries(query) {
+    return this.#catalog.getCommandEntries(query);
+  }
+  getCommandBindings(query) {
+    return this.#catalog.getCommandBindings(query);
+  }
+  acquireResource(key, setup) {
+    if (this.#cleanedUp || this.#host.isDestroyed) {
+      throw new Error("Cannot use a keymap after its host was destroyed");
+    }
+    const existing = this.#resources.get(key);
+    if (existing) {
+      existing.count += 1;
+      return () => {
+        this.#releaseResource(key, existing);
+      };
+    }
+    const dispose = setup();
+    const resource = { count: 1, dispose };
+    this.#resources.set(key, resource);
+    return () => {
+      this.#releaseResource(key, resource);
+    };
+  }
+  runCommand(cmd, options) {
+    return this.#executor.runCommand(cmd, options);
+  }
+  dispatchCommand(cmd, options) {
+    return this.#executor.dispatchCommand(cmd, options);
+  }
+  on(name, fn) {
+    if (name === "warning") {
+      return this.#events.hook(name, fn);
+    }
+    if (name === "error") {
+      return this.#events.hook(name, fn);
+    }
+    return this.#hooks.hook(name, fn);
+  }
+  intercept(name, fn, options) {
+    if (name === "key") {
+      return this.#dispatch.intercept(name, fn, options);
+    }
+    if (name === "key:after") {
+      return this.#dispatch.intercept(name, fn, options);
+    }
+    return this.#dispatch.intercept(name, fn, options);
+  }
+  registerLayer(layer) {
+    return this.#layers.registerLayer(layer);
+  }
+  registerLayerFields(fields) {
+    return registerFields(this.#state, this.#notify, "layer", fields);
+  }
+  prependLayerBindingsTransformer(transformer) {
+    return this.#state.layerBindingsTransformers.prepend(transformer);
+  }
+  appendLayerBindingsTransformer(transformer) {
+    return this.#state.layerBindingsTransformers.append(transformer);
+  }
+  clearLayerBindingsTransformers() {
+    this.#state.layerBindingsTransformers.clear();
+  }
+  prependBindingTransformer(transformer) {
+    return this.#state.bindingTransformers.prepend(transformer);
+  }
+  appendBindingTransformer(transformer) {
+    return this.#state.bindingTransformers.append(transformer);
+  }
+  clearBindingTransformers() {
+    this.#state.bindingTransformers.clear();
+  }
+  prependCommandTransformer(transformer) {
+    return this.#state.commandTransformers.prepend(transformer);
+  }
+  appendCommandTransformer(transformer) {
+    return this.#state.commandTransformers.append(transformer);
+  }
+  clearCommandTransformers() {
+    this.#state.commandTransformers.clear();
+  }
+  prependBindingParser(parser) {
+    return this.#state.bindingParsers.prepend(parser);
+  }
+  appendBindingParser(parser) {
+    return this.#state.bindingParsers.append(parser);
+  }
+  clearBindingParsers() {
+    this.#state.bindingParsers.clear();
+  }
+  registerToken(token) {
+    return registerToken(this.#state, this.#notify, this.#compiler, this.#layers, token);
+  }
+  registerSequencePattern(pattern) {
+    return registerSequencePattern(this.#state, this.#notify, this.#layers, pattern);
+  }
+  prependBindingExpander(expander) {
+    return this.#state.bindingExpanders.prepend(expander);
+  }
+  appendBindingExpander(expander) {
+    return this.#state.bindingExpanders.append(expander);
+  }
+  clearBindingExpanders() {
+    this.#state.bindingExpanders.clear();
+  }
+  registerBindingFields(fields) {
+    return registerFields(this.#state, this.#notify, "binding", fields);
+  }
+  registerCommandFields(fields) {
+    return registerFields(this.#state, this.#notify, "command", fields);
+  }
+  prependCommandResolver(resolver) {
+    return this.#catalog.prependCommandResolver(resolver);
+  }
+  appendCommandResolver(resolver) {
+    return this.#catalog.appendCommandResolver(resolver);
+  }
+  clearCommandResolvers() {
+    this.#catalog.clearCommandResolvers();
+  }
+  prependLayerAnalyzer(analyzer) {
+    return this.#layerDiagnostics.prependLayerAnalyzer(analyzer);
+  }
+  appendLayerAnalyzer(analyzer) {
+    return this.#layerDiagnostics.appendLayerAnalyzer(analyzer);
+  }
+  clearLayerAnalyzers() {
+    this.#layerDiagnostics.clearLayerAnalyzers();
+  }
+  prependEventMatchResolver(resolver) {
+    return this.#dispatch.prependEventMatchResolver(resolver);
+  }
+  appendEventMatchResolver(resolver) {
+    return this.#dispatch.appendEventMatchResolver(resolver);
+  }
+  clearEventMatchResolvers() {
+    this.#dispatch.clearEventMatchResolvers();
+  }
+  prependDisambiguationResolver(resolver) {
+    return this.#dispatch.prependDisambiguationResolver(resolver);
+  }
+  appendDisambiguationResolver(resolver) {
+    return this.#dispatch.appendDisambiguationResolver(resolver);
+  }
+  clearDisambiguationResolvers() {
+    this.#dispatch.clearDisambiguationResolvers();
+  }
+  #handleFocusedTargetChange(_focused) {
+    this.#notify.runWithStateChangeBatch(() => {
+      this.#activation.setPendingSequence(null);
+      this.#notify.queueStateChange({ invalidateCaches: false });
+    });
+  }
+  #warnUnknownField(kind, fieldName) {
+    this.#notify.warnOnce(`${kind}:${fieldName}`, `unknown-${kind}-field`, { field: fieldName, kind }, `[Keymap] Unknown ${kind} field "${fieldName}" was ignored`);
+  }
+  #warnUnknownToken(token, sequence) {
+    this.#notify.warnOnce(`token:${token}`, "unknown-token", { token, sequence }, `[Keymap] Unknown token "${token}" in key sequence "${sequence}" was ignored`);
+  }
+  #releaseResource(key, resource) {
+    const current = this.#resources.get(key);
+    if (current !== resource) {
+      return;
+    }
+    resource.count -= 1;
+    if (resource.count > 0) {
+      return;
+    }
+    resource.dispose();
+    this.#resources.delete(key);
+  }
+}
+export {
+  stringifyKeyStroke,
+  stringifyKeySequence,
+  Keymap,
+  KEYMAP_EXTENSION_CONTEXT
+};
+
+//# debugId=DF4DB67A4951EA4E64756E2164756E21
+//# sourceMappingURL=index.js.map