@deadair/plugin-sdk 0.2.0

package/dist/capabilities/charts.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The `charts` kind. A charts plugin answers "what is popular", as an ordered
+ * list of records somebody else ranked.
+ *
+ * ## It answers with NAMES, and that is the whole design
+ *
+ * A chart entry is a title and an artist as strings, which is exactly the shape
+ * of a station pick: the host looks a name up, ingests it if a provider has it,
+ * and then judges it against the rotation rules like anything else. So a chart
+ * source inherits the dislike veto, the repeat window, the artist spacing and
+ * the fetch-and-bench by doing nothing at all, and a plugin here has no way to
+ * put a record on air that the operator forbade.
+ *
+ * Which is why there is no `trackId`, no provider id and no stream URL in any
+ * shape below. A chart is an opinion about records, not a source of them.
+ *
+ * ## Several plugins, several menus
+ *
+ * Unlike `enrichment`, this is not a fan-out that merges: two chart services do
+ * not produce one better chart, they produce two charts. So there is no
+ * `priority` here, and the host qualifies every {@link ChartDescriptor.id} with
+ * the plugin that offered it — two services will both call something `top-100`.
+ *
+ * Every shape here is JSON-safe.
+ */
+/**
+ * One chart this plugin can serve.
+ *
+ * `id` is scoped to this plugin and needs to be unique only within it. The host
+ * qualifies it before anything outside sees it, so a short flat id is right.
+ */
+export interface ChartDescriptor {
+    id: string;
+    /** What to call it in a list an operator reads, e.g. `Top 100 Songs`. */
+    name: string;
+    /** ISO 3166-1 alpha-2, when the chart is national. Absent means global. */
+    country?: string;
+    /** The genre this chart covers, when it covers one. */
+    genre?: string;
+    description?: string;
+}
+/** What a chart is asked for. */
+export interface ChartQuery {
+    /** A {@link ChartDescriptor.id} this plugin offered. */
+    chartId: string;
+    /** How many entries to return. A plugin may return fewer; it must not return more. */
+    limit: number;
+    /**
+     * Which edition, as an ISO-8601 date string (`YYYY-MM-DD`). Never a `Date`.
+     *
+     * A chart is a weekly document with a history, and "the hits of this week in
+     * 1994" is a show. Whether a service can answer that is the plugin's
+     * business: one that cannot should answer for its current edition rather
+     * than throwing, because a nearly-right chart is a usable hour and an error
+     * is silence.
+     */
+    date?: string;
+}
+/** One record's place in a chart. */
+export interface ChartEntry {
+    /** 1-based position in this edition. */
+    rank: number;
+    title: string;
+    /**
+     * The LEAD artist, and never a credit line.
+     *
+     * A correctness rule rather than a formatting one, and it is the single
+     * easiest thing to get wrong here, because most feeds print `A, B & C` in
+     * one field. Everything downstream matches a pick on the lead artist alone —
+     * the host keys it as `songKey(title, [artist])` and its provider lookup
+     * compares the first artist exactly — so a joined credit is a record that is
+     * named correctly, resolves to nothing, and is dropped as "not in the
+     * catalog". A live run of the same mistake elsewhere resolved every solo
+     * credit and lost every duet.
+     *
+     * Put the other credits in {@link featuring}, which is shown and never
+     * matched on.
+     */
+    artist: string;
+    /** The other credited artists, in the source's own order. Never used to identify the record. */
+    featuring?: string[];
+    album?: string;
+    year?: number;
+    /** Best position this record has reached, where the source tracks it. */
+    peak?: number;
+    /** How many editions it has appeared in, where the source tracks it. */
+    weeksOn?: number;
+}
+/**
+ * Implemented by a `charts` plugin.
+ */
+export interface ChartsProvider {
+    /**
+     * What this plugin can serve, right now.
+     *
+     * Asked per request rather than cached by the host, for the reason a tool's
+     * declarations are: an operator reconfiguring a plugin reinitializes it, and
+     * a country list that depends on a config field would otherwise be a boot
+     * snapshot of a setting that has since changed.
+     *
+     * An empty array is an ordinary answer — an unconfigured plugin has nothing
+     * to offer — and is not a failure.
+     */
+    listCharts(): Promise<ChartDescriptor[]>;
+    /**
+     * One chart's entries, ranked.
+     *
+     * Return `[]` for a `chartId` you do not recognise rather than throwing: the
+     * host asks the plugin that named the id, so an unknown one means the menu
+     * moved underneath a caller, which is a stale request and not a fault.
+     */
+    fetchChart(query: ChartQuery): Promise<ChartEntry[]>;
+    /**
+     * The id of a chart for one musical style, if this service publishes one.
+     *
+     * Optional, the way `artistTopTracks` is on the similarity capability, and it exists because a
+     * style chart is the one family {@link listCharts} cannot offer: a service that ranks by tag has
+     * a chart for every word anybody has ever applied, so enumerating them is impossible and listing
+     * ten arbitrary ones is a worse menu than none. The result is that a perfectly good endpoint was
+     * unreachable — a caller could only ask for ids it had been shown.
+     *
+     * So this is a NAMING question rather than a fetch: hand it a style and get back an id for
+     * {@link fetchChart}, in whatever private scheme this plugin uses. The host never builds one
+     * itself, because the scheme belongs to the plugin and a host that guessed it would be writing
+     * one service's URL structure into deadair.
+     *
+     * `undefined` for a service with no style charts, which is an ordinary answer. Note it says
+     * nothing about whether the style HAS entries — an id for a word nobody ever tagged is a valid
+     * id for an empty chart, and telling those apart costs a request the caller is about to make
+     * anyway.
+     */
+    styleChartId?(style: string): string | undefined;
+}
+//# sourceMappingURL=charts.d.ts.map

