@skewedaspect/sage 0.3.0

package/docs/binding_system.md

@@ -0,0 +1,820 @@
+# Binding System
+
+## Overview
+
+The SAGE Binding System is a flexible and powerful approach to handling user input in your games. It creates an abstraction layer between physical input devices (keyboard, mouse, gamepad) and the game actions they trigger, making your code more modular and easier to maintain.
+
+## Core Concepts
+
+### Actions
+
+Actions are the "what" in your game's input system - they represent game events that can be triggered by user input. Actions are divided into two types:
+
+- **Digital Actions**: Boolean (on/off) values, like jumping or interacting
+- **Analog Actions**: Numeric values (typically ranging from -1 to 1 or 0 to 1), like throttle control or camera rotation
+
+Actions are defined by a name and type, and analog actions can optionally specify minimum and maximum values:
+
+```typescript
+// Digital action example
+{
+  name: 'jump',
+  type: 'digital'
+}
+
+// Analog action example
+{
+  name: 'throttle',
+  type: 'analog',
+  minValue: 0,  // No throttle
+  maxValue: 1   // Full throttle
+}
+```
+
+### Bindings
+
+Bindings are the "how" in your input system - they connect physical inputs to actions. SAGE supports multiple binding types that process input differently:
+
+- **Trigger Bindings**: Fire once when a button is pressed or released
+- **Toggle Bindings**: Toggle between on/off states each time a button is pressed (like crouch)
+- **Value Bindings**: Continuously translate input values (like joystick position) to action values
+
+Each binding connects a specific input from a device (like a keyboard key or gamepad button) to an action, with options to customize how the input translates to the action.
+
+### Contexts
+
+Contexts allow you to organize bindings into groups that can be activated or deactivated together. This is particularly useful for handling different input modes, such as:
+
+- Gameplay controls
+- Menu navigation
+- Vehicle controls
+- Dialog interactions
+
+Contexts can be exclusive (only one active at a time) or non-exclusive (multiple can be active simultaneously).
+
+## Basic Setup
+
+### Initializing the Binding System
+
+The binding system relies on the SAGE event bus and works alongside the input manager:
+
+```typescript
+import { GameEventBus } from './src/classes/eventBus.ts';
+import { BindingManager } from './src/managers/binding.ts';
+
+// Create event bus and binding manager
+const eventBus = new GameEventBus();
+const bindingManager = new BindingManager(eventBus);
+```
+
+### Registering Actions
+
+Before you can create bindings, you need to register the actions they will trigger:
+
+```typescript
+// Register a digital action
+bindingManager.registerAction({
+  name: 'quit',
+  type: 'digital'
+});
+
+// Register an analog action
+bindingManager.registerAction({
+  name: 'throttle',
+  type: 'analog',
+  minValue: 0,  // No throttle
+  maxValue: 1   // Full throttle
+});
+```
+
+### Creating and Registering Bindings
+
+Here's how to create a binding that triggers the "quit" action when the Escape key is pressed:
+
+```typescript
+import { KeyboardValueReader } from './src/classes/input/readers/keyboard.ts';
+import { TriggerBinding } from './src/classes/bindings/trigger.ts';
+
+// Create a trigger binding for the Escape key
+const quitBinding = new TriggerBinding(
+  { name: 'quit', type: 'digital' },  // The action
+  'keyboard-main',                    // Device ID
+  new KeyboardValueReader('Escape'),  // Input source
+  { edgeMode: 'rising' }              // Options (trigger on key press)
+);
+
+// Register the binding
+bindingManager.registerBinding(quitBinding);
+```
+
+### Using Binding Definitions
+
+You can also create bindings using definitions, which is useful for creating bindings programmatically or from configuration:
+
+```typescript
+// Define a binding definition object
+const jumpBindingDefinition = {
+  type: 'trigger',
+  action: 'jump',                     // Action name as a string
+  deviceID: 'keyboard-main',
+  reader: {
+    type: 'keyboard',
+    sourceType: 'key',
+    sourceKey: 'Space'
+  },
+  options: {
+    edgeMode: 'rising'
+  }
+};
+
+// Register the binding from the definition
+bindingManager.registerBindingFromDefinition(jumpBindingDefinition);
+```
+
+### Handling Actions
+
+Once actions and bindings are set up, you listen for action events on the event bus:
+
+```typescript
+// Subscribe to the quit action
+eventBus.subscribe('action:quit', (event) => {
+  console.log('Quit action triggered!');
+  game.quit();
+});
+```
+
+## Binding Types in Detail
+
+### Trigger Binding
+
+The trigger binding fires a one-time event when a button state changes:
+
+```typescript
+// Create a trigger binding for the Space key to jump
+const jumpBinding = new TriggerBinding(
+  { name: 'jump', type: 'digital' },
+  'keyboard-main',
+  new KeyboardValueReader('Space'),
+  { 
+    edgeMode: 'rising',  // 'rising' = when pressed, 'falling' = when released
+    threshold: 0.5       // For analog inputs, the activation threshold
+  }
+);
+```
+
+### Toggle Binding
+
+The toggle binding switches between on and off states with each activation:
+
+```typescript
+// Create a toggle binding for the C key to toggle crouch
+const crouchBinding = new ToggleBinding(
+  { name: 'crouch', type: 'digital' },
+  'keyboard-main',
+  new KeyboardValueReader('KeyC'),
+  {
+    initialState: false,  // Start in "off" state
+    onValue: true,        // Value when toggled on
+    offValue: false       // Value when toggled off
+  }
+);
+```
+
+### Value Binding
+
+The value binding continuously passes input values to an action:
+
+```typescript
+// Create a value binding for the right trigger for throttle control
+const throttleBinding = new ValueBinding(
+  { name: 'throttle', type: 'analog', minValue: 0, maxValue: 1 },
+  'gamepad-0',
+  new GamepadValueReader('button', '7'),  // Right trigger
+  {
+    scale: 1.0,       // Full value when pressed
+    deadzone: 0.05,   // Ignore small values
+    emitOnChange: true // Only emit when value changes
+  }
+);
+```
+
+## Working with Contexts
+
+### Registering Contexts
+
+```typescript
+// Register contexts for different game states
+bindingManager.registerContext('gameplay', true);  // true = exclusive
+bindingManager.registerContext('menu', true);      // also exclusive
+bindingManager.registerContext('always', false);   // false = non-exclusive
+```
+
+### Assigning Bindings to Contexts
+
+When creating bindings, you can specify their context:
+
+```typescript
+// Create a binding that only works in the gameplay context
+const jumpBinding = new TriggerBinding(
+  { name: 'jump', type: 'digital' },
+  'keyboard-main',
+  new KeyboardValueReader('Space'),
+  { 
+    context: 'gameplay',
+    edgeMode: 'rising'
+  }
+);
+```
+
+### Activating and Deactivating Contexts
+
+```typescript
+// Start in gameplay mode
+bindingManager.activateContext('gameplay');
+
+// When opening a menu, switch to menu mode
+bindingManager.activateContext('menu');  // This automatically deactivates 'gameplay' since both are exclusive
+
+// Return to gameplay
+bindingManager.activateContext('gameplay');
+
+// Deactivate a specific context
+bindingManager.deactivateContext('menu');
+```
+
+## Implementing Character Movement with WASD Controls
+
+Here's a complete example of implementing WASD movement controls using digital actions:
+
+```typescript
+// 1. Register movement actions (using digital actions for directional movement)
+bindingManager.registerAction({
+  name: 'move_forward',
+  type: 'digital'
+});
+
+bindingManager.registerAction({
+  name: 'move_backward',
+  type: 'digital'
+});
+
+bindingManager.registerAction({
+  name: 'move_left',
+  type: 'digital'
+});
+
+bindingManager.registerAction({
+  name: 'move_right',
+  type: 'digital'
+});
+
+// 2. Create WASD keyboard bindings using trigger bindings
+// Trigger bindings fire once when pressed/released, which is appropriate for digital actions
+const wBinding = new TriggerBinding(
+  bindingManager.getAction('move_forward'),
+  'keyboard-main',
+  new KeyboardValueReader('KeyW'),
+  { edgeMode: 'both' }  // Fire on both press and release
+);
+
+const sBinding = new TriggerBinding(
+  bindingManager.getAction('move_backward'),
+  'keyboard-main',
+  new KeyboardValueReader('KeyS'),
+  { edgeMode: 'both' }
+);
+
+const aBinding = new TriggerBinding(
+  bindingManager.getAction('move_left'),
+  'keyboard-main',
+  new KeyboardValueReader('KeyA'),
+  { edgeMode: 'both' }
+);
+
+const dBinding = new TriggerBinding(
+  bindingManager.getAction('move_right'),
+  'keyboard-main',
+  new KeyboardValueReader('KeyD'),
+  { edgeMode: 'both' }
+);
+
+// 3. Register all bindings
+bindingManager.registerBinding(wBinding);
+bindingManager.registerBinding(sBinding);
+bindingManager.registerBinding(aBinding);
+bindingManager.registerBinding(dBinding);
+
+// 4. Handle the movement actions
+eventBus.subscribe('action:move_forward', (event) => {
+  // True when key is pressed, false when released
+  if (event.payload.value === true) {
+    player.velocity.z = -player.speed; // Move forward (negative Z in many 3D systems)
+  } else {
+    // Only zero out velocity if player isn't also moving backward
+    if (!player.isMovingBackward) {
+      player.velocity.z = 0;
+    }
+  }
+});
+
+// Similar handlers for the other actions
+// ...existing code...
+```
+
+### Alternative: Using Binding Definitions for WASD Controls
+
+You can also set up WASD controls using binding definitions, which is more concise:
+
+```typescript
+// Define all actions at once
+const movementActions = [
+  { name: 'move_forward', type: 'digital' },
+  { name: 'move_backward', type: 'digital' },
+  { name: 'move_left', type: 'digital' },
+  { name: 'move_right', type: 'digital' }
+];
+
+// Register all actions
+movementActions.forEach(action => bindingManager.registerAction(action));
+
+// Define all bindings at once using binding definitions
+const wasdBindings = [
+  {
+    type: 'trigger',  // Use trigger binding for digital actions
+    action: 'move_forward', 
+    deviceID: 'keyboard-main',
+    reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyW' },
+    options: { edgeMode: 'both' }  // Fire on both press and release
+  },
+  {
+    type: 'trigger',
+    action: 'move_backward',
+    deviceID: 'keyboard-main',
+    reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyS' },
+    options: { edgeMode: 'both' }
+  },
+  {
+    type: 'trigger',
+    action: 'move_left',
+    deviceID: 'keyboard-main',
+    reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyA' },
+    options: { edgeMode: 'both' }
+  },
+  {
+    type: 'trigger',
+    action: 'move_right',
+    deviceID: 'keyboard-main',
+    reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyD' },
+    options: { edgeMode: 'both' }
+  }
+];
+
+// Register all bindings in one go
+wasdBindings.forEach(binding => bindingManager.registerBinding(binding));
+```
+
+## Integration with Entity System
+
+The entity system in SAGE allows you to define required actions at the entity level, creating a clean way to associate input controls with specific game objects.
+
+### Defining Entity Actions
+
+When defining an entity, you can specify the actions it requires:
+
+```typescript
+import { GameEntityDefinition } from './src/interfaces/entity.ts';
+
+// Define a player entity with movement behaviors
+const playerEntityDefinition: GameEntityDefinition = {
+  type: 'player',
+  defaultState: {
+    position: { x: 0, y: 0, z: 0 },
+    velocity: { x: 0, y: 0, z: 0 },
+    speed: 5,
+    isMovingForward: false,
+    isMovingBackward: false,
+    isMovingLeft: false,
+    isMovingRight: false
+  },
+  behaviors: [
+    PlayerMovementBehavior,
+    PlayerAnimationBehavior
+  ],
+  // Define actions needed by this entity (digital actions for directional movement)
+  actions: [
+    { name: 'move_forward', type: 'digital' },
+    { name: 'move_backward', type: 'digital' },
+    { name: 'move_left', type: 'digital' },
+    { name: 'move_right', type: 'digital' },
+    { name: 'jump', type: 'digital' }
+  ]
+};
+```
+
+### Creating Player Movement Behavior
+
+The entity system works with behaviors that respond to action events:
+
+```typescript
+import { GameEntityBehavior } from './src/classes/entity.ts';
+
+class PlayerMovementBehavior extends GameEntityBehavior<{
+  position: { x: number, y: number, z: number },
+  velocity: { x: number, y: number, z: number },
+  speed: number,
+  isMovingForward: boolean,
+  isMovingBackward: boolean,
+  isMovingLeft: boolean,
+  isMovingRight: boolean
+}> {
+  initialize(entity) {
+    // Subscribe to movement actions
+    this.eventBus.subscribe('action:move_forward', (event) => {
+      const isActive = event.payload.value === true;
+      entity.state.isMovingForward = isActive;
+      
+      if (isActive) {
+        entity.state.velocity.z = -entity.state.speed;
+      } else if (!entity.state.isMovingBackward) {
+        entity.state.velocity.z = 0;
+      }
+    });
+    
+    this.eventBus.subscribe('action:move_backward', (event) => {
+      const isActive = event.payload.value === true;
+      entity.state.isMovingBackward = isActive;
+      
+      if (isActive) {
+        entity.state.velocity.z = entity.state.speed;
+      } else if (!entity.state.isMovingForward) {
+        entity.state.velocity.z = 0;
+      }
+    });
+    
+    this.eventBus.subscribe('action:move_left', (event) => {
+      const isActive = event.payload.value === true;
+      entity.state.isMovingLeft = isActive;
+      
+      if (isActive) {
+        entity.state.velocity.x = -entity.state.speed;
+      } else if (!entity.state.isMovingRight) {
+        entity.state.velocity.x = 0;
+      }
+    });
+    
+    this.eventBus.subscribe('action:move_right', (event) => {
+      const isActive = event.payload.value === true;
+      entity.state.isMovingRight = isActive;
+      
+      if (isActive) {
+        entity.state.velocity.x = entity.state.speed;
+      } else if (!entity.state.isMovingLeft) {
+        entity.state.velocity.x = 0;
+      }
+    });
+    
+    this.eventBus.subscribe('action:jump', () => {
+      // Implement jump logic
+      if (entity.state.onGround) {
+        entity.state.velocity.y = entity.state.jumpForce;
+      }
+    });
+  }
+  
+  update(entity, deltaTime) {
+    // Apply velocity to position
+    entity.state.position.x += entity.state.velocity.x * deltaTime;
+    entity.state.position.y += entity.state.velocity.y * deltaTime;
+    entity.state.position.z += entity.state.velocity.z * deltaTime;
+    
+    // Apply physics like gravity, friction, etc.
+  }
+}
+```
+
+## Saving and Loading Bindings
+
+The binding system provides methods to export and import configurations, allowing for customizable controls that persist between game sessions.
+
+### Exporting Configuration
+
+```typescript
+// Get current configuration as a serializable object
+const savedConfig = bindingManager.exportConfiguration();
+
+// You can now save this object however you prefer
+localStorage.setItem('gameControls', JSON.stringify(savedConfig));
+// or
+saveToFile('controls.json', JSON.stringify(savedConfig));
+// or
+await api.saveUserPreferences(savedConfig);
+```
+
+### Importing Configuration
+
+```typescript
+// Load the configuration from your storage
+const loadedConfig = JSON.parse(localStorage.getItem('gameControls'));
+
+// Apply the configuration to the binding manager
+bindingManager.importConfiguration(loadedConfig);
+```
+
+### Complete Example: Saving and Loading Controls
+
+Here's a complete example of how to implement customizable controls with saving/loading:
+
+```typescript
+class GameControlsManager {
+  private bindingManager: BindingManager;
+  
+  constructor(eventBus: GameEventBus) {
+    this.bindingManager = new BindingManager(eventBus);
+    this.setupDefaultControls();
+  }
+  
+  // Set up default control scheme
+  setupDefaultControls() {
+    // Register default actions
+    const defaultActions = [
+      { name: 'move_forward', type: 'digital' },
+      { name: 'move_backward', type: 'digital' },
+      { name: 'move_left', type: 'digital' },
+      { name: 'move_right', type: 'digital' },
+      { name: 'jump', type: 'digital' },
+      { name: 'interact', type: 'digital' },
+      { name: 'pause', type: 'digital' }
+    ];
+    
+    // Register all default actions
+    defaultActions.forEach(action => this.bindingManager.registerAction(action));
+    
+    // Create contexts
+    this.bindingManager.registerContext('gameplay', true);
+    this.bindingManager.registerContext('menu', true);
+    
+    // Define default bindings
+    const defaultBindings = [
+      // Movement - WASD
+      {
+        type: 'value',
+        action: 'move_forward',
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyW' },
+        context: 'gameplay',
+        options: { onValue: true, offValue: false }
+      },
+      {
+        type: 'value',
+        action: 'move_backward',
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyS' },
+        context: 'gameplay',
+        options: { onValue: true, offValue: false }
+      },
+      {
+        type: 'value',
+        action: 'move_left',
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyA' },
+        context: 'gameplay',
+        options: { onValue: true, offValue: false }
+      },
+      {
+        type: 'value',
+        action: 'move_right',
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyD' },
+        context: 'gameplay',
+        options: { onValue: true, offValue: false }
+      },
+      // Jump - Space
+      {
+        type: 'trigger',
+        action: 'jump',
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'Space' },
+        context: 'gameplay',
+        options: { edgeMode: 'rising' }
+      },
+      // Interact - E
+      {
+        type: 'trigger',
+        action: 'interact',
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'KeyE' },
+        context: 'gameplay',
+        options: { edgeMode: 'rising' }
+      },
+      // Pause - Escape (works in both gameplay and menu contexts)
+      {
+        type: 'trigger',
+        action: 'pause', 
+        deviceID: 'keyboard-main',
+        reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'Escape' },
+        options: { edgeMode: 'rising' }
+      }
+    ];
+    
+    // Register all default bindings
+    defaultBindings.forEach(binding => this.bindingManager.registerBindingFromDefinition(binding));
+    
+    // Start in gameplay context
+    this.bindingManager.activateContext('gameplay');
+  }
+  
+  // Load control configuration from storage
+  loadControls() {
+    try {
+      const savedConfig = localStorage.getItem('gameControls');
+      if (savedConfig) {
+        const config = JSON.parse(savedConfig);
+        this.bindingManager.importConfiguration(config);
+        console.log('Custom controls loaded successfully');
+        return true;
+      }
+    } catch (err) {
+      console.error('Failed to load custom controls:', err);
+    }
+    return false;
+  }
+  
+  // Save current control configuration to storage
+  saveControls() {
+    try {
+      const config = this.bindingManager.exportConfiguration();
+      localStorage.setItem('gameControls', JSON.stringify(config));
+      console.log('Controls saved successfully');
+      return true;
+    } catch (err) {
+      console.error('Failed to save controls:', err);
+      return false;
+    }
+  }
+  
+  // Reset to default controls
+  resetToDefaults() {
+    // Clear existing bindings and re-setup defaults
+    localStorage.removeItem('gameControls');
+    // Re-initialize binding manager
+    this.bindingManager.importConfiguration({
+      actions: [],
+      bindings: [],
+      contexts: []
+    });
+    this.setupDefaultControls();
+  }
+  
+  // Rebind a specific action to a new key
+  rebindAction(actionName: string, newKey: string, context?: string) {
+    // Remove existing bindings for this action in this context
+    this.bindingManager.unregisterBindings(actionName, context || null);
+    
+    // Create new binding
+    const action = this.bindingManager.getAction(actionName);
+    if (!action) {
+      console.error(`Cannot rebind: action "${actionName}" not found`);
+      return false;
+    }
+    
+    // Create and register the new binding
+    const bindingDef = {
+      type: action.type === 'digital' ? 'value' : 'value',
+      action,
+      deviceID: 'keyboard-main',
+      reader: {
+        type: 'keyboard',
+        sourceType: 'key',
+        sourceKey: newKey
+      },
+      context,
+      options: action.type === 'digital' 
+        ? { onValue: true, offValue: false } 
+        : {}
+    };
+    
+    this.bindingManager.registerBindingFromDefinition(bindingDef);
+    return true;
+  }
+  
+  // Get the binding manager for direct access if needed
+  getBindingManager() {
+    return this.bindingManager;
+  }
+}
+
+// Usage:
+const controls = new GameControlsManager(eventBus);
+
+// On game startup, try to load saved controls or fall back to defaults
+if (!controls.loadControls()) {
+  console.log('No saved controls found, using defaults');
+}
+
+// When user changes a keybinding in settings menu
+controls.rebindAction('jump', 'KeyF', 'gameplay');
+controls.saveControls();
+
+// When user wants to reset all controls
+controls.resetToDefaults();
+```
+
+### Storage Considerations
+
+The binding system is deliberately agnostic about how you store configurations. It simply provides methods to convert the binding state to and from plain JavaScript objects. This gives you the flexibility to:
+
+- Save to browser storage like localStorage
+- Save to files on disk
+- Store in databases
+- Sync with cloud services
+- Embed in user profiles
+
+## Advanced Usage: Multiple Input Methods
+
+One of the strengths of the binding system is support for multiple input devices. Here's how to set up the same action with different input methods:
+
+```typescript
+// Jump action with keyboard
+const keyboardJump = new TriggerBinding(
+  { name: 'jump', type: 'digital' },
+  'keyboard-main',
+  new KeyboardValueReader('Space')
+);
+
+// Jump action with gamepad
+const gamepadJump = new TriggerBinding(
+  { name: 'jump', type: 'digital' },
+  'gamepad-0',
+  new GamepadValueReader('button', '0')  // A/Cross button
+);
+
+// Movement with gamepad analog stick (using digital actions for clarity)
+// Map left stick up to move_forward action
+const gamepadMoveForward = new ValueBinding(
+  { name: 'move_forward', type: 'digital' },
+  'gamepad-0',
+  new GamepadValueReader('axis', '1'),  // Left stick Y-axis
+  { 
+    deadzone: 0.2,       // Prevent drift
+    threshold: -0.5,     // Activate when stick pushed upward (negative Y)
+    invert: true         // Invert because pushing up gives negative values
+  }
+);
+
+// Map left stick down to move_backward action
+const gamepadMoveBackward = new ValueBinding(
+  { name: 'move_backward', type: 'digital' },
+  'gamepad-0',
+  new GamepadValueReader('axis', '1'),  // Left stick Y-axis
+  { 
+    deadzone: 0.2,       // Prevent drift
+    threshold: 0.5       // Activate when stick pushed downward (positive Y)
+  }
+);
+
+// Register all bindings
+bindingManager.registerBinding(keyboardJump);
+bindingManager.registerBinding(gamepadJump);
+bindingManager.registerBinding(gamepadMoveForward);
+bindingManager.registerBinding(gamepadMoveBackward);
+```
+
+### Supporting Multiple Input Devices with Binding Definitions
+
+Using binding definitions makes it easier to support multiple input methods:
+
+```typescript
+// Define action once
+bindingManager.registerAction({ name: 'jump', type: 'digital' });
+
+// Define bindings for multiple devices
+const jumpBindings = [
+  {
+    // Keyboard binding
+    type: 'trigger',
+    action: 'jump', // Action name as a string
+    deviceID: 'keyboard-main',
+    reader: { type: 'keyboard', sourceType: 'key', sourceKey: 'Space' },
+    context: 'gameplay'
+  },
+  {
+    // Gamepad A button binding
+    type: 'trigger',
+    action: 'jump', // Action name as a string
+    deviceID: 'gamepad-0',
+    reader: { type: 'gamepad', sourceType: 'button', sourceKey: '0' },
+    context: 'gameplay'
+  },
+  {
+    // Mouse left button binding
+    type: 'trigger',
+    action: 'jump', // Action name as a string
+    deviceID: 'mouse-main',
+    reader: { type: 'mouse', sourceType: 'button', sourceKey: '0' },
+    context: 'gameplay'
+  }
+];
+
+// Register all bindings
+jumpBindings.forEach(binding => bindingManager.registerBindingFromDefinition(binding));
+```