@mango-iiif/av 0.0.1

package/dist/controller-element-BOKM9v2S.d.ts

@@ -0,0 +1,15 @@
+import { h as AVPlayerController, i as AVPlayerEventMap } from './controller-DLy38ais.js';
+
+declare const HTMLElementBase: typeof HTMLElement;
+declare abstract class AVControllerElement extends HTMLElementBase {
+    #private;
+    get controller(): AVPlayerController;
+    set controller(value: AVPlayerController);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected get controllerEvents(): Array<keyof AVPlayerEventMap>;
+    protected abstract controllerChanged(): void;
+    protected abstract handleControllerEvent<K extends keyof AVPlayerEventMap>(type: K, event: CustomEvent<AVPlayerEventMap[K]>): void;
+}
+
+export { AVControllerElement as A };

package/dist/core.d.ts

@@ -0,0 +1,28 @@
+import { l as AVStrings, J as JsonObject, e as AVManifest, u as TranscriptResource, s as TranscriptCue, r as TimeSpan } from './controller-DLy38ais.js';
+export { A as AVAnnotation, a as AVAnnotationAdapter, b as AVAnnotationDraft, c as AVCanvas, d as AVControlsConfig, f as AVPanelsConfig, g as AVPlayerConfig, h as AVPlayerController, i as AVPlayerEventMap, j as AVPlayerState, k as AVResumeConfig, m as AVTranscriptConfig, n as AuthService, C as Chapter, D as DownloadResource, I as IIIFPresentationVersion, L as LocalizedValue, M as MediaKind, o as MediaSource, p as MetadataEntry, T as TextTrack, q as TextTrackKind, t as TranscriptCueType, v as defaultConfig, w as defaultStrings } from './controller-DLy38ais.js';
+
+interface NormalizeOptions {
+    fetch?: typeof globalThis.fetch;
+    requestInit?: RequestInit;
+    preferredLanguages?: string[];
+    loadExternalAnnotations?: boolean;
+    strings?: Partial<AVStrings>;
+}
+declare const normalizeManifest: (input: JsonObject | string, options?: NormalizeOptions) => Promise<AVManifest>;
+
+interface TranscriptParseOptions {
+    showNotes?: boolean;
+    showMetadata?: boolean;
+}
+declare const parseTimedText: (input: string, format: "vtt" | "srt", options?: TranscriptParseOptions) => TranscriptCue[];
+declare const parseTranscript: (input: string | unknown, format: string, options?: TranscriptParseOptions) => TranscriptCue[];
+declare const loadTranscript: (resource: TranscriptResource, options?: TranscriptParseOptions & {
+    fetch?: typeof globalThis.fetch;
+    requestInit?: RequestInit;
+}) => Promise<TranscriptCue[]>;
+
+declare const parseTime: (value: string | number | undefined) => number | undefined;
+declare const parseTemporalFragment: (target: unknown) => TimeSpan | undefined;
+declare const formatTime: (seconds: number) => string;
+
+export { AVManifest, AVStrings, JsonObject, type NormalizeOptions, TimeSpan, TranscriptCue, TranscriptResource, formatTime, loadTranscript, normalizeManifest, parseTemporalFragment, parseTime, parseTimedText, parseTranscript };

package/dist/core.js

