Discord Player

PluginRegistry

Context-owned capability registry. Removal aborts and drains calls before teardown.

You are reading the v8 docsDev
ClassTypeScript@discord-player/plugin-host
View sourcepackages/plugin-host/src/plugins/registry.ts:30
class PluginRegistry

Context-owned capability registry. Removal aborts and drains calls before teardown.

Constructors

constructor

constructor(
  player: LegacyPlayerContext,
  blocked: () => readonly string[] = ...,
  hostId?: string,
)

Create an independent host.

Parameters

NameTypeDescription
playerLegacyPlayerContext

Structural source context.

blocked() => readonly string[]Default: ...

Default disabled source IDs supplied by the owning Player.

hostId?string

Owning deployment, absent in ordinary embedded execution.

Properties

playerreadonly

readonly player: LegacyPlayerContext

Structural source context.

Methods

defineProvider

defineProvider<K extends "playback.backend">(name: K): void

Enable a local singleton capability before setup. Source hosts do not enable playback providers.

Parameters

NameTypeDescription
nameK

Provider capability name.

Returns

void

providerSignal

providerSignal<K extends "playback.backend">(name: K): AbortSignal | undefined

Read the selected provider registration lifetime.

Parameters

NameTypeDescription
nameK

Provider capability name.

Returns

AbortSignal | undefined

Registration cancellation signal, absent for the default implementation.

selectProvider

selectProvider<K extends "playback.backend">(
  name: K,
  dispose: () => Promise<void>,
): ProviderMap[K] | undefined

Select and seal a provider before resource initialization. Later replacement registrations fail.

Parameters

NameTypeDescription
nameK

Provider capability name.

dispose() => Promise<void>

Release owned framework resources before plugin teardown.

Returns

ProviderMap[K] | undefined

The active implementation, or undefined for the framework default.

defineOperation

defineOperation<K extends keyof OperationMap>(
  name: K,
  policy: OperationMap[K]["policy"],
  synchronous: boolean = false,
): void

Define a declaration-merged operation before registering handlers.

Parameters

NameTypeDescription
nameK

Operation name.

policyOperationMap[K]["policy"]

Dispatch policy matching its contract.

synchronousbooleanDefault: false

Whether callbacks must complete before returning; required for interception.

Returns

void

has

has(id: string, hostId?: string): boolean

Whether an ID is reserved or active.

Parameters

NameTypeDescription
idstring

Plugin ID.

hostId?string

Optional deployment constraint.

Returns

boolean

providers

providers(operation: keyof OperationMap): ProviderReference[]

List active provider/deployment references in priority and registration order.

Parameters

NameTypeDescription
operationkeyof OperationMap

Capability to inspect.

Returns

ProviderReference[]

Unique eligible provider/deployment references.

hasHost

hasHost(hostId: string): boolean

Check whether a deployment has an owned registration.

Parameters

NameTypeDescription
hostIdstring

Deployment identity.

Returns

boolean

describe

describe(
): {
  id: string;
  provides: "playback.backend"[];
  operations: (keyof OperationMap)[];
  protocols: string[];
  priorities: {
    [k: string]: number;
  };
  subscriptions: {
    operation: keyof OperationMap;
    priority: number;
    guildIds: readonly string[] | undefined;
    order: number;
  }[];
}[]

Advertise only active local operation handlers and supplied provider capabilities.

Returns

{
id: string;
provides: "playback.backend"[];
operations: (keyof OperationMap)[];
protocols: string[];
priorities: {
[k: string]: number;
};
subscriptions: {
operation: keyof OperationMap;
priority: number;
guildIds: readonly string[] | undefined;
order: number;
}[];
}[]

Serializable provider capability descriptions.

registerHost

registerHost(host: RemotePluginHostOptions, signal: AbortSignal = ...): Promise<void>

Register all advertised providers from an existing HTTP deployment.

Parameters

NameTypeDescription
hostRemotePluginHostOptions

Existing deployment and authentication.

signalAbortSignalDefault: ...

Caller lifetime.

Returns

Promise<void>

supportsProtocol

supportsProtocol(protocol: string, options: ExecuteOptions = {}): boolean

Whether an active matching handler explicitly accepts a protocol.

Parameters

NameTypeDescription
protocolstring

