@deadair/plugin-sdk 0.2.0

package/dist/article.parse.d.ts

@@ -0,0 +1,82 @@
+import type { HostFetchInit, PluginHost } from './plugin.host.js';
+/**
+ * The story behind a headline, as the paragraphs somebody else published.
+ *
+ * The sibling of `feed.parse.ts`, here for the same reason and with the same
+ * split. A feed is a summary of a publication and frequently not a summary of
+ * anything else: measured against the station's own configured feed, every
+ * item's `description` was one sentence restating its title and its
+ * `content:encoded` was that same sentence wrapped in a `<p>`. So a station
+ * that wants to say what HAPPENED has to read the page the entry points at,
+ * and every plugin that reads a feed will want this the moment it wants more
+ * than titles.
+ *
+ * ## It extracts and it does not summarise
+ *
+ * Everything that comes out of here is the publisher's own prose, in the
+ * publisher's own order, with the furniture removed. Nothing is rewritten,
+ * nothing is joined, and no sentence is composed. That is the same boundary
+ * `plugins/wikipedia` keeps by handing the host an article verbatim: only the
+ * host can check a claim against the text it came from, and prose that has been
+ * through a plugin's own paraphrase is prose nothing can check.
+ *
+ * The one thing removed that is not furniture is a paragraph announcing itself as an advertisement
+ * — see {@link SPONSOR_OPENERS}. It is still a cut rather than a rewrite: what is left is the
+ * publisher's own prose, and what went is prose the publisher was paid for.
+ *
+ * ## Wrong in one direction on purpose
+ *
+ * A page that cannot be read answers `undefined` rather than a guess. Every
+ * caller's fallback is the entry's own words, which is a real answer, whereas
+ * navigation copy and cookie banners scraped off a template are noise a voice
+ * would read out as news. So the extraction is deliberately conservative: a
+ * block that is not clearly a paragraph of prose is dropped, and a page that
+ * yields nothing is a page with nothing on it as far as anything here is
+ * concerned.
+ */
+/**
+ * How much of an article is kept.
+ *
+ * Sized to what a bulletin can use rather than to the article: the destination
+ * is a model's context beside a persona sheet and a set of content rules, and a
+ * writer that only ever reads out one sentence per story does not need three
+ * thousand words to find it. Cut on a sentence boundary
+ * ({@link truncateSentences}), because half a sentence is something a model
+ * finishes out of its own head.
+ */
+export declare const ARTICLE_MAX_CHARS = 2000;
+/**
+ * An article page as plain text, or `undefined` when it does not carry one.
+ *
+ * Pure, and that is what makes it testable against saved pages with no host in
+ * the way — `parseFeed`'s split, for `parseFeed`'s reason.
+ *
+ * @param html - The page, as served.
+ * @param maxChars - Where to cut. See {@link ARTICLE_MAX_CHARS}.
+ */
+export declare function extractArticle(html: string, maxChars?: number): string | undefined;
+/**
+ * An article off the network, as plain text.
+ *
+ * Everything about the request except the status check is `host.fetch`'s, and
+ * the status ladder is `plugin.http.ts`'s unmodified: `fetchFeed`'s shape, for
+ * `fetchFeed`'s reasons.
+ *
+ * The one thing this adds is the content-type check, which is not fussiness. An
+ * entry legitimately links to a PDF, an audio file or a video page, and a
+ * megabyte of binary put through a tag stripper produces a long string of
+ * plausible-looking rubbish rather than an error — which a bulletin would then
+ * read out.
+ *
+ * `options.maxChars` is separate from `init` because the two are addressed to
+ * different parties: everything in `init` is the host's business and this is the
+ * parser's. The default is {@link ARTICLE_MAX_CHARS}, which is sized for a
+ * bulletin — a writer that reads one sentence per story out of a model's context
+ * has no use for three thousand words. A plugin contributing an enrichment
+ * `SourceDocument` wants far more of the page, because what reads that is a
+ * claim extractor rather than a presenter.
+ */
+export declare function fetchArticle(host: PluginHost, url: string, init?: HostFetchInit, options?: {
+    maxChars?: number;
+}): Promise<string | undefined>;
+//# sourceMappingURL=article.parse.d.ts.map