package/dist/capabilities/charts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charts.d.ts","sourceRoot":"","sources":["../../src/capabilities/charts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,iCAAiC;AACjC,MAAM,WAAW,UAAU;IACvB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACvB,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;;;;;;;;OAcG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;;;;;;;;;OAUG;IACH,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAEzC;;;;;;OAMG;IACH,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAErD;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACpD"}

package/dist/capabilities/enrichment.d.ts

@@ -0,0 +1,255 @@
+/**
+ * The `enrichment` kind. An enrichment plugin takes a reference to something in
+ * the catalog and returns extra facts about it: the stuff the DJ talks over,
+ * the stuff the UI shows. Several enrichment plugins run for the same thing and
+ * the host merges their results in `priority` order.
+ *
+ * Three references, three answers, because the facts have three different
+ * lifetimes and three different costs. A recording is asked about once per
+ * track, an artist once per artist, and a record once per album — so a rotation
+ * that revisits the same few hundred artists pays for them once rather than
+ * once per song. Only `enrichTrack` is required.
+ *
+ * Every shape here is JSON-safe.
+ */
+/**
+ * How an enrichment plugin is asked to identify a track. `isrc` is the
+ * preferred key when present; otherwise match on the normalised
+ * `artist|title` pair.
+ */
+export interface TrackRef {
+    /** Recording ISRC. When set, prefer it over the string fields. */
+    isrc?: string;
+    /**
+     * MusicBrainz RECORDING id, when the catalog has resolved one.
+     *
+     * The mirror of {@link ArtistRef.mbid} and {@link AlbumRef.mbid}, and it
+     * arrives the same way: something already resolved it and the host promoted
+     * it onto `tracks.mbid`, so a later pass gets it for free. Prefer it over
+     * every other field here when your source can take one, because it is the
+     * only identifier in this shape that cannot match the wrong record.
+     */
+    mbid?: string;
+    /** Primary artist name, as the source provider spells it. */
+    artist: string;
+    title: string;
+    album?: string;
+    durationMs?: number;
+    /** Release year, when known. Cheap disambiguator for covers and re-issues. */
+    year?: number;
+}
+/** Match keys an enrichment plugin can look a track up by. */
+export declare const ENRICHMENT_MATCH_KEY_ISRC = "isrc";
+export declare const ENRICHMENT_MATCH_KEY_ARTIST_TITLE = "artist-title";
+export declare const KNOWN_ENRICHMENT_MATCH_KEYS: readonly ["isrc", "artist-title"];
+export type EnrichmentMatchKey = (typeof KNOWN_ENRICHMENT_MATCH_KEYS)[number];
+/** A named external identifier, e.g. `{ source: 'musicbrainz', id: '...' }`. */
+export interface ExternalId {
+    source: string;
+    id: string;
+}
+/** A link out to the source, shown in the UI and usable as a citation. */
+export interface ExternalLink {
+    label: string;
+    url: string;
+}
+/**
+ * A piece of PROSE about this thing, handed over for the host to read rather
+ * than for anyone to say.
+ *
+ * The difference between this and {@link TrackEnrichment.facts} is who wrote
+ * the sentence. A `fact` is a line your plugin composed and is willing to have
+ * spoken on air unchanged. A document is somebody else's article, verbatim: the
+ * host extracts claims from it, checks each claim against the text, and keeps
+ * the provenance. Nothing reads a document aloud, and nothing shows one on a
+ * page.
+ *
+ * Hand over the prose rather than your own summary of it. The host stores it,
+ * so a better extraction later costs no request to your upstream, and
+ * `sourceQuote` on the claims it produces has to be a span that really occurs
+ * in `text` or the claim is dropped.
+ *
+ * Plain text, not HTML and not wiki markup. Strip the furniture (navigation,
+ * licence footers, reference markers) the way a reader would ignore it.
+ */
+export interface SourceDocument {
+    /** Where this text can be read by a person. Becomes the claim's citation, so it must be public. */
+    url: string;
+    /** The document's own title, e.g. the article name. */
+    title: string;
+    /** The prose, as plain text. */
+    text: string;
+    /** ISO-8601 instant. Never a `Date`. */
+    retrievedAt: string;
+}
+/**
+ * How an enrichment plugin is asked to identify an artist.
+ *
+ * Two identifiers, and the difference between them matters. `mbid` is the one
+ * id that crosses providers, so a plugin that is not MusicBrainz can still use
+ * it (Last.fm takes one directly) or ignore it and match on `name`.
+ * `providerRef` is this plugin's *own* last id for this artist, handed back so
+ * a second pass is a lookup rather than another search. Neither is promised:
+ * the first time anything asks about an artist, all there is is a name.
+ */
+export interface ArtistRef {
+    /** Canonical artist name, as the catalog holds it. */
+    name: string;
+    /** MusicBrainz artist id, when the catalog has resolved one. */
+    mbid?: string;
+    /** The id this plugin itself used last time it answered about this artist. */
+    providerRef?: string;
+}
+/** The album equivalent of {@link ArtistRef}. `mbid` is a MusicBrainz release-group id. */
+export interface AlbumRef {
+    name: string;
+    /** The album's artist, because a title alone does not identify a record. */
+    artist: string;
+    /** MusicBrainz release-group id, when the catalog has resolved one. */
+    mbid?: string;
+    providerRef?: string;
+}
+/**
+ * The union of facts enrichment can contribute. Every field is optional: a
+ * plugin returns a `Partial<TrackEnrichment>` containing only what it knows.
+ */
+export interface TrackEnrichment {
+    /**
+     * Your own id for this thing, so the next pass can be a lookup rather than
+     * another search. The mirror of the `providerRef` on the ref you were
+     * handed: the host stores it against your plugin and gives it back to you,
+     * and only to you.
+     *
+     * Say it outright whenever you have one. It is not identity and it is not a
+     * claim about anyone else's ids — put those in {@link externalIds}, in
+     * whatever order suits you.
+     */
+    providerRef: string;
+    /** Canonical artist name, if the source has a better spelling than the provider. */
+    artist: string;
+    title: string;
+    album: string;
+    /** Original release year of the recording. */
+    year: number;
+    /** ISO-8601 date string (`YYYY-MM-DD` or `YYYY`). Never a `Date`. */
+    releaseDate: string;
+    genres: string[];
+    moods: string[];
+    /** Free-text background: label, session players, chart history. DJ patter fodder. */
+    biography: string;
+    /** Short trivia lines, each independently speakable. */
+    facts: string[];
+    /** Source prose for the host to extract claims from. See {@link SourceDocument}. */
+    documents: SourceDocument[];
+    /** Beats per minute. */
+    bpm: number;
+    /** Musical key, e.g. `A minor`. */
+    musicalKey: string;
+    label: string;
+    isrc: string;
+    artworkUrl: string;
+    externalIds: ExternalId[];
+    links: ExternalLink[];
+}
+/**
+ * What enrichment can say about an artist rather than a recording.
+ *
+ * Asked once per artist instead of once per track, which is the whole point of
+ * it being a separate method: a rotation revisits the same few hundred artists
+ * constantly, and an artist's background changes on a scale of years.
+ */
+export interface ArtistEnrichment {
+    /** Your own id for this artist. See {@link TrackEnrichment.providerRef}. */
+    providerRef: string;
+    /** Canonical artist name, if the source has a better spelling than the provider. */
+    name: string;
+    /** Free-text background. DJ patter fodder. */
+    biography: string;
+    /** Short trivia lines, each independently speakable. */
+    facts: string[];
+    /** Source prose for the host to extract claims from. See {@link SourceDocument}. */
+    documents: SourceDocument[];
+    genres: string[];
+    imageUrl: string;
+    externalIds: ExternalId[];
+    links: ExternalLink[];
+}
+/**
+ * What enrichment can say about a record rather than a recording.
+ *
+ * The label, the pressing and the cover belong to the release, not to any one
+ * track on it, so they are asked for once per album. A track's own
+ * `TrackEnrichment.label` is still meaningful for a single that was never on a
+ * record, or for a compilation whose tracks were licensed separately.
+ */
+export interface AlbumEnrichment {
+    /** Your own id for this record. See {@link TrackEnrichment.providerRef}. */
+    providerRef: string;
+    name: string;
+    /** Canonical artist name for the album, which is not always the track's. */
+    artist: string;
+    /** Release year of this record, as opposed to of any recording on it. */
+    year: number;
+    /** ISO-8601 date string (`YYYY-MM-DD` or `YYYY`). Never a `Date`. */
+    releaseDate: string;
+    label: string;
+    genres: string[];
+    facts: string[];
+    /** Source prose for the host to extract claims from. See {@link SourceDocument}. */
+    documents: SourceDocument[];
+    artworkUrl: string;
+    externalIds: ExternalId[];
+    links: ExternalLink[];
+}
+/**
+ * Implemented by an `enrichment` plugin.
+ */
+export interface EnrichmentProvider {
+    /**
+     * Lower runs first and wins conflicts on merge. Use 100 for a canonical
+     * source (MusicBrainz), 500 for a supplementary one, 900 for a guess.
+     */
+    priority: number;
+    /** Which of the {@link TrackRef} fields this plugin can actually match on. */
+    matchKeys: EnrichmentMatchKey[];
+    /**
+     * How many refs this plugin will take in one {@link enrichTracks} call.
+     *
+     * The host chunks to it, so a batch call is a small fixed number of upstream
+     * round trips and can be given a deadline that means something. Ignored by a
+     * plugin that does not implement `enrichTracks`.
+     */
+    maxBatchSize?: number;
+    /** Return only the fields you actually resolved. Return `{}` on no match. */
+    enrichTrack(ref: TrackRef): Promise<Partial<TrackEnrichment>>;
+    /**
+     * The same question as {@link enrichTrack}, asked about several tracks at
+     * once. Optional, the way {@link enrichArtist} is: the host loops
+     * `enrichTrack` for any plugin that does not write it, so implementing it is
+     * an optimisation and never a requirement.
+     *
+     * Implement it only where the upstream can genuinely answer about many at
+     * once. A source paced at a request per second is the case this exists for:
+     * one query that identifies twenty-five tracks costs a second, where
+     * twenty-five `enrichTrack` calls cost twenty-five.
+     *
+     * Index-aligned with `refs`: entry `i` is the answer about `refs[i]`, the
+     * returned array is the same length, and `{}` at a position is a miss
+     * exactly as it is for `enrichTrack`. A source that could only account for
+     * some of the batch returns `{}` for the rest rather than a short array.
+     */
+    enrichTracks?(refs: TrackRef[]): Promise<Partial<TrackEnrichment>[]>;
+    /**
+     * Optional, the way a music provider's `resolveStreamUrl` is: a source
+     * that only knows recordings is still a valid enrichment plugin, and the
+     * host asks nothing of a plugin that did not write the method.
+     *
+     * Implement it for anything that belongs to the artist rather than to one
+     * of their recordings. The host asks once per artist, so the same answer
+     * covers every track they appear on.
+     */
+    enrichArtist?(ref: ArtistRef): Promise<Partial<ArtistEnrichment>>;
+    /** The album equivalent of {@link enrichArtist}, asked once per record. */
+    enrichAlbum?(ref: AlbumRef): Promise<Partial<AlbumEnrichment>>;
+}
+//# sourceMappingURL=enrichment.d.ts.map

package/dist/capabilities/enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrichment.d.ts","sourceRoot":"","sources":["../../src/capabilities/enrichment.ts"],"names":[],"mappings":"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"}