Query prefix without punctuation.

optionsExecuteOptionsDefault: {}

Source targeting and block list.

Returns

boolean

protocolMatches

protocolMatches(
  protocol: string,
  options: ExecuteOptions = {},
): {
  pluginId: string;
  hostId: string | undefined;
  score: number;
}[]

Ordered owners of a custom query protocol.

Parameters

NameTypeDescription
protocolstring

Registered protocol prefix.

optionsExecuteOptionsDefault: {}

Targeting and block list.

Returns

{
pluginId: string;
hostId: string | undefined;
score: number;
}[]

Eligible provider identities, in dispatch order.

register

register<O>(registration: PluginRegistration<O>): Promise<void>

Register and initialize a source descriptor, reserving its ID synchronously.

Parameters

NameTypeDescription
registrationPluginRegistration<O>

Descriptor produced by definePlugin.

Returns

Promise<void>

unregister

unregister(id: string, hostId?: string): Promise<boolean>

Abort new and active work, drain handlers, and release resources. Handlers must cooperate with cancellation.

Parameters

NameTypeDescription
idstring

Plugin ID.

hostId?string

Optional deployment identity when the provider exists on multiple hosts.

Returns

Promise<boolean>

Whether the registration existed.

ready

ready(): Promise<void>

Initialize pending registrations before dispatch.

Returns

Promise<void>

destroy

destroy(): Promise<void>

Destroy all registrations, attempting every cleanup even when one fails.

Returns

Promise<void>

hasCapability

hasCapability(operation: keyof OperationMap): boolean

Whether an operation has active subscribers. Does not scan unrelated registrations.

Parameters

NameTypeDescription
operationkeyof OperationMap

Capability name.

Returns

boolean

Whether at least one active handler exists.

assertNotDispatching

assertNotDispatching(): void

Reject reentrant application operations from synchronous capability handlers.

Returns

void

executeSync

executeSync<K extends keyof OperationMap>(
  operation: K,
  input: OperationInput<K>,
  options: ExecuteOptions = {},
): OperationResult<K>

Dispatch a synchronous local capability without scheduling promises.

Parameters

NameTypeDescription
operationK

Capability defined with synchronous execution.

inputOperationInput<K>

Validated operation payload.

optionsExecuteOptionsDefault: {}

Scope and cancellation constraints.

Returns

OperationResult<K>

The selected result, or transformed input for pipe operations.

execute

execute<K extends keyof OperationMap>(
  operation: K,
  input: OperationInput<K>,
  options: ExecuteOptions = {},
): Promise<OperationResult<K>>

Execute using the operation's declared policy. Genuine failures reject immediately.

Parameters

NameTypeDescription
operationK

Typed operation name.

inputOperationInput<K>

Operation payload.

optionsExecuteOptionsDefault: {}

Target, block list and cancellation.

Returns

Promise<OperationResult<K>>

Result inferred from the operation policy.

serialize

serialize(
  entity: Playlist | Track<unknown>,
  options: ExecuteOptions = {},
): Promise<SerializedEntityUnion>

Serialize using modern application-metadata transformations. Plain model serialization remains synchronous.

Parameters

NameTypeDescription
entityPlaylist | Track<unknown>

Track or playlist to persist.

optionsExecuteOptionsDefault: {}

Cancellation and provider scope.

Returns

Promise<SerializedEntityUnion>

A validated JSON persistence payload, without playback grants or live streams.

restore

restore(
  payload: unknown,
  options: ExecuteOptions = {},
): Promise<Playlist | Track<unknown>>

Restore through modern metadata transformations and the existing schema validator.

Parameters

NameTypeDescription
payloadunknown

Untrusted persistence payload.

optionsExecuteOptionsDefault: {}

Cancellation and provider scope.

Returns

Promise<Playlist | Track<unknown>>

A restored entity without ephemeral playback state.

resolveStream

resolveStream(track: Track, options: StreamResolutionOptions = {}): Promise<MediaSource>

Resolve and normalize a track for the already selected Remedia node.

Parameters

NameTypeDescription
trackTrack

Data model with a portable provider reference.

optionsStreamResolutionOptionsDefault: {}

Target node mode and cancellation.

Returns

Promise<MediaSource>

On this page