package/dist/article.parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"article.parse.d.ts","sourceRoot":"","sources":["../src/article.parse.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,OAAQ,CAAC;AAwIvC;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAA0B,GAAG,MAAM,GAAG,SAAS,CAgCrG;AA2BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAC9B,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA0B7B"}

package/dist/boundary.json.safe.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Compile-time enforcement of the JSON-safe rule, over the payloads it applies
+ * to.
+ *
+ * ## Which payloads, and why
+ *
+ * This rule used to cover everything a plugin touched, on the strength of a deferred move behind a
+ * subprocess: JSON was going to be the wire format, so nothing could carry a `Date`, a `Uint8Array`
+ * or a live object. That move is closed (`packages/plugin-sdk/CLAUDE.md` § "Trust and egress"), and
+ * with it the reason to apply the rule to `host.fetch`'s arguments and return value, which nothing
+ * serializes.
+ *
+ * What is registered here is what has an INDEPENDENT reason to survive
+ * `JSON.parse(JSON.stringify(x))`: it is stored in Postgres, or sent to the
+ * console over HTTP, or both. A `Date` in `TrackEnrichment` is a bug whether or
+ * not plugins ever move anywhere, which is why that half of the rule outlived
+ * the argument that introduced it.
+ *
+ * ## Why compile time
+ *
+ * The runtime conformance suite in `tests/` round-trips hand-written fixtures,
+ * which catches a value that violates the rule despite a type that permits it
+ * (a class instance where the type says `object`). What it cannot catch is a
+ * newly added field: nothing populates it, so nothing round-trips it, and CI
+ * stays green while a `Date` crosses the boundary.
+ *
+ * TypeScript types are erased, so no runtime walk can ever be exhaustive over
+ * a type. That check has to happen at compile time, which is what this file
+ * is. {@link AssertAllBoundaryPayloadsAreJsonSafe} fails `tsc` the moment any
+ * field of any registered payload stops being JSON-safe, without anyone
+ * writing a fixture for it.
+ *
+ * This lives in `src/` rather than `tests/` on purpose: per the repo
+ * convention the build tsconfig includes only `./src/**\/*`, so an assertion
+ * in `tests/` would never run during `tsc --noEmit`. Everything here is types
+ * plus three name arrays, so the runtime cost is the arrays alone.
+ */
+import type { AnalysisRef, TrackAnalysis, TrackCuePoints, TrackLoudness, TrackTaggedLoudness } from './capabilities/analysis.js';
+import type { AudioJoin, AudioOverlay } from './capabilities/mixer.js';
+import type { ChartDescriptor, ChartEntry, ChartQuery } from './capabilities/charts.js';
+import type { NewsFeedDescriptor, NewsItem, NewsQuery } from './capabilities/news.js';
+import type { ScrobblePlay, ScrobbleRejection, ScrobbleResult } from './capabilities/scrobble.js';
+import type { SearchQuery, SearchResult } from './capabilities/search.js';
+import type { ArtistTrack, SimilarArtist } from './capabilities/similarity.js';
+import type { WeatherConditions, WeatherDay, WeatherQuery, WeatherReading } from './capabilities/weather.js';
+import type { AlbumEnrichment, AlbumRef, ArtistEnrichment, ArtistRef, ExternalId, ExternalLink, SourceDocument, TrackEnrichment, TrackRef } from './capabilities/enrichment.js';
+import type { GetPlaylistTracksOptions, ListPlaylistsOptions, PlaybackState, ProviderPlaylist, ProviderStream, ProviderTrack, SearchTracksOptions } from './capabilities/music.provider.js';
+import type { LlmMessage, LlmModelInfo, LlmRequest, LlmResult, LlmToolCall, LlmToolDeclaration, LlmUsage } from './capabilities/llm.js';
+import type { SpeechRequest, SpeechVoice } from './capabilities/speech.js';
+import type { ConfigField, ConfigFieldColumn, ConfigFieldOption } from './plugin.config.fields.js';
+import type { TrackFetchRequest, TrackFetchSession } from './plugin.host.js';
+import type { PluginConnectionResult } from './plugin.lifecycle.js';
+import type { PluginManifest } from './plugin.manifest.js';
+import type { NetworkPermissionFromConfig, NetworkPermissionHost, PluginGrantRequest, PluginPermissions } from './plugin.permissions.js';
+/**
+ * `T` with every part that cannot survive `JSON.parse(JSON.stringify(x))`
+ * replaced by `never`, so `T extends JsonSafe<T>` holds only for a genuinely
+ * JSON-safe `T`.
+ *
+ * Deliberately narrower than structured-clone-safe. `Date`, `Map`, `Set` and
+ * typed arrays all survive `structuredClone` and are still rejected here,
+ * because what these payloads actually have to survive is Postgres and HTTP,
+ * and both of those are JSON. A `Date` that round-trips through
+ * `structuredClone` still comes back out of a `jsonb` column as a string.
+ *
+ * `any` and `unknown` pass through unchecked: there is nothing to inspect at
+ * compile time, which is exactly the case the runtime fixture round-trip
+ * covers.
+ */
+export type JsonSafe<T> = 0 extends 1 & T ? T : unknown extends T ? T : T extends string | number | boolean | null | undefined ? T : T extends (...args: never[]) => unknown ? never : T extends Date | RegExp | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<unknown> ? never : T extends ArrayBuffer | SharedArrayBuffer | ArrayBufferView ? never : T extends bigint | symbol ? never : T extends readonly (infer TElement)[] ? readonly JsonSafe<TElement>[] : T extends object ? {
+    [K in keyof T]: JsonSafe<T[K]>;
+} : never;
+/**
+ * `true` when `T` survives the boundary, `false` when any part of it does not.
+ *
+ * The tuple wrappers stop the conditional from distributing over a union, so a
+ * field typed `string | Date` fails as a whole rather than partially matching.
+ *
+ * Written as a conditional rather than the more obvious
+ * `T extends JsonSafe<T>` constraint, because TypeScript rejects that form as
+ * a circular constraint (TS2313).
+ */
+type IsJsonSafe<T> = [T] extends [JsonSafe<T>] ? true : false;
+/**
+ * Compiles only when every value in `T` is `true`. When one is not, the error
+ * lands on that property, so the diagnostic names the offending boundary type.
+ */
+type AssertAllTrue<T extends Record<string, true>> = T;
+/**
+ * Every payload that is stored or sent, asserted in one place.
+ *
+ * ADDING A BOUNDARY TYPE? Add it here and to {@link JSON_SAFE_PAYLOAD_TYPES}.
+ * `tests/boundary.registry.test.ts` fails if an exported interface in a
+ * boundary source file is in none of the three registries, so this cannot be
+ * skipped by accident.
+ *
+ * `PluginManifest` is asserted without `configSchema`, which is a zod schema:
+ * a class instance, deliberately never serialized, and stripped by the host
+ * before a manifest is sent anywhere.
+ */
+export type AssertAllBoundaryPayloadsAreJsonSafe = AssertAllTrue<{
+    PluginConnectionResult: IsJsonSafe<PluginConnectionResult>;
+    PluginPermissions: IsJsonSafe<PluginPermissions>;
+    NetworkPermissionHost: IsJsonSafe<NetworkPermissionHost>;
+    NetworkPermissionFromConfig: IsJsonSafe<NetworkPermissionFromConfig>;
+    PluginGrantRequest: IsJsonSafe<PluginGrantRequest>;
+    ConfigField: IsJsonSafe<ConfigField>;
+    ConfigFieldOption: IsJsonSafe<ConfigFieldOption>;
+    ConfigFieldColumn: IsJsonSafe<ConfigFieldColumn>;
+    PluginManifestWithoutConfigSchema: IsJsonSafe<Omit<PluginManifest, 'configSchema'>>;
+    ProviderTrack: IsJsonSafe<ProviderTrack>;
+    ProviderPlaylist: IsJsonSafe<ProviderPlaylist>;
+    ProviderStream: IsJsonSafe<ProviderStream>;
+    TrackFetchSession: IsJsonSafe<TrackFetchSession>;
+    TrackFetchRequest: IsJsonSafe<TrackFetchRequest>;
+    SearchTracksOptions: IsJsonSafe<SearchTracksOptions>;
+    ListPlaylistsOptions: IsJsonSafe<ListPlaylistsOptions>;
+    GetPlaylistTracksOptions: IsJsonSafe<GetPlaylistTracksOptions>;
+    PlaybackState: IsJsonSafe<PlaybackState>;
+    TrackRef: IsJsonSafe<TrackRef>;
+    ArtistRef: IsJsonSafe<ArtistRef>;
+    AlbumRef: IsJsonSafe<AlbumRef>;
+    ExternalId: IsJsonSafe<ExternalId>;
+    ExternalLink: IsJsonSafe<ExternalLink>;
+    SourceDocument: IsJsonSafe<SourceDocument>;
+    TrackEnrichment: IsJsonSafe<TrackEnrichment>;
+    ArtistEnrichment: IsJsonSafe<ArtistEnrichment>;
+    AlbumEnrichment: IsJsonSafe<AlbumEnrichment>;
+    SpeechRequest: IsJsonSafe<SpeechRequest>;
+    SpeechVoice: IsJsonSafe<SpeechVoice>;
+    LlmMessage: IsJsonSafe<LlmMessage>;
+    LlmToolDeclaration: IsJsonSafe<LlmToolDeclaration>;
+    LlmToolCall: IsJsonSafe<LlmToolCall>;
+    LlmUsage: IsJsonSafe<LlmUsage>;
+    LlmRequest: IsJsonSafe<LlmRequest>;
+    LlmResult: IsJsonSafe<LlmResult>;
+    LlmModelInfo: IsJsonSafe<LlmModelInfo>;
+    AnalysisRef: IsJsonSafe<AnalysisRef>;
+    AudioJoin: IsJsonSafe<AudioJoin>;
+    AudioOverlay: IsJsonSafe<AudioOverlay>;
+    TrackCuePoints: IsJsonSafe<TrackCuePoints>;
+    TrackLoudness: IsJsonSafe<TrackLoudness>;
+    TrackTaggedLoudness: IsJsonSafe<TrackTaggedLoudness>;
+    TrackAnalysis: IsJsonSafe<TrackAnalysis>;
+    ChartDescriptor: IsJsonSafe<ChartDescriptor>;
+    ChartQuery: IsJsonSafe<ChartQuery>;
+    ChartEntry: IsJsonSafe<ChartEntry>;
+    NewsFeedDescriptor: IsJsonSafe<NewsFeedDescriptor>;
+    NewsQuery: IsJsonSafe<NewsQuery>;
+    NewsItem: IsJsonSafe<NewsItem>;
+    SimilarArtist: IsJsonSafe<SimilarArtist>;
+    ArtistTrack: IsJsonSafe<ArtistTrack>;
+    SearchQuery: IsJsonSafe<SearchQuery>;
+    SearchResult: IsJsonSafe<SearchResult>;
+    WeatherQuery: IsJsonSafe<WeatherQuery>;
+    WeatherConditions: IsJsonSafe<WeatherConditions>;
+    WeatherDay: IsJsonSafe<WeatherDay>;
+    WeatherReading: IsJsonSafe<WeatherReading>;
+    ScrobblePlay: IsJsonSafe<ScrobblePlay>;
+    ScrobbleRejection: IsJsonSafe<ScrobbleRejection>;
+    ScrobbleResult: IsJsonSafe<ScrobbleResult>;
+}>;
+/**
+ * Names of the interfaces asserted above. Kept as a runtime array so the
+ * registry-coverage test can compare it against what is actually exported
+ * from the boundary source files.
+ */
+export declare const JSON_SAFE_PAYLOAD_TYPES: readonly ["PluginConnectionResult", "PluginPermissions", "NetworkPermissionHost", "NetworkPermissionFromConfig", "PluginGrantRequest", "ConfigField", "ConfigFieldOption", "ConfigFieldColumn", "PluginManifest", "ProviderTrack", "ProviderPlaylist", "ProviderStream", "TrackFetchSession", "TrackFetchRequest", "SearchTracksOptions", "ListPlaylistsOptions", "GetPlaylistTracksOptions", "PlaybackState", "TrackRef", "ArtistRef", "AlbumRef", "ExternalId", "ExternalLink", "SourceDocument", "TrackEnrichment", "ArtistEnrichment", "AlbumEnrichment", "SpeechRequest", "SpeechVoice", "LlmMessage", "LlmToolDeclaration", "LlmToolCall", "LlmUsage", "LlmRequest", "LlmResult", "LlmModelInfo", "AnalysisRef", "AudioJoin", "AudioOverlay", "TrackCuePoints", "TrackLoudness", "TrackTaggedLoudness", "TrackAnalysis", "ChartDescriptor", "ChartQuery", "ChartEntry", "NewsFeedDescriptor", "NewsQuery", "NewsItem", "SimilarArtist", "ArtistTrack", "SearchQuery", "SearchResult", "WeatherQuery", "WeatherConditions", "WeatherDay", "WeatherReading", "ScrobblePlay", "ScrobbleRejection", "ScrobbleResult"];
+/**
+ * Boundary interfaces that are deliberately NOT payloads: they describe
+ * methods, so they carry functions by definition and can never be JSON-safe.
+ *
+ * The arguments and return values of those methods are payloads, and those
+ * are what {@link JSON_SAFE_PAYLOAD_TYPES} covers. Listing the method-bearing
+ * interfaces explicitly is what makes "is this a payload or a contract?" a
+ * conscious decision for anyone adding one, rather than a silent omission.
+ */
+export declare const BOUNDARY_METHOD_TYPES: readonly ["PluginLogger", "PluginStorage", "PluginSecrets", "PluginConfigAccess", "PluginOAuth", "PluginEvents", "PluginTrackFetcher", "PluginHost", "PluginLifecycle", "MusicProviderCatalog", "MusicProviderStream", "MusicProviderSteer", "MusicProviderOAuth", "MusicProvider", "EnrichmentProvider", "SpeechPluginInstance", "LlmPluginInstance", "AnalysisProvider", "MixerProvider", "ChartsProvider", "NewsProvider", "SimilarityProvider", "SearchProvider", "WeatherProvider", "ScrobbleProvider"];
+/**
+ * Boundary interfaces that deliberately carry a LIVE object, and so are neither
+ * payloads nor method contracts.
+ *
+ * The host and the plugin share a realm, permanently (see `packages/plugin-sdk/CLAUDE.md` § "Trust
+ * and egress"), so handing over a real `AbortSignal` or a real stream is the correct design rather
+ * than a shortcut around the rule. They are listed rather than simply left out, because the
+ * registry-coverage test treats an unclassified boundary interface as an omission, and "this one
+ * holds a live object on purpose" is a decision somebody should have to make in writing.
+ */
+export declare const BOUNDARY_LIVE_OBJECT_TYPES: readonly ["HostFetchInit", "SpeechHandle", "JoinedAudio", "LlmHandle"];
+export {};
+//# sourceMappingURL=boundary.json.safe.d.ts.map

package/dist/boundary.json.safe.d.ts.map

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

package/dist/capabilities/analysis.d.ts

@@ -0,0 +1,330 @@
+/**
+ * The `analysis` capability. An analysis plugin takes one track's audio and
+ * answers with measurements of it: where the record actually starts, where it is
+ * underway, where the ending begins, where it stops.
+ *
+ * ## Why this is not enrichment
+ *
+ * Enrichment asks an upstream what it KNOWS about a recording, fans the question
+ * out to everything that answers, and merges the results in priority order.
+ * Nothing here works that way. There is no upstream that knows where a record's
+ * outro begins — it is computed from the samples — so there is exactly one
+ * answer, one source, and nothing to merge. `TrackRef` also carries no way to
+ * reach the audio, deliberately, because no enrichment source wants it.
+ *
+ * ## The plugin is an adapter, not an analyzer
+ *
+ * Measuring any of this needs decoded PCM, and decoding is the one thing this
+ * tree does not do in Node. So the expected implementation is a thin adapter over
+ * a separate program: take {@link AnalysisRef.audioUrl}, hand it to whatever
+ * actually decodes, return what comes back. That is the same relationship the
+ * bundled speech plugin has with its engine.
+ *
+ * The reason is decoding and only decoding. An earlier version of this note also claimed the
+ * boundary bought a licence position, which `analysis/README.md` § "The rule, stated once" retired:
+ * nothing copyleft or non-commercial enters the analysis path in the first place, so there is no
+ * position for the boundary to buy.
+ *
+ * Nothing here requires that shape. A plugin that can measure audio some other
+ * way is a valid implementation; this note exists so the first one is not
+ * mistaken for the contract.
+ *
+ * ## Why joining audio is not here
+ *
+ * It was, for one commit, as an optional `joinAudio`. The argument was the
+ * paragraph above read backwards — joining needs decoded PCM too, so it wants the
+ * same adapter over the same program, and the bundled plugin does serve both off
+ * one sidecar with one address. That much is still true and is why there is still
+ * one plugin.
+ *
+ * What it got wrong is that a capability is the unit of SELECTION, not of
+ * implementation: the host picks one plugin per capability, so a joiner carried
+ * here is whichever plugin the operator chose to MEASURE with. `capabilities/mixer.ts`
+ * has the rest of it.
+ *
+ * ## What the host guarantees, and what it cannot
+ *
+ * The host resolves {@link AnalysisRef.audioUrl} because a plugin cannot: the
+ * copy that can actually be served is a binding the catalog owns, and asking one
+ * plugin to go through another is not a thing the host permits. In exchange the
+ * host cannot see the bytes, so it cannot tell a complete download from a
+ * truncated one — which is why {@link TrackAnalysis.complete} is reported rather
+ * than inferred. See the note on that field: it is the difference between a cache
+ * that can be trusted and one that cannot.
+ *
+ * Every shape here is JSON-safe. Offsets are integer milliseconds.
+ */
+import type { PluginLifecycle } from '../plugin.lifecycle.js';
+/**
+ * The current shape of {@link TrackAnalysis.data}.
+ *
+ * Bumped whenever a detector's output changes shape, which is what lets a stored
+ * row be recognised as STALE rather than read as missing or, worse, as current.
+ * Reanalysis then falls out of an ordinary "needs work" query instead of needing
+ * a migration.
+ *
+ * **An OPTIONAL field being added is not that**, and does not bump this. Every
+ * consumer of `data` already has a defined answer for a field that is absent —
+ * it has to, since an analyzer may not compute one — so a row written before the
+ * field existed is still a correct row of this version rather than a stale one.
+ * Bumping for it would mark the whole catalog for re-measurement to gain
+ * something the station degrades over anyway. `tagGainDb` and friends arrived
+ * exactly this way.
+ *
+ * The host compares this against what it stored, so a plugin must report the
+ * version it actually produced rather than this constant, in case the two have
+ * drifted apart across an upgrade.
+ */
+export declare const ANALYSIS_SCHEMA_VERSION = 1;
+/**
+ * How the host asks about one track.
+ *
+ * Deliberately not a {@link TrackRef}: nothing here is matched by name, so
+ * artist and title would be decoration. What a measurement needs is bytes and a
+ * way to tell a truncation from a short record.
+ */
+export interface AnalysisRef {
+    /**
+     * The canonical catalog id for this track.
+     *
+     * Passed for the plugin's own logging and for its own caching, if it keeps
+     * any. It is not a key into anything the plugin can read, and the host does
+     * not expect it back.
+     */
+    trackId: string;
+    /**
+     * A complete, fetchable URL for the audio, resolved by the host.
+     *
+     * Carries its own authentication, exactly as the playout URLs do: whatever
+     * fetches this sends no headers on the host's behalf. It may be short-lived,
+     * so fetch it during the call rather than storing it.
+     *
+     * **It has to be reachable from wherever the decoding happens**, which is not
+     * necessarily where this plugin runs. An address that resolves inside the
+     * API process and not inside a sidecar container is the first thing to check
+     * when every analysis fails at once.
+     */
+    audioUrl: string;
+    /**
+     * How long the catalog believes the track is.
+     *
+     * A cross-check rather than an input to any measurement: audio that decodes
+     * to appreciably less than this was truncated, and measuring it would report
+     * a confident cold ending for a record that fades. Absent when the catalog
+     * never learned a duration, which is ordinary and is not a reason to refuse.
+     */
+    durationMs?: number;
+}
+/**
+ * The four points, all absolute offsets into the file.
+ *
+ * Including `cueOut`. Storing it relative to `cueIn` is the obvious-looking
+ * choice and it is wrong: everything downstream seeks in file time, so a relative
+ * figure has to be re-based at every read, and eventually one read does not.
+ *
+ * Two lengths fall out — `intro = introEnd - cueIn` and
+ * `outro = cueOut - outroStart` — and they are what a transition is actually
+ * sized from. Neither is stored, because a stored derivation is a second thing
+ * that can disagree with the first.
+ */
+export interface TrackCuePoints {
+    /** Where audio actually starts, past the leading silence. */
+    cueIn: number;
+    /**
+     * Where the record is fully underway: the beat established, or the vocal in.
+     *
+     * The talk-up limit, and one of the two points that is real work. A detector
+     * weighted to low frequencies places this early on a record that opens with
+     * a pad, which reads as "the intro is over" while it plainly is not.
+     */
+    introEnd: number;
+    /**
+     * Where the ending begins, so the earliest a blend may start.
+     *
+     * The other real one, and the one with a specific failure to design against:
+     * a low-frequency-weighted detector places it too early on a quiet ending,
+     * which is exactly the case an ending-aware transition exists to serve.
+     */
+    outroStart: number;
+    /** Where audio actually stops, before the trailing silence. */
+    cueOut: number;
+}
+/**
+ * How loud the record is, and how close it already runs to its ceiling.
+ *
+ * Every field is OPTIONAL, and absent is a real answer rather than a gap: a
+ * silent or near-silent track has no loudness, and the alternative to omitting
+ * it is a floor value like -80 that a caller would then "correct" by fifty
+ * decibels. Absent means no opinion, which is what every consumer of these
+ * measurements already has to handle.
+ *
+ * They are also optional in the weaker sense that an analyzer may not compute
+ * them at all. A plugin that only finds cue points is a valid analyzer; a
+ * station reading these has to degrade to its live normalizer, which is what it
+ * does today anyway.
+ */
+export interface TrackLoudness {
+    /**
+     * Gated programme loudness in LUFS, to ITU-R BS.1770.
+     *
+     * Gated, which is the whole difference between this and an average level: a
+     * record with a long quiet outro is as loud as its body, not as loud as its
+     * mean. The station's per-track gain is the distance from this to whatever
+     * target it holds.
+     */
+    integratedLufs?: number;
+    /**
+     * The highest inter-sample peak in dBTP, which is what caps a boost.
+     *
+     * Distinct from {@link samplePeakDb} and the distinction is the point: the
+     * reconstructed waveform between two samples can exceed both of them,
+     * routinely by around a decibel. A gain computed against sample peak alone
+     * is how a quiet master gets lifted into clipping, so this is the number a
+     * boost has to respect.
+     *
+     * Legitimately positive. A value above 0 dBTP means the master already
+     * overshoots on playback, which is worth knowing before adding anything.
+     */
+    truePeakDb?: number;
+    /**
+     * The highest actual sample, in dBFS.
+     *
+     * Carried alongside the true peak rather than instead of it, because the gap
+     * between them is diagnostic: a wide one means the master is already fighting
+     * its own ceiling.
+     */
+    samplePeakDb?: number;
+}
+/**
+ * What the FILE says about its own loudness, as opposed to what was measured.
+ *
+ * A different kind of claim from {@link TrackLoudness}, which is why it is a
+ * different interface: those fields are this analyzer's opinion, and these are
+ * whoever mastered or scanned the record telling the station what they decided.
+ * A consumer that prefers one over the other has to be able to tell them apart,
+ * which it cannot do if they arrive in the same field.
+ *
+ * All optional, and most files carry none of them.
+ */
+export interface TrackTaggedLoudness {
+    /**
+     * The gain the file's own tags ask for, in dB.
+     *
+     * **Meaningless without {@link tagReferenceLufs}**, and that is the whole
+     * reason both are reported. A gain is a correction relative to some level,
+     * and the two conventions in the wild are five decibels apart, so a station
+     * that stored only this would be storing the answer to a question it can no
+     * longer ask.
+     */
+    tagGainDb?: number;
+    /**
+     * The loudness {@link tagGainDb} is relative to, in LUFS.
+     *
+     * -23 for an R128 tag, where the specification fixes it. -18 for a
+     * ReplayGain tag, where it is an ASSUMPTION: ReplayGain 2.0 targets -18 and
+     * every current scanner writes it, but the older convention used the same
+     * tag names with no version field, so a file carrying it is
+     * indistinguishable from the outside.
+     *
+     * Subtracting this pair gives the loudness the tagger believed the record
+     * has, which is the figure a station's own target applies to.
+     */
+    tagReferenceLufs?: number;
+    /**
+     * The peak the file's tags declare, in dBFS.
+     *
+     * A SAMPLE peak, always, because that is what ReplayGain defines. It is not
+     * a substitute for {@link TrackLoudness.truePeakDb} and nothing should cap a
+     * boost with it; it is stored because the gap between the two says how hard
+     * the master is already running.
+     */
+    tagPeakDb?: number;
+}
+/**
+ * What one analysis produced.
+ *
+ * `data` is deliberately the only place measurements live, and the host stores
+ * it whole without reading the individual fields. That is what lets a later
+ * schema version add a beat grid or a vocal curve without touching the plugin
+ * contract, the host, or the database.
+ */
+export interface TrackAnalysis {
+    /**
+     * The shape of {@link data}, as this plugin actually produced it.
+     *
+     * Report what was measured rather than {@link ANALYSIS_SCHEMA_VERSION}: an
+     * adapter over a separate analyzer is reporting that analyzer's version, and
+     * the two drift the moment one of them is upgraded and the other is not. A
+     * version the host does not know is a configuration problem it can name,
+     * where a wrong one is a row nothing can read and nothing can explain.
+     */
+    schemaVersion: number;
+    /**
+     * Whether the whole file was measured.
+     *
+     * **Load-bearing, and the host cannot check it.** A byte-capped, idle-timed
+     * out or otherwise truncated download produces perfectly confident
+     * measurements of a file that was never the track, and the specific lie it
+     * tells is that a record which fades ended cold. Since the host never sees
+     * the bytes, this is the only signal that separates a measurement worth
+     * keeping from one worth discarding, and a plugin that always answers `true`
+     * has quietly disabled the check.
+     *
+     * A genuinely short track is `true`. A download that stopped early is
+     * `false`, and the two are told apart with {@link AnalysisRef.durationMs}
+     * where there is one.
+     */
+    complete: boolean;
+    /**
+     * The measurements, in the shape {@link schemaVersion} names.
+     *
+     * Typed as the v1 fields plus room to grow rather than as a closed
+     * interface, because the host passes it through unread. A v2 payload with a
+     * tempo and a downbeat grid is the same call, the same plugin method, and a
+     * different number above.
+     *
+     * The cue points are required and the loudness is not, which reflects what
+     * each costs to produce: the points come from the decode that has already
+     * happened, where loudness needs a filter chain an analyzer may reasonably
+     * not implement.
+     */
+    data: TrackCuePoints & TrackLoudness & TrackTaggedLoudness & Record<string, unknown>;
+    /**
+     * How long the audio turned out to be once decoded.
+     *
+     * The honest figure, as opposed to the catalog's claim in
+     * {@link AnalysisRef.durationMs}. Worth reporting even when the two agree:
+     * where they do not, this is the one that the offsets above are on the same
+     * timeline as.
+     */
+    durationMs?: number;
+    /**
+     * What did the measuring, as a name and version.
+     *
+     * Stored as provenance, so a row can be attributed after the fact when a
+     * detector turns out to have been wrong about a class of records. Free-text
+     * and never parsed.
+     */
+    analyzer?: string;
+}
+/** A plugin that can measure a track's audio. */
+export interface AnalysisProvider extends PluginLifecycle {
+    /**
+     * Measure one track.
+     *
+     * One track per call, with no batch sibling: the unit of work is one file's
+     * bytes, and there is no upstream round trip to amortise across several. How
+     * many run at once is the host's decision, taken against hardware it can see
+     * and this plugin cannot.
+     *
+     * Expect to be given minutes rather than seconds — decoding a full record is
+     * not a request, it is a job — but honour `host.signal` all the same, because
+     * a station shutting down should not wait on a measurement nobody will read.
+     *
+     * @throws {PluginError} `config` when the plugin is not set up enough to try
+     *   (no analyzer address), `upstream` when the audio could not be fetched or
+     *   could not be decoded, `timeout` when the analyzer did not answer.
+     */
+    analyzeTrack(ref: AnalysisRef): Promise<TrackAnalysis>;
+}
+//# sourceMappingURL=analysis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../src/capabilities/analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;OAWG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,cAAc;IAC3B,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;;;;;OAQG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;OAYG;IACH,IAAI,EAAE,cAAc,GAAG,aAAa,GAAG,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErF;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,iDAAiD;AACjD,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACrD;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC1D"}