@@ -0,0 +1,28 @@
+import "./chunk-GAVG7CPU.js";
+import {
+  loadTranscript,
+  parseTimedText,
+  parseTranscript
+} from "./chunk-3LLEY7MA.js";
+import {
+  AVPlayerController,
+  defaultConfig,
+  defaultStrings,
+  formatTime,
+  normalizeManifest,
+  parseTemporalFragment,
+  parseTime
+} from "./chunk-R4OUWZ3R.js";
+export {
+  AVPlayerController,
+  defaultConfig,
+  defaultStrings,
+  formatTime,
+  loadTranscript,
+  normalizeManifest,
+  parseTemporalFragment,
+  parseTime,
+  parseTimedText,
+  parseTranscript
+};
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { MangoAVAnnotationsElement } from './annotations.js';
+export { defineMangoAVAnnotations } from './annotations.js';
+import { MangoAVTranscriptElement } from './transcript-element.js';
+export { defineMangoAVTranscript } from './transcript-element.js';
+import { MangoAVChaptersElement } from './chapters.js';
+export { defineMangoAVChapters } from './chapters.js';
+import { MangoAVPlayerElement } from './player.js';
+export { defineMangoAVPlayer } from './player.js';
+import { MangoAVMediaElement } from './media.js';
+export { defineMangoAVMedia } from './media.js';
+export { A as AVAnnotation, a as AVAnnotationAdapter, b as AVAnnotationDraft, c as AVCanvas, d as AVControlsConfig, e as AVManifest, f as AVPanelsConfig, g as AVPlayerConfig, h as AVPlayerController, i as AVPlayerEventMap, j as AVPlayerState, k as AVResumeConfig, l as AVStrings, m as AVTranscriptConfig, n as AuthService, C as Chapter, D as DownloadResource, I as IIIFPresentationVersion, J as JsonObject, L as LocalizedValue, M as MediaKind, o as MediaSource, p as MetadataEntry, T as TextTrack, q as TextTrackKind, r as TimeSpan, s as TranscriptCue, t as TranscriptCueType, u as TranscriptResource, v as defaultConfig, w as defaultStrings } from './controller-DLy38ais.js';
+export { NormalizeOptions, formatTime, loadTranscript, normalizeManifest, parseTemporalFragment, parseTime, parseTimedText, parseTranscript } from './core.js';
+import './controller-element-BOKM9v2S.js';
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'mango-av-media': MangoAVMediaElement;
+        'mango-av-player': MangoAVPlayerElement;
+        'mango-av-chapters': MangoAVChaptersElement;
+        'mango-av-transcript': MangoAVTranscriptElement;
+        'mango-av-annotations': MangoAVAnnotationsElement;
+    }
+}
+
+export { MangoAVAnnotationsElement, MangoAVChaptersElement, MangoAVMediaElement, MangoAVPlayerElement, MangoAVTranscriptElement };

package/dist/index.js

