# AUR0157

## Warning Message

`AUR0157: Binding command <command-name> has already been registered.`

Where `<command-name>` is the name of the binding command (e.g., `trigger`, `for`, `bind`) that was attempted to be registered again.

## Description

This warning indicates that an attempt was made to register a binding command with a specific name, but another binding command with the same name was already registered in the application's configuration. Binding commands define how specific binding syntaxes (like `.bind`, `.trigger`, `.for`) are processed by the template compiler. Each command name must be unique.

**Note:** This is typically logged as a warning. The application might continue, but only the first registration for the given command name will be effective. Overwriting built-in commands or duplicating custom commands can lead to unpredictable compilation and runtime binding behavior.

## Cause

1. **Duplicate Custom Command Registration:** Calling `Aurelia.register()` or a similar registration method multiple times with the same custom binding command class or different classes using the same command name via the `@bindingCommand` decorator or configuration object.
2. **Attempting to Overwrite Built-in Commands:** Defining a custom binding command with a name that conflicts with a standard Aurelia command (e.g., `bind`, `trigger`, `for`, `one-time`, `to-view`, `from-view`, `two-way`, `capture`). While possible, this is generally discouraged unless you fully understand the implications.
3. **Naming Collision:** Accidentally defining two different custom binding command classes that use the same command name.

## Solution

1. **Ensure Unique Names:** Choose a unique name for each custom binding command. Avoid using names of built-in commands unless intentionally replacing core functionality (use with caution).
2. **Register Once:** Ensure each binding command (especially custom ones) is registered only once. Review your application's registration configuration, typically in `main.ts` or where `Aurelia.register(...)` is called with binding command configurations.
3. **Refactor/Rename:** If you have two distinct custom commands that ended up with the same name, rename one of them.

## Example

```typescript
// my-custom-command.ts
import { bindingCommand, type BindingCommandInstance, type BindingInfo, type ExpressionParser, type IAttrMapper, type BindingInstruction, PropertyBindingInstruction } from 'aurelia';

// Correct: Defining a custom command
@bindingCommand('my-cmd')
export class MyCustomBindingCommand implements BindingCommandInstance {
  public readonly type = 'bind'; // Or other valid type
  build(info: BindingInfo, parser: ExpressionParser, mapper: IAttrMapper): BindingInstruction {
    // Command logic...
    // Example: return new PropertyBindingInstruction(info.expr, info.attr.target);
    return null! // Placeholder
  }
}

// another-command.ts - Incorrect: Uses the same name
import { bindingCommand, type BindingCommandInstance } from 'aurelia';
@bindingCommand('my-cmd') // Causes AUR0157 if both are registered
export class AnotherCustomBindingCommand implements BindingCommandInstance {
  // ... command logic ...
  public readonly type = 'bind';
  build(info: BindingInfo, parser: ExpressionParser, mapper: IAttrMapper): BindingInstruction { return null!; }
}

// trigger-command-override.ts - Discouraged: Overwriting built-in
import { bindingCommand, type BindingCommandInstance } from 'aurelia';
@bindingCommand('trigger') // Causes AUR0157, overwrites standard .trigger
export class TriggerOverrideCommand implements BindingCommandInstance {
  // ... command logic ...
  public readonly type = 'trigger';
  build(info: BindingInfo, parser: ExpressionParser, mapper: IAttrMapper): BindingInstruction { return null!; }
}


// --- main.ts ---
import { Aurelia, BindingCommand } from 'aurelia';
import { MyCustomBindingCommand } from './my-custom-command';
import { AnotherCustomBindingCommand } from './another-command';
// import { TriggerOverrideCommand } from './trigger-command-override';

// Incorrect: Attempting to register two commands with the same name 'my-cmd'
// Aurelia.register(
//   BindingCommand.define('my-cmd', MyCustomBindingCommand),
//   BindingCommand.define('my-cmd', AnotherCustomBindingCommand)
// ) /* ... */;

// Correct: Register only one command for the name 'my-cmd'
Aurelia.register(
  BindingCommand.define('my-cmd', MyCustomBindingCommand)
) /* ... */;

// Discouraged: Overwriting trigger (will log AUR0157)
// Aurelia.register(
//   BindingCommand.define('trigger', TriggerOverrideCommand)
// ) /* ... */;

```

## Debugging Tips

* Search your project for `@bindingCommand('<command-name>')` or `BindingCommand.define('<command-name>', ...)` usages for the command name mentioned in the warning.
* Review your main configuration/registration file (`main.ts` or similar) to ensure commands are registered only once.
* Compare your custom command names against the list of built-in Aurelia binding commands to avoid unintentional conflicts.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.aurelia.io/developer-guides/error-messages/runtime-html/aur0157.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.