Authoritative Username

The authoritative-username capability lets a provider control the stored Identica username for an account. When that provider reports a different username and the account is not protected by capability-owned manual authority state, Identica updates the stored username to match it.

Conflicts

This capability contributes the built-in username conflict type. The generic conflicts configuration page documents the shared rule structure. This section documents the capability-specific selector and resolver behavior for conflicts.username.

A username conflict happens when a provider with this capability wants to apply a username that is already used by another active account. If no active conflicting account is found, normal username synchronization continues without conflict resolution.

Before resolvers run, the capability also applies an entrypoint guard. When the incoming account and the active conflicting account belong to different providers and both providers expose entrypoints, Identica requires that collision to be handled from a provider entrypoint flow. If the flow did not come from an entrypoint, the conflict is denied with the capability's entrypointRequired message.

Example situation

With the generated default conflict rules:

An active credential account is already using Steve.
A premium account with this capability joins and also reports Steve.
Identica detects a username conflict before applying the update.
The premium + credential case rule runs first.
That default case formats the incoming side as {username}_{incomingProvider}.
In simple terms, the joining side gets a name like Steve_Premium.

For other provider combinations that do not match a specific case rule, the generated default rule appends * to the incoming side instead, such as Steve*.

The selector field below decides when a case rule applies.

conflicts.username.cases[].when.providers

Takes: a list of provider ids
Affects: which provider combination a case rule applies to

The rule matches when both provider ids are present in the conflict context, regardless of their order in the list. Most rules should contain exactly two provider ids such as premium and credential.

The resolver fields below configure the built-in format_display resolver for conflicts.username.

Takes: a string
Affects: the formatted username override produced by format_display

Supported placeholders:

{username} or {requested}
{incomingProvider} and {existingProvider}
{incomingProviderId} and {existingProviderId}
{random} or {random:4}

Provider display-name placeholders support optional truncation with :maxSymbolCount.

Examples:

{incomingProvider}
{incomingProvider:8}
{existingProvider:6}
{username}_{incomingProvider:8}_{random:3}

Only {incomingProvider} and {existingProvider} support truncation.

conflicts.username.default.resolvers[].parameters.format.uppercase

conflicts.username.cases[].resolvers[].parameters.format.uppercase

Takes: true or false
Current default: false
Affects: whether the full formatted result is converted to uppercase

conflicts.username.default.resolvers[].parameters.format.lowercase

conflicts.username.cases[].resolvers[].parameters.format.lowercase

Takes: true or false
Current default: false
Affects: whether the full formatted result is converted to lowercase

Avoid enabling both uppercase and lowercase at the same time.

conflicts.username.default.resolvers[].parameters.target

conflicts.username.cases[].resolvers[].parameters.target

Takes: "joiner", "existing", or "both"
Current default: "joiner"
Affects: which side receives the formatted override value

joiner means the incoming account side.

Pattern with provider-name truncation:

resolvers:
  - id: "format_display"
    parameters:
      format:
        pattern: "{username}_{incomingProvider:8}"
      target: "joiner"

{
  "resolvers": [
    {
      "id": "format_display",
      "parameters": {
        "format": {
          "pattern": "{username}_{incomingProvider:8}"
        },
        "target": "joiner"
      }
    }
  ]
}

Pattern with full-result uppercase formatting:

resolvers:
  - id: "format_display"
    parameters:
      format:
        pattern: "{username}_{incomingProvider}"
        uppercase: true
      target: "joiner"

{
  "resolvers": [
    {
      "id": "format_display",
      "parameters": {
        "format": {
          "pattern": "{username}_{incomingProvider}",
          "uppercase": true
        },
        "target": "joiner"
      }
    }
  ]
}

Pattern applied to both sides:

resolvers:
  - id: "format_display"
    parameters:
      format:
        pattern: "{username}_{random:3}"
      target: "both"

{
  "resolvers": [
    {
      "id": "format_display",
      "parameters": {
        "format": {
          "pattern": "{username}_{random:3}"
        },
        "target": "both"
      }
    }
  ]
}