@@ -0,0 +1,70 @@
+import {
+  MangoAVAnnotationsElement,
+  defineMangoAVAnnotations
+} from "./chunk-IFTSCRCU.js";
+import {
+  MangoAVChaptersElement,
+  defineMangoAVChapters
+} from "./chunk-YH6DS7J6.js";
+import "./chunk-GAVG7CPU.js";
+import {
+  MangoAVMediaElement,
+  defineMangoAVMedia
+} from "./chunk-GX7UU6V4.js";
+import {
+  MangoAVPlayerElement,
+  defineMangoAVPlayer
+} from "./chunk-ML77YRJL.js";
+import "./chunk-NTHMZZYJ.js";
+import {
+  MangoAVTranscriptElement,
+  defineMangoAVTranscript
+} from "./chunk-PZ6GV6ZJ.js";
+import "./chunk-CDLYT3KB.js";
+import {
+  loadTranscript,
+  parseTimedText,
+  parseTranscript
+} from "./chunk-3LLEY7MA.js";
+import "./chunk-JXUHKKIX.js";
+import {
+  AVPlayerController,
+  defaultConfig,
+  defaultStrings,
+  formatTime,
+  normalizeManifest,
+  parseTemporalFragment,
+  parseTime
+} from "./chunk-R4OUWZ3R.js";
+
+// src/index.ts
+if (typeof window !== "undefined" && "customElements" in window) {
+  defineMangoAVMedia();
+  defineMangoAVPlayer();
+  defineMangoAVChapters();
+  defineMangoAVTranscript();
+  defineMangoAVAnnotations();
+}
+export {
+  AVPlayerController,
+  MangoAVAnnotationsElement,
+  MangoAVChaptersElement,
+  MangoAVMediaElement,
+  MangoAVPlayerElement,
+  MangoAVTranscriptElement,
+  defaultConfig,
+  defaultStrings,
+  defineMangoAVAnnotations,
+  defineMangoAVChapters,
+  defineMangoAVMedia,
+  defineMangoAVPlayer,
+  defineMangoAVTranscript,
+  formatTime,
+  loadTranscript,
+  normalizeManifest,
+  parseTemporalFragment,
+  parseTime,
+  parseTimedText,
+  parseTranscript
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './core';\nexport { defineMangoAVMedia, MangoAVMediaElement } from './components/mango-av-media';\nexport { defineMangoAVPlayer, MangoAVPlayerElement } from './components/mango-av-player';\nexport { defineMangoAVChapters, MangoAVChaptersElement } from './components/mango-av-chapters';\nexport { defineMangoAVTranscript, MangoAVTranscriptElement } from './components/mango-av-transcript';\nexport { defineMangoAVAnnotations, MangoAVAnnotationsElement } from './components/mango-av-annotations';\n\nimport { defineMangoAVMedia } from './components/mango-av-media';\nimport { defineMangoAVPlayer } from './components/mango-av-player';\nimport { defineMangoAVChapters } from './components/mango-av-chapters';\nimport { defineMangoAVTranscript } from './components/mango-av-transcript';\nimport { defineMangoAVAnnotations } from './components/mango-av-annotations';\n\nif (typeof window !== 'undefined' && 'customElements' in window) {\n  defineMangoAVMedia();\n  defineMangoAVPlayer();\n  defineMangoAVChapters();\n  defineMangoAVTranscript();\n  defineMangoAVAnnotations();\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    'mango-av-media': import('./components/mango-av-media').MangoAVMediaElement;\n    'mango-av-player': import('./components/mango-av-player').MangoAVPlayerElement;\n    'mango-av-chapters': import('./components/mango-av-chapters').MangoAVChaptersElement;\n    'mango-av-transcript': import('./components/mango-av-transcript').MangoAVTranscriptElement;\n    'mango-av-annotations': import('./components/mango-av-annotations').MangoAVAnnotationsElement;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,IAAI,OAAO,WAAW,eAAe,oBAAoB,QAAQ;AAC/D,qBAAmB;AACnB,sBAAoB;AACpB,wBAAsB;AACtB,0BAAwB;AACxB,2BAAyB;AAC3B;","names":[]}

package/dist/media.d.ts

@@ -0,0 +1,28 @@
+import { h as AVPlayerController, J as JsonObject, g as AVPlayerConfig, e as AVManifest, c as AVCanvas } from './controller-DLy38ais.js';
+
+declare const HTMLElementBase: typeof HTMLElement;
+declare class MangoAVMediaElement extends HTMLElementBase {
+    #private;
+    static observedAttributes: string[];
+    readonly player: AVPlayerController;
+    constructor();
+    get manifest(): JsonObject | string | undefined;
+    get controller(): AVPlayerController;
+    set manifest(value: JsonObject | string | undefined);
+    get config(): AVPlayerConfig;
+    set config(value: AVPlayerConfig);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    load(input: JsonObject | string): Promise<AVManifest>;
+    play(): Promise<void>;
+    pause(): void;
+    seekTo(time: number): void;
+    selectCanvas(indexOrId: number | string, options?: {
+        time?: number;
+        autoplay?: boolean;
+    }): AVCanvas | undefined;
+}
+declare const defineMangoAVMedia: (tagName?: string) => typeof MangoAVMediaElement;
+
+export { MangoAVMediaElement, defineMangoAVMedia };

package/dist/media.js

@@ -0,0 +1,16 @@
+import {
+  MangoAVMediaElement,
+  defineMangoAVMedia
+} from "./chunk-GX7UU6V4.js";
+import "./chunk-NTHMZZYJ.js";
+import "./chunk-CDLYT3KB.js";
+import "./chunk-3LLEY7MA.js";
+import "./chunk-R4OUWZ3R.js";
+
+// src/media.ts
+if (typeof window !== "undefined" && "customElements" in window) defineMangoAVMedia();
+export {
+  MangoAVMediaElement,
+  defineMangoAVMedia
+};
+//# sourceMappingURL=media.js.map

package/dist/media.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/media.ts"],"sourcesContent":["export { defineMangoAVMedia, MangoAVMediaElement } from './components/mango-av-media';\n\nimport { defineMangoAVMedia } from './components/mango-av-media';\nif (typeof window !== 'undefined' && 'customElements' in window) defineMangoAVMedia();\n"],"mappings":";;;;;;;;;;AAGA,IAAI,OAAO,WAAW,eAAe,oBAAoB,OAAQ,oBAAmB;","names":[]}

package/dist/player.d.ts

@@ -0,0 +1,27 @@
+import { A as AVControllerElement } from './controller-element-BOKM9v2S.js';
+import { J as JsonObject, g as AVPlayerConfig, e as AVManifest, c as AVCanvas, i as AVPlayerEventMap } from './controller-DLy38ais.js';
+
+declare class MangoAVPlayerElement extends AVControllerElement {
+    #private;
+    static observedAttributes: string[];
+    constructor();
+    get manifest(): JsonObject | string | undefined;
+    set manifest(value: JsonObject | string | undefined);
+    get config(): AVPlayerConfig;
+    set config(value: AVPlayerConfig);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    load(input: JsonObject | string): Promise<AVManifest>;
+    play(): Promise<void>;
+    pause(): void;
+    seekTo(time: number): void;
+    selectCanvas(indexOrId: number | string, options?: {
+        time?: number;
+        autoplay?: boolean;
+    }): AVCanvas | undefined;
+    protected controllerChanged(): void;
+    protected handleControllerEvent<K extends keyof AVPlayerEventMap>(type: K, event: CustomEvent<AVPlayerEventMap[K]>): void;
+}
+declare const defineMangoAVPlayer: (tagName?: string) => typeof MangoAVPlayerElement;
+
+export { MangoAVPlayerElement, defineMangoAVPlayer };

package/dist/player.js

@@ -0,0 +1,15 @@
+import {
+  MangoAVPlayerElement,
+  defineMangoAVPlayer
+} from "./chunk-ML77YRJL.js";
+import "./chunk-NTHMZZYJ.js";
+import "./chunk-JXUHKKIX.js";
+import "./chunk-R4OUWZ3R.js";
+
+// src/player.ts
+if (typeof window !== "undefined" && "customElements" in window) defineMangoAVPlayer();
+export {
+  MangoAVPlayerElement,
+  defineMangoAVPlayer
+};
+//# sourceMappingURL=player.js.map

package/dist/player.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/player.ts"],"sourcesContent":["export { defineMangoAVPlayer, MangoAVPlayerElement } from './components/mango-av-player';\n\nimport { defineMangoAVPlayer } from './components/mango-av-player';\nif (typeof window !== 'undefined' && 'customElements' in window) defineMangoAVPlayer();\n"],"mappings":";;;;;;;;;AAGA,IAAI,OAAO,WAAW,eAAe,oBAAoB,OAAQ,qBAAoB;","names":[]}

package/dist/transcript-element.d.ts

@@ -0,0 +1,12 @@
+import { A as AVControllerElement } from './controller-element-BOKM9v2S.js';
+import { i as AVPlayerEventMap } from './controller-DLy38ais.js';
+
+declare class MangoAVTranscriptElement extends AVControllerElement {
+    #private;
+    constructor();
+    protected controllerChanged(): void;
+    protected handleControllerEvent<K extends keyof AVPlayerEventMap>(type: K, _event: CustomEvent<AVPlayerEventMap[K]>): void;
+}
+declare const defineMangoAVTranscript: (tagName?: string) => typeof MangoAVTranscriptElement;
+
+export { MangoAVTranscriptElement, defineMangoAVTranscript };

package/dist/transcript-element.js

@@ -0,0 +1,16 @@
+import {
+  MangoAVTranscriptElement,
+  defineMangoAVTranscript
+} from "./chunk-PZ6GV6ZJ.js";
+import "./chunk-CDLYT3KB.js";
+import "./chunk-3LLEY7MA.js";
+import "./chunk-JXUHKKIX.js";
+import "./chunk-R4OUWZ3R.js";
+
+// src/transcript-element.ts
+if (typeof window !== "undefined" && "customElements" in window) defineMangoAVTranscript();
+export {
+  MangoAVTranscriptElement,
+  defineMangoAVTranscript
+};
+//# sourceMappingURL=transcript-element.js.map

package/dist/transcript-element.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transcript-element.ts"],"sourcesContent":["export { defineMangoAVTranscript, MangoAVTranscriptElement } from './components/mango-av-transcript';\n\nimport { defineMangoAVTranscript } from './components/mango-av-transcript';\nif (typeof window !== 'undefined' && 'customElements' in window) defineMangoAVTranscript();\n"],"mappings":";;;;;;;;;;AAGA,IAAI,OAAO,WAAW,eAAe,oBAAoB,OAAQ,yBAAwB;","names":[]}

package/docs/API.md

@@ -0,0 +1,264 @@
+# API reference
+
+## Entry points
+
+- `@mango-iiif/av` exports the complete API and registers all Mango AV custom elements in a browser.
+- `@mango-iiif/av/core` exports parsing, types, transcript helpers, and `AVPlayerController` without registering a custom element.
+- `@mango-iiif/av/media`, `/player`, `/chapters`, `/transcript`, and `/annotations` register and export only the selected element.
+
+## Components
+
+| Element | Purpose |
+| --- | --- |
+| `<mango-av-media>` | Complete precomposed player, navigation, transcript, annotations, metadata, and files. |
+| `<mango-av-player>` | Media Chrome audio/video playback and Canvas/source controls only. |
+| `<mango-av-chapters>` | Independently placeable structured Range navigation. |
+| `<mango-av-transcript>` | Independently placeable synchronized transcript, selector, search, and download UI. |
+| `<mango-av-annotations>` | Independently placeable synchronized annotation UI. |
+
+## `<mango-av-media>`
+
+### Attributes
+
+| Attribute | Type | Purpose |
+| --- | --- | --- |
+| `manifest-url` | URL | Fetch and load a IIIF Presentation 2 or 3 Manifest. |
+| `config` | JSON string | Set JSON-compatible `AVPlayerConfig` fields. Function hooks must be assigned through the property API. |
+
+### Properties and methods
+
+| Member | Type | Purpose |
+| --- | --- | --- |
+| `manifest` | `JsonObject \| string` | Manifest object, raw JSON, or URL. Setting it loads the resource. |
+| `config` | `AVPlayerConfig` | Runtime configuration, including callbacks. |
+| `controller` | `AVPlayerController` | Shared state and playback controller. The legacy `player` alias exposes the same instance. |
+| `load(input)` | `Promise<AVManifest>` | Load and normalize a manifest. |
+| `play()` | `Promise<void>` | Begin playback. |
+| `pause()` | `void` | Pause playback. |
+| `seekTo(seconds)` | `void` | Seek within the active source/segment. |
+| `selectCanvas(indexOrId, options?)` | `AVCanvas \| undefined` | Change Canvas and optionally seek/autoplay. |
+
+### Slots
+
+| Slot | Location |
+| --- | --- |
+| `header` | Replaces the default manifest title and summary. |
+| `before-player` | Before the Media Chrome controller. |
+| `player-overlay` | Inside the Media Chrome controller, above media. |
+| `controls` | Replaces the default Media Chrome controls and menus. |
+| `after-player` | After the player and toolbar. |
+
+## Standalone components
+
+Every standalone component has a `controller: AVPlayerController` property. Assign the same controller instance to any components that should synchronize:
+
+```ts
+const controller = new AVPlayerController();
+
+player.controller = controller;
+chapters.controller = controller;
+transcript.controller = controller;
+annotations.controller = controller;
+
+await controller.load(manifest);
+```
+
+The elements can be in unrelated parts of the document or application component tree. Communication occurs through the controller rather than DOM ancestry.
+
+Use one `<mango-av-player>` per controller because the controller attaches to one active media element. Any number of chapters, transcript, annotations, or application-owned views can share it.
+
+Use the component subpath entry points when an application should bundle only selected UI elements:
+
+```ts
+import '@mango-iiif/av/player';
+import '@mango-iiif/av/chapters';
+import '@mango-iiif/av/transcript';
+```
+
+Subscribe to the same typed event stream from application code with `controller.on()`:
+
+```ts
+const unsubscribe = controller.on('av-canvaschange', (event) => {
+  console.log(event.detail.canvas, event.detail.canvasIndex);
+});
+
+unsubscribe();
+```
+
+## Translations
+
+`AVPlayerConfig.strings` accepts `Partial<AVStrings>`. Overrides are merged with `defaultStrings`, so a translation can be introduced incrementally and all unspecified strings remain English.
+
+```ts
+import { AVPlayerController, defaultStrings, type AVStrings } from '@mango-iiif/av/core';
+
+const welsh: Partial<AVStrings> = {
+  chapters: 'Penodau',
+  transcript: 'Trawsgrifiad',
+  previous: 'Blaenorol',
+  next: 'Nesaf',
+  sourceNumber: 'Ffynhonnell {number}',
+  resumePrompt: 'Parhau o {time}?',
+};
+
+const controller = new AVPlayerController({
+  preferredLanguages: ['cy', 'en', 'none'],
+  strings: welsh,
+});
+```
+
+The placeholders `{number}`, `{time}`, `{status}`, `{statusText}`, and `{type}` are retained until rendering. Translation values can therefore be supplied through either the TypeScript API or the JSON `config` attribute. `controller.configure({ strings })` updates all connected components and emits `av-configchange`.
+
+String keys cover:
+
+- panel, navigation, download, search, resume, and accessibility labels;
+- loading, error, and empty states;
+- generated IIIF fallback labels such as `sourceNumber`, `transcriptNumber`, `sectionNumber`, `chapterNumber`, and `untitledManifest`.
+
+`preferredLanguages` separately controls which language is selected from IIIF language maps. It is also applied to Media Chrome's `lang` attribute. German, Spanish, French, Portuguese, Simplified Chinese, and Traditional Chinese Media Chrome dictionaries are loaded automatically when selected; custom Mango AV strings work with any language.
+
+### `<mango-av-player>`
+
+The standalone player supports `manifest`, `config`, `load`, `play`, `pause`, `seekTo`, and `selectCanvas`, as well as the `manifest-url` and JSON `config` attributes. Its slots are `overlay` and `controls`.
+
+### `<mango-av-chapters>`
+
+Renders nested IIIF Ranges. Selecting a chapter calls `controller.selectCanvas()` and emits the bubbling `av-chapterselect` DOM event.
+
+### `<mango-av-transcript>`
+
+Loads the active Canvas transcript and follows controller time. Selecting a timed cue calls `controller.seekTo()` and `controller.play()`. It emits `av-transcriptcueselect` and `av-transcriptsearch`. The heading can be replaced through the `heading` slot.
+
+### `<mango-av-annotations>`
+
+Renders and follows the active Canvas annotations. Selecting a timed annotation calls `controller.seekTo()` and `controller.play()`. It emits `av-annotationselect`. The heading can be replaced through the `heading` slot.
+
+### CSS custom properties
+
+| Property | Default |
+| --- | --- |
+| `--mango-av-accent` | `#5b3fd6` |
+| `--mango-av-accent-contrast` | `#fff` |
+| `--mango-av-background` | `#fff` |
+| `--mango-av-surface` | `#f5f5f8` |
+| `--mango-av-text` | `#18181b` |
+| `--mango-av-muted` | `#62626a` |
+| `--mango-av-border` | `#d7d7de` |
+| `--mango-av-radius` | `.65rem` |
+| `--mango-av-font` | system sans-serif |
+| `--mango-av-panel-width` | `24rem` |
+| `--mango-av-player-aspect-ratio` | `16 / 9` |
+
+Media Chrome's own public variables remain available and can override the mapped defaults.
+
+## `AVPlayerConfig`
+
+```ts
+interface AVPlayerConfig {
+  controls?: {
+    seek?: boolean;
+    volume?: boolean;
+    captions?: boolean;
+    playbackRate?: boolean;
+    pictureInPicture?: boolean;
+    fullscreen?: boolean;
+    sourceSelector?: boolean;
+    download?: boolean;
+    skipSeconds?: number;
+  };
+  panels?: {
+    chapters?: boolean;
+    transcript?: boolean;
+    annotations?: boolean;
+    metadata?: boolean;
+    supplementalFiles?: boolean;
+  };
+  transcript?: {
+    autoScroll?: boolean;
+    search?: boolean;
+    download?: boolean;
+    showNotes?: boolean;
+    showMetadata?: boolean;
+    showSearchMarkers?: boolean;
+  };
+  resume?: {
+    enabled?: boolean;
+    maxItems?: number;
+    ttlDays?: number;
+    prompt?: boolean;
+  };
+  strings?: Partial<AVStrings>;
+  preferredLanguages?: string[];
+  autoAdvance?: boolean;
+  repeat?: boolean;
+  startCanvasId?: string;
+  startTime?: number;
+  activePanel?: 'chapters' | 'transcript' | 'annotations' | 'metadata' | 'files' | 'none';
+  crossorigin?: 'anonymous' | 'use-credentials' | '';
+  preload?: 'none' | 'metadata' | 'auto';
+  playbackRates?: number[];
+  fetch?: typeof globalThis.fetch;
+  requestInit?: RequestInit;
+  resolveRequest?: (url, context) => string | Promise<string>;
+  annotationAdapter?: AVAnnotationAdapter;
+}
+```
+
+`fetch` and `requestInit` configure manifest, external AnnotationPage, and transcript requests. `resolveRequest` runs immediately before a media URL is assigned; it can obtain an IIIF Auth token, sign a URL, route through a proxy, or enforce an application's access policy. The normalized Canvas exposes discovered auth services to the callback through `context.canvas.authServices`.
+
+`annotationAdapter` connects create/update/delete to the host's persistence API:
+
+```ts
+media.config = {
+  annotationAdapter: {
+    create: async (canvas, draft) => api.create(canvas.id, draft),
+    update: async (canvas, annotation) => api.update(canvas.id, annotation),
+    remove: async (canvas, annotation) => api.remove(canvas.id, annotation.id),
+  },
+};
+
+await media.controller.createAnnotation({
+  text: 'Important passage',
+  time: { start: 12, end: 18 },
+  motivation: ['highlighting'],
+});
+```
+
+If no adapter is supplied, annotation mutations are local for the current session.
+
+## `AVPlayerController`
+
+Playback methods:
+
+- `load`, `attachMedia`, `detachMedia`, and `destroy`
+- `play`, `pause`, `stop`, `seekTo`, and `seekBy`
+- `selectCanvas`, `next`, `previous`, and `selectSource`
+- `setAutoAdvance` and `setRepeat`
+- `getSavedPosition` and `resolvedSourceUrl`
+- `createAnnotation`, `updateAnnotation`, and `removeAnnotation`
+- `on(event, listener)`, which returns an unsubscribe function
+
+Read-only properties are `config`, `state`, `manifest`, `canvas`, `source`, and `media`.
+
+## Events
+
+`AVPlayerController` is the canonical cross-component event bus. It emits the events below to every component sharing that instance. `<mango-av-media>` and `<mango-av-player>` also expose controller events as bubbling, composed DOM `CustomEvent`s for host application integration.
+
+| Event | Detail |
+| --- | --- |
+| `av-loadstart` | Input source |
+| `av-ready` | Normalized manifest |
+| `av-error` | `Error` |
+| `av-canvaschange` | Canvas and index |
+| `av-sourcechange` | Media source and index |
+| `av-play`, `av-pause`, `av-ended` | Canvas ID and playback position where applicable |
+| `av-timeupdate`, `av-seek` | Timeline values |
+| `av-annotationschange` | Active Canvas annotation list |
+| `av-configchange` | Resolved controller configuration |
+| `av-statechange` | Complete `AVPlayerState` snapshot |
+
+## Parsing helpers
+
+`normalizeManifest(input, options)` is the version boundary. It returns the same `AVManifest` model for IIIF Presentation 2 and 3.
+
+`parseTimedText`, `parseTranscript`, and `loadTranscript` support WebVTT, SRT, plain text, and structured JSON. `parseTime`, `parseTemporalFragment`, and `formatTime` are also public.

package/docs/FEATURE_PARITY.md

@@ -0,0 +1,43 @@
+# Feature coverage
+
+This document records the audio, video, IIIF, transcript, annotation, and integration behavior implemented in `@mango-iiif/av`.
+
+| Capability | `@mango-iiif/av` implementation | Verification |
+| --- | --- | --- |
+| Root IIIF player with URL/object input | `<mango-av-media>` and `AVPlayerController.load` | Unit + browser |
+| Video and audio playback | Native media elements inside Media Chrome | Browser |
+| HLS | `<hls-video>` with native HLS/hls.js fallback | Browser demo |
+| Multiple media resources and quality/source selection | Normalized `Choice`/body list and source selector | Unit |
+| Multi-Canvas playback | Previous, next, Canvas selection, state events | Unit + browser |
+| Temporal Canvas/source clipping | `#t=` normalization and segment enforcement | Unit |
+| Custom start Canvas/time | Presentation 2 `startCanvas`, Presentation 3 `start`, and config overrides | Unit |
+| Auto-advance and repeat | Manifest behavior plus runtime toggle/API | Unit/controller |
+| Structured navigation | Recursive Presentation 2/3 Range model and accessible chapter buttons | Unit + browser |
+| Transcripts | Inline/external transcript resources and synchronized panel | Unit + browser |
+| Transcript formats | WebVTT, SRT, text, JSON, and inline TextualBody; DOCX is intentionally excluded | Unit |
+| Transcript selector/search/download | Configurable transcript tools | Browser |
+| Transcript auto-scroll | Active cue tracking against controller time | Browser |
+| Captions/subtitles/descriptions | Native tracks and Media Chrome captions menu | Parser unit + browser |
+| Time-synchronized annotations | Commenting, supplementing, transcribing, tagging, and highlighting display | Unit + browser |
+| Marker create/edit/delete endpoints | Typed `annotationAdapter` and controller mutation API | Controller API |
+| Metadata display | Manifest + Canvas metadata, rights, and required statement | Parser unit + browser |
+| Supplemental files | Manifest + Canvas `rendering` downloads | Parser unit + browser |
+| Resume playback | Bounded, expiring local-storage cache with optional prompt | Controller/browser |
+| IIIF Auth integration | Auth service discovery plus configurable fetch/request resolver | Parser unit/API |
+| Poster/placeholder | Presentation 3 `placeholderCanvas` extraction | Parser |
+| Responsive layout and accessibility | Responsive panel, native controls, ARIA tabs/navigation, keyboard-native buttons | Playwright |
+| Standalone usage | Complete and independently placeable framework-free elements plus controller-only entry point | Build/pack |
+| Configurable appearance | CSS properties, named slots, Media Chrome variables, live style recipes | Playwright/demo |
+
+## Deliberate API differences
+
+- React Context and React component props are replaced by a typed controller and DOM events.
+- Video.js-specific plugin APIs are replaced by standard `HTMLMediaElement` methods and Media Chrome controls.
+- Playlist marker mutations use `annotationAdapter`, allowing REST, GraphQL, local-first, or authenticated persistence.
+- Protected-resource policy remains with the consuming application through `fetch`, `requestInit`, and `resolveRequest`; the package does not hard-code a login provider or token transport.
+- Styling uses stable host-level custom properties and slots rather than component SCSS overrides.
+- DOCX/Word transcript parsing is intentionally out of scope; the loader rejects it explicitly.
+
+## Additional IIIF behavior
+
+The normalized model also preserves Presentation version, Canvas behaviors, audio-description tracks, nested Ranges, required statements, rights, homepages, auth services, source dimensions/duration, and machine-generated transcript flags. Unknown motivations and behaviors are retained as strings so extensions remain available to host applications.