@a11y-oracle/keyboard-engine 1.0.0

package/README.md

@@ -0,0 +1,144 @@
+# @a11y-oracle/keyboard-engine
+
+CDP-based keyboard dispatch engine for accessibility testing. Sends native hardware-level keystrokes via `Input.dispatchKeyEvent` and reads focused element information via `Runtime.evaluate`.
+
+This is a low-level building block used internally by `@a11y-oracle/core-engine`. Most users should use the Playwright or Cypress plugin instead.
+
+## Installation
+
+```bash
+npm install @a11y-oracle/keyboard-engine
+```
+
+## Usage
+
+```typescript
+import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+
+const keyboard = new KeyboardEngine(cdpSession);
+
+// Press a key
+await keyboard.press('Tab');
+
+// Press with modifiers
+await keyboard.press('Tab', { shift: true });   // Shift+Tab (backward)
+await keyboard.press('a', { ctrl: true });       // Ctrl+A (select all)
+
+// Get info about the currently focused element
+const el = await keyboard.getFocusedElement();
+if (el) {
+  console.log(el.tag);      // "BUTTON"
+  console.log(el.id);       // "submit-btn"
+  console.log(el.role);     // "button"
+  console.log(el.tabIndex); // 0
+  console.log(el.rect);     // { x: 100, y: 200, width: 120, height: 40 }
+}
+```
+
+## API Reference
+
+### `KeyboardEngine`
+
+#### `constructor(cdp: CDPSessionLike)`
+
+Create a new keyboard engine.
+
+- `cdp` — Any object with a `send(method, params?)` method compatible with CDP.
+
+#### `press(key: string, modifiers?: ModifierKeys): Promise<void>`
+
+Dispatch a native key press via CDP `Input.dispatchKeyEvent`. Sends a `keyDown` event followed by a `keyUp` event, matching the behavior of a physical key press.
+
+- `key` — Key name from `KEY_DEFINITIONS` (see table below).
+- `modifiers` — Optional modifier keys to hold during the press.
+
+Modifier keys map to the CDP bitmask: Alt = 1, Ctrl = 2, Meta = 4, Shift = 8.
+
+Throws if the key name is not in `KEY_DEFINITIONS`.
+
+#### `getFocusedElement(): Promise<FocusedElementInfo | null>`
+
+Get information about the currently focused DOM element via `Runtime.evaluate`.
+
+Returns `null` if no interactive element has focus (e.g., `document.body` or `document.documentElement` is focused).
+
+### Supported Keys
+
+| Key Name | Description |
+|----------|-------------|
+| `Tab` | Tab navigation |
+| `Enter` | Activate / submit |
+| `Space` or `' '` | Activate / toggle |
+| `Escape` | Cancel / close |
+| `ArrowUp` | Navigate up |
+| `ArrowDown` | Navigate down |
+| `ArrowLeft` | Navigate left |
+| `ArrowRight` | Navigate right |
+| `Home` | Jump to start |
+| `End` | Jump to end |
+| `Backspace` | Delete backward |
+| `Delete` | Delete forward |
+
+### Types
+
+#### `KeyDefinition`
+
+CDP keyboard event parameters for a single key:
+
+```typescript
+interface KeyDefinition {
+  key: string;     // CDP key property (e.g. "Tab")
+  code: string;    // CDP code property (e.g. "Tab")
+  keyCode: number; // Windows virtual key code (e.g. 9)
+}
+```
+
+#### `ModifierKeys`
+
+Modifier keys for key press combinations:
+
+```typescript
+interface ModifierKeys {
+  shift?: boolean;
+  ctrl?: boolean;
+  alt?: boolean;
+  meta?: boolean;
+}
+```
+
+#### `FocusedElementInfo`
+
+Information about the currently focused DOM element:
+
+```typescript
+interface FocusedElementInfo {
+  tag: string;        // "BUTTON"
+  id: string;         // "submit-btn"
+  className: string;  // "btn primary"
+  textContent: string; // "Submit"
+  role: string;       // "button" (from role attribute)
+  ariaLabel: string;  // "Submit form" (from aria-label)
+  tabIndex: number;   // 0
+  rect: { x: number; y: number; width: number; height: number };
+}
+```
+
+## Exports
+
+```typescript
+export { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+export { KEY_DEFINITIONS } from '@a11y-oracle/keyboard-engine';
+export type {
+  KeyDefinition,
+  ModifierKeys,
+  FocusedElementInfo,
+} from '@a11y-oracle/keyboard-engine';
+```
+
+## How It Works
+
+The engine uses two CDP domains:
+
+1. **`Input.dispatchKeyEvent`** — Sends real hardware-level keystroke events (keyDown + keyUp) directly to the browser. This bypasses synthetic JavaScript event dispatch (`element.dispatchEvent()`), so the browser handles focus management natively — just as if a user physically pressed the key.
+
+2. **`Runtime.evaluate`** — Executes a JavaScript expression in the page context to read `document.activeElement` properties (tag, id, class, role, aria-label, tabIndex, bounding rect).

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @module @a11y-oracle/keyboard-engine
+ *
+ * CDP-based keyboard dispatch engine for accessibility testing.
+ * Provides native hardware-level keystroke dispatch and focused
+ * element introspection.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+ *
+ * const keyboard = new KeyboardEngine(cdpSession);
+ * await keyboard.press('Tab');
+ * await keyboard.press('Tab', { shift: true }); // Shift+Tab
+ *
+ * const el = await keyboard.getFocusedElement();
+ * console.log(el?.tag, el?.id, el?.role);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { KeyboardEngine } from './lib/keyboard-engine.js';
+export { KEY_DEFINITIONS } from './lib/key-map.js';
+export type { KeyDefinition, ModifierKeys, FocusedElementInfo, } from './lib/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,YAAY,EACV,aAAa,EACb,YAAY,EACZ,kBAAkB,GACnB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * @module @a11y-oracle/keyboard-engine
+ *
+ * CDP-based keyboard dispatch engine for accessibility testing.
+ * Provides native hardware-level keystroke dispatch and focused
+ * element introspection.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+ *
+ * const keyboard = new KeyboardEngine(cdpSession);
+ * await keyboard.press('Tab');
+ * await keyboard.press('Tab', { shift: true }); // Shift+Tab
+ *
+ * const el = await keyboard.getFocusedElement();
+ * console.log(el?.tag, el?.id, el?.role);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { KeyboardEngine } from './lib/keyboard-engine.js';
+export { KEY_DEFINITIONS } from './lib/key-map.js';

package/dist/lib/key-map.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module key-map
+ *
+ * Maps human-readable key names to CDP `Input.dispatchKeyEvent` parameters.
+ * Used by the {@link KeyboardEngine} to dispatch real keyboard events
+ * through the Chrome DevTools Protocol.
+ */
+import type { KeyDefinition } from './types.js';
+/**
+ * Map of key names to their CDP Input.dispatchKeyEvent parameters.
+ *
+ * Supports all common navigation and interaction keys used in
+ * WCAG keyboard accessibility patterns.
+ */
+export declare const KEY_DEFINITIONS: Record<string, KeyDefinition>;
+//# sourceMappingURL=key-map.d.ts.map

package/dist/lib/key-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-map.d.ts","sourceRoot":"","sources":["../../src/lib/key-map.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAczD,CAAC"}

package/dist/lib/key-map.js

@@ -0,0 +1,28 @@
+/**
+ * @module key-map
+ *
+ * Maps human-readable key names to CDP `Input.dispatchKeyEvent` parameters.
+ * Used by the {@link KeyboardEngine} to dispatch real keyboard events
+ * through the Chrome DevTools Protocol.
+ */
+/**
+ * Map of key names to their CDP Input.dispatchKeyEvent parameters.
+ *
+ * Supports all common navigation and interaction keys used in
+ * WCAG keyboard accessibility patterns.
+ */
+export const KEY_DEFINITIONS = {
+    Tab: { key: 'Tab', code: 'Tab', keyCode: 9 },
+    Enter: { key: 'Enter', code: 'Enter', keyCode: 13 },
+    ' ': { key: ' ', code: 'Space', keyCode: 32 },
+    Space: { key: ' ', code: 'Space', keyCode: 32 },
+    Escape: { key: 'Escape', code: 'Escape', keyCode: 27 },
+    ArrowUp: { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+    ArrowDown: { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+    ArrowLeft: { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+    ArrowRight: { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+    Home: { key: 'Home', code: 'Home', keyCode: 36 },
+    End: { key: 'End', code: 'End', keyCode: 35 },
+    Backspace: { key: 'Backspace', code: 'Backspace', keyCode: 8 },
+    Delete: { key: 'Delete', code: 'Delete', keyCode: 46 },
+};

package/dist/lib/keyboard-engine.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @module keyboard-engine
+ *
+ * CDP-based keyboard dispatch engine. Sends native hardware-level
+ * keystrokes via `Input.dispatchKeyEvent` and reads focused element
+ * information via `Runtime.evaluate`.
+ *
+ * @example
+ * ```typescript
+ * import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+ *
+ * const keyboard = new KeyboardEngine(cdpSession);
+ * await keyboard.press('Tab');
+ * const focused = await keyboard.getFocusedElement();
+ * console.log(focused?.tag, focused?.id);
+ * ```
+ */
+import type { CDPSessionLike } from '@a11y-oracle/cdp-types';
+import type { ModifierKeys, FocusedElementInfo } from './types.js';
+/**
+ * Engine for dispatching native keyboard events via Chrome DevTools Protocol.
+ *
+ * Uses `Input.dispatchKeyEvent` for hardware-level key dispatch (bypassing
+ * synthetic JavaScript events) and `Runtime.evaluate` for reading
+ * `document.activeElement` properties.
+ */
+export declare class KeyboardEngine {
+    private cdp;
+    /**
+     * Create a new KeyboardEngine.
+     *
+     * @param cdp - CDP session to send commands through.
+     */
+    constructor(cdp: CDPSessionLike);
+    /**
+     * Press a keyboard key via CDP `Input.dispatchKeyEvent`.
+     *
+     * Dispatches a `keyDown` event followed by a `keyUp` event, matching
+     * the behavior of a physical key press.
+     *
+     * @param key - Key name from {@link KEY_DEFINITIONS}
+     *   (e.g. `'Tab'`, `'Enter'`, `'ArrowDown'`).
+     * @param modifiers - Optional modifier keys to hold during the press.
+     *
+     * @throws Error if the key is not in {@link KEY_DEFINITIONS}.
+     *
+     * @example
+     * ```typescript
+     * await keyboard.press('Tab');
+     * await keyboard.press('Tab', { shift: true }); // Shift+Tab
+     * ```
+     */
+    press(key: string, modifiers?: ModifierKeys): Promise<void>;
+    /**
+     * Get information about the currently focused DOM element.
+     *
+     * Uses `Runtime.evaluate` to query `document.activeElement` and
+     * extract its properties.
+     *
+     * @returns The focused element info, or `null` if no interactive
+     *          element has focus (e.g. body or document is focused).
+     *
+     * @example
+     * ```typescript
+     * await keyboard.press('Tab');
+     * const el = await keyboard.getFocusedElement();
+     * console.log(el?.tag); // 'BUTTON'
+     * console.log(el?.id);  // 'submit-btn'
+     * ```
+     */
+    getFocusedElement(): Promise<FocusedElementInfo | null>;
+}
+//# sourceMappingURL=keyboard-engine.d.ts.map

package/dist/lib/keyboard-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-engine.d.ts","sourceRoot":"","sources":["../../src/lib/keyboard-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAmDnE;;;;;;GAMG;AACH,qBAAa,cAAc;IAMb,OAAO,CAAC,GAAG;IALvB;;;;OAIG;gBACiB,GAAG,EAAE,cAAc;IAEvC;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BjE;;;;;;;;;;;;;;;;OAgBG;IACG,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;CAQ9D"}

package/dist/lib/keyboard-engine.js

@@ -0,0 +1,153 @@
+/**
+ * @module keyboard-engine
+ *
+ * CDP-based keyboard dispatch engine. Sends native hardware-level
+ * keystrokes via `Input.dispatchKeyEvent` and reads focused element
+ * information via `Runtime.evaluate`.
+ *
+ * @example
+ * ```typescript
+ * import { KeyboardEngine } from '@a11y-oracle/keyboard-engine';
+ *
+ * const keyboard = new KeyboardEngine(cdpSession);
+ * await keyboard.press('Tab');
+ * const focused = await keyboard.getFocusedElement();
+ * console.log(focused?.tag, focused?.id);
+ * ```
+ */
+import { KEY_DEFINITIONS } from './key-map.js';
+/**
+ * Compute the CDP modifier bitmask from a {@link ModifierKeys} object.
+ *
+ * Bitmask values per CDP spec:
+ * - Alt = 1
+ * - Ctrl = 2
+ * - Meta = 4
+ * - Shift = 8
+ */
+function computeModifiers(modifiers) {
+    if (!modifiers)
+        return 0;
+    let bitmask = 0;
+    if (modifiers.alt)
+        bitmask |= 1;
+    if (modifiers.ctrl)
+        bitmask |= 2;
+    if (modifiers.meta)
+        bitmask |= 4;
+    if (modifiers.shift)
+        bitmask |= 8;
+    return bitmask;
+}
+/**
+ * JavaScript expression evaluated in the browser to extract
+ * focused element information from `document.activeElement`.
+ *
+ * Returns `null` if no element has focus or the body is focused.
+ */
+const GET_FOCUSED_ELEMENT_JS = `
+(() => {
+  const el = document.activeElement;
+  if (!el || el === document.body || el === document.documentElement) return null;
+  const rect = el.getBoundingClientRect();
+  return {
+    tag: el.tagName,
+    id: el.id || '',
+    className: typeof el.className === 'string' ? el.className : '',
+    textContent: (el.textContent || '').trim().substring(0, 200),
+    role: el.getAttribute('role') || '',
+    ariaLabel: el.getAttribute('aria-label') || '',
+    tabIndex: el.tabIndex,
+    rect: {
+      x: Math.round(rect.x),
+      y: Math.round(rect.y),
+      width: Math.round(rect.width),
+      height: Math.round(rect.height),
+    },
+  };
+})()
+`;
+/**
+ * Engine for dispatching native keyboard events via Chrome DevTools Protocol.
+ *
+ * Uses `Input.dispatchKeyEvent` for hardware-level key dispatch (bypassing
+ * synthetic JavaScript events) and `Runtime.evaluate` for reading
+ * `document.activeElement` properties.
+ */
+export class KeyboardEngine {
+    cdp;
+    /**
+     * Create a new KeyboardEngine.
+     *
+     * @param cdp - CDP session to send commands through.
+     */
+    constructor(cdp) {
+        this.cdp = cdp;
+    }
+    /**
+     * Press a keyboard key via CDP `Input.dispatchKeyEvent`.
+     *
+     * Dispatches a `keyDown` event followed by a `keyUp` event, matching
+     * the behavior of a physical key press.
+     *
+     * @param key - Key name from {@link KEY_DEFINITIONS}
+     *   (e.g. `'Tab'`, `'Enter'`, `'ArrowDown'`).
+     * @param modifiers - Optional modifier keys to hold during the press.
+     *
+     * @throws Error if the key is not in {@link KEY_DEFINITIONS}.
+     *
+     * @example
+     * ```typescript
+     * await keyboard.press('Tab');
+     * await keyboard.press('Tab', { shift: true }); // Shift+Tab
+     * ```
+     */
+    async press(key, modifiers) {
+        const keyDef = KEY_DEFINITIONS[key];
+        if (!keyDef) {
+            const supported = Object.keys(KEY_DEFINITIONS).join(', ');
+            throw new Error(`Unknown key: "${key}". Supported keys: ${supported}`);
+        }
+        const mod = computeModifiers(modifiers);
+        await this.cdp.send('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key: keyDef.key,
+            code: keyDef.code,
+            windowsVirtualKeyCode: keyDef.keyCode,
+            nativeVirtualKeyCode: keyDef.keyCode,
+            modifiers: mod,
+        });
+        await this.cdp.send('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key: keyDef.key,
+            code: keyDef.code,
+            windowsVirtualKeyCode: keyDef.keyCode,
+            nativeVirtualKeyCode: keyDef.keyCode,
+            modifiers: mod,
+        });
+    }
+    /**
+     * Get information about the currently focused DOM element.
+     *
+     * Uses `Runtime.evaluate` to query `document.activeElement` and
+     * extract its properties.
+     *
+     * @returns The focused element info, or `null` if no interactive
+     *          element has focus (e.g. body or document is focused).
+     *
+     * @example
+     * ```typescript
+     * await keyboard.press('Tab');
+     * const el = await keyboard.getFocusedElement();
+     * console.log(el?.tag); // 'BUTTON'
+     * console.log(el?.id);  // 'submit-btn'
+     * ```
+     */
+    async getFocusedElement() {
+        const result = (await this.cdp.send('Runtime.evaluate', {
+            expression: GET_FOCUSED_ELEMENT_JS,
+            returnByValue: true,
+        }));
+        return result.result.value ?? null;
+    }
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @module types
+ *
+ * Type definitions for the keyboard engine.
+ */
+/**
+ * CDP keyboard event parameter definition for a single key.
+ */
+export interface KeyDefinition {
+    /** The `key` property for CDP (e.g. `'Tab'`, `'Enter'`). */
+    key: string;
+    /** The `code` property for CDP (e.g. `'Tab'`, `'Enter'`). */
+    code: string;
+    /** The Windows virtual key code (e.g. `9` for Tab). */
+    keyCode: number;
+}
+/**
+ * Modifier keys that can be held during a key press.
+ *
+ * Maps to CDP's `Input.dispatchKeyEvent` `modifiers` bitmask:
+ * - Alt = 1
+ * - Ctrl = 2
+ * - Meta = 4
+ * - Shift = 8
+ */
+export interface ModifierKeys {
+    shift?: boolean;
+    ctrl?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+/**
+ * Information about the currently focused DOM element.
+ *
+ * Obtained via `Runtime.evaluate` querying `document.activeElement`.
+ */
+export interface FocusedElementInfo {
+    /** The tag name (e.g. `'BUTTON'`, `'A'`, `'INPUT'`). */
+    tag: string;
+    /** The element's `id` attribute, or empty string. */
+    id: string;
+    /** The element's `className` string. */
+    className: string;
+    /** Trimmed text content of the element. */
+    textContent: string;
+    /** The element's `role` attribute, or empty string. */
+    role: string;
+    /** The element's `aria-label` attribute, or empty string. */
+    ariaLabel: string;
+    /** The element's `tabIndex` property. */
+    tabIndex: number;
+    /** The element's bounding rectangle. */
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,wDAAwD;IACxD,GAAG,EAAE,MAAM,CAAC;IACZ,qDAAqD;IACrD,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,IAAI,EAAE;QACJ,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH"}

package/dist/lib/types.js

@@ -0,0 +1,6 @@
+/**
+ * @module types
+ *
+ * Type definitions for the keyboard engine.
+ */
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@a11y-oracle/keyboard-engine",
+  "version": "1.0.0",
+  "description": "Native CDP keyboard dispatch with modifier key support and focused element introspection",
+  "license": "MIT",
+  "author": "a11y-oracle",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a11y-oracle/a11y-oracle.git",
+    "directory": "libs/keyboard-engine"
+  },
+  "bugs": {
+    "url": "https://github.com/a11y-oracle/a11y-oracle/issues"
+  },
+  "homepage": "https://github.com/a11y-oracle/a11y-oracle/tree/main/libs/keyboard-engine",
+  "keywords": [
+    "accessibility",
+    "a11y",
+    "keyboard",
+    "cdp",
+    "chrome-devtools-protocol",
+    "wcag",
+    "testing"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@a11y-oracle/cdp-types": "1.0.0",
+    "devtools-protocol": "^0.0.1591961",
+    "tslib": "^2.3.0"
+  }
+}