libaribhtml5 0.1.4 → 0.1.7

package/dist/types/device-identifier.d.ts

@@ -1,4 +1,7 @@
 /** Current demo receiver identifier (48-bit hexadecimal ACAS source value). */
 export declare const DEFAULT_RECEIVER_DEVICE_IDENTIFIER = "4194c4ae4730";
+/** Legacy BML browser.getIRDID() type used for the receiver/CAS identifier. */
+export declare const RECEIVER_IRD_ID_TYPE = 5;
+export declare function getDefaultReceiverIrdId(type: number): string | null;
 export type ReceiverDeviceIdentifierProvider = (kind: number) => string | null | undefined | Promise<string | null | undefined>;
 export declare function resolveReceiverDeviceIdentifier(kind: number, provider?: ReceiverDeviceIdentifierProvider): Promise<string>;

package/dist/types/iframe-input.d.ts

@@ -0,0 +1,4 @@
+type PointerTransparentIframe = Pick<HTMLIFrameElement, 'inert' | 'style' | 'tabIndex'>;
+/** Keep the application plane visible without making it an input or focus target. */
+export declare function makeIframePointerTransparent(iframe: PointerTransparentIframe): void;
+export {};

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export { AribReceiverHost } from './receiver-host';
 export type { AribApplicationInformation, AribApplicationReplaceHandler, AribApplicationReplaceRequest, AribCaptionPacket, AribBroadcastClock, AribExitManagedStateHandler, AribReceiverLifecycleEvent, AribReceiverHostOptions, } from './receiver-host';
+export type { AribApplicationPresentationState, AribViewerParticipationEvent, AribViewerParticipationNotification, } from './viewer-participation';
 export { BehindIframeMediaPlaneAdapter, DomObjectMediaPlaneAdapter, } from './media-plane';
 export type { AribMediaPlane, AribMediaPlaneAdapter, AribMediaPlaneLayer, AribMediaPlaneStackEntry, AribMediaPlaneUnmountReason, AribVideoPlane, BehindIframeMediaPlaneAdapterOptions, DomObjectMediaPlaneAdapterOptions, } from './media-plane';
 export { installRuntime } from './runtime/install';
@@ -9,9 +10,12 @@ export { cloneProgramInfo } from './program-info';
 export type { ProgramInfo } from './program-info';
 export { runtimeEventMatchesSelector } from './runtime/stream-event';
 export type { RuntimeEvent, RuntimeEventSelector, RuntimeEventSource, } from './runtime/stream-event';
-export type { RuntimeApplicationInformation, RuntimeOptions, RuntimeWindow, } from './runtime/install';
-export { DEFAULT_RECEIVER_DEVICE_IDENTIFIER, resolveReceiverDeviceIdentifier, } from './device-identifier';
+export type { AribPermissionManagedArea, RuntimeApplicationInformation, RuntimePermissionManagedArea, RuntimeOptions, RuntimeWindow, } from './runtime/install';
+export { ARIB_PERMISSION_BITS, AribApplicationBoundaryPolicy, } from './runtime/application-boundary';
+export type { AribPermissionBit, AribPermissionEvaluation, } from './runtime/application-boundary';
+export { DEFAULT_RECEIVER_DEVICE_IDENTIFIER, getDefaultReceiverIrdId, RECEIVER_IRD_ID_TYPE, resolveReceiverDeviceIdentifier, } from './device-identifier';
 export type { ReceiverDeviceIdentifierProvider } from './device-identifier';
+export { normalizeLctBackgroundColor } from './layout';
 export type { BroadcastResourceCacheEvent, BroadcastResourceCacheListener, BroadcastResourceChange, BroadcastResourceStore, } from './runtime/resources';
 export { installBroadcastClock } from './runtime/clock';
 export type { BroadcastNowProvider } from './runtime/clock';

package/dist/types/layout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert the ARIB STD-B60 24-bit LCT background colour to a CSS colour.
+ * A null value removes the current LCT override and restores host fallback
+ * selection.
+ */
+export declare function normalizeLctBackgroundColor(value: number | null): string | null;
+export declare function resolveReceiverBackgroundColor(lctColor: string | null, stageColor: string | null): string;

package/dist/types/receiver/canvas-controller.d.ts

@@ -0,0 +1,30 @@
+type ReceiverCanvasSize = {
+    width: number;
+    height: number;
+};
+type CanvasResizeObserver = Pick<ResizeObserver, 'observe' | 'disconnect'>;
+type ReceiverCanvasControllerOptions = {
+    iframe: HTMLIFrameElement;
+    viewport: HTMLElement;
+    createResizeObserver?: (callback: ResizeObserverCallback) => CanvasResizeObserver;
+};
+/** Owns receiver-canvas geometry and background selection for the host facade. */
+export declare class ReceiverCanvasController {
+    private readonly iframe;
+    private readonly viewport;
+    private readonly resizeObserver;
+    private logicalWidth;
+    private logicalHeight;
+    private lctBackgroundColor;
+    private stageBackgroundColor;
+    constructor(options: ReceiverCanvasControllerOptions);
+    get logicalSize(): ReceiverCanvasSize;
+    setLctBackgroundColor(backgroundColorRgb: number | null): void;
+    setStageBackgroundColor(backgroundColor: string | null): void;
+    resetStageBackground(): void;
+    applyScreenSize(width: number, height: number): void;
+    fit(): void;
+    dispose(): void;
+    private applyBackgroundColor;
+}
+export {};

package/dist/types/receiver/protocol.d.ts

@@ -0,0 +1,21 @@
+import type { AribMediaPlane, AribMediaPlaneLayer } from '../media-plane';
+/** Untrusted runtime-to-host wire message before session and event filtering. */
+export type RuntimeMessage = Record<string, unknown> & {
+    type?: string;
+    runtimeId?: string;
+    event?: string;
+};
+export type AribApplicationReplaceRequest = {
+    organizationId: number;
+    applicationId: number;
+    aitUrl: string | null;
+};
+export type ReceiverMediaPlaneFallback = {
+    screenWidth: number;
+    screenHeight: number;
+};
+export declare function normalizeStageBackgroundColor(value: unknown): string | null;
+export declare function normalizeCaptionSubscriptionTags(value: unknown): number[];
+export declare function normalizeApplicationReplaceRequest(message: RuntimeMessage): AribApplicationReplaceRequest | null;
+export declare function normalizeMediaLayer(value: unknown): AribMediaPlaneLayer;
+export declare function normalizeMediaPlane(message: RuntimeMessage, fallback: ReceiverMediaPlaneFallback): AribMediaPlane;

package/dist/types/receiver/runtime-session-controller.d.ts

@@ -0,0 +1,40 @@
+import type { ProgramInfo } from '../program-info';
+import type { RuntimeApplicationInformation } from '../runtime/application-controller';
+import type { RuntimeEvent } from '../runtime/stream-event';
+export type RuntimeInstalledSnapshot = {
+    captionComponentTags: readonly number[];
+    applicationInformation: RuntimeApplicationInformation;
+    inputActive: boolean;
+    programInfo: ProgramInfo | null;
+};
+type RuntimeSessionControllerOptions = {
+    ownerWindow: Window;
+    iframe: HTMLIFrameElement;
+    origin: string;
+    applicationLoadTimeoutMs: number;
+    onApplicationLoadTimeout: (url: string) => void;
+};
+/** Owns receiver-to-runtime transport and the runtime installation session. */
+export declare class RuntimeSessionController {
+    private readonly ownerWindow;
+    private readonly iframe;
+    private readonly origin;
+    private readonly applicationLoadTimeoutMs;
+    private readonly onApplicationLoadTimeout;
+    private readonly pendingStreamEvents;
+    private activeRuntimeId;
+    private applicationLoadTimer;
+    private disposed;
+    constructor(options: RuntimeSessionControllerOptions);
+    get hasActiveRuntime(): boolean;
+    matches(runtimeId: unknown): boolean;
+    acceptInstalled(runtimeId: string, snapshot: RuntimeInstalledSnapshot, beforeReplay?: () => void): void;
+    postToRuntime(event: string, detail?: Record<string, unknown>): void;
+    emitStreamEvent(value: RuntimeEvent): void;
+    clearPendingStreamEvents(): void;
+    invalidate(): void;
+    armWatchdog(url: string): void;
+    clearWatchdog(): void;
+    dispose(): void;
+}
+export {};

package/dist/types/receiver/types.d.ts

@@ -0,0 +1,91 @@
+import type { ReceiverDeviceIdentifierProvider } from '../device-identifier';
+import type { AribMediaPlane, AribMediaPlaneAdapter } from '../media-plane';
+import type { AribProgramGuideHandler, AribProgramGuideUnavailableHandler } from '../program-guide';
+import type { RuntimeApplicationInformation } from '../runtime/install';
+import type { BroadcastResourceStore } from '../runtime/resources';
+import type { ReceiverSystemInformationOverrides } from '../runtime/system-information';
+import type { AribViewerParticipationEvent } from '../viewer-participation';
+import type { AribApplicationReplaceRequest } from './protocol';
+export type AribCaptionPacket = {
+    componentTag: number;
+    payload?: string;
+    dataType?: string;
+    tmd?: string;
+    data?: string;
+};
+export type AribCaptionSubscription = {
+    componentTags: number[];
+};
+export type AribApplicationInformation = RuntimeApplicationInformation;
+export type { AribApplicationReplaceRequest } from './protocol';
+export type AribApplicationReplaceHandler = (request: AribApplicationReplaceRequest) => void | Promise<void>;
+export type AribExitManagedStateHandler = (url: string) => void | Promise<void>;
+export type AribBroadcastClock = {
+    /** Absolute broadcast time at the anchor, as Unix epoch milliseconds. */
+    epochMilliseconds: number;
+    /** Media timeline value which corresponds to epochMilliseconds. */
+    mediaTimeSeconds?: number;
+    /** Current playback position; enables pause, rate, and seek aware projection. */
+    currentMediaTimeSeconds?: () => number;
+};
+export type AribReceiverLifecycleEvent = {
+    type: 'loading';
+    url: string;
+} | {
+    type: 'installed';
+    url: string;
+    runtimeId: string;
+} | {
+    type: 'navigating';
+    url: string;
+} | {
+    type: 'exited';
+} | {
+    type: 'navigation-blocked';
+    url: string;
+} | {
+    type: 'frame-blocked';
+    url: string;
+} | {
+    type: 'error';
+    message: string;
+};
+export type AribReceiverHostOptions = {
+    iframe: HTMLIFrameElement;
+    viewport: HTMLElement;
+    /** Surface used only by the behind-iframe compatibility adapter. */
+    videoSurface?: HTMLElement;
+    mediaPlaneAdapter?: AribMediaPlaneAdapter;
+    onStatus?: (status: string) => void;
+    /** Machine-readable application/runtime lifecycle; never branch on onStatus text. */
+    onLifecycle?: (event: AribReceiverLifecycleEvent) => void;
+    /** Time to wait for a loaded document to install the receiver runtime. 0 disables the fallback. */
+    applicationLoadTimeoutMs?: number;
+    onUrlChange?: (url: string) => void;
+    onMediaPlane?: (plane: AribMediaPlane) => void;
+    /** @deprecated Use onMediaPlane. */
+    onVideoPlane?: (plane: AribMediaPlane) => void;
+    keepVideoVisible?: boolean;
+    /** Allow broadcaster applications to use HTTP origins outside this host. */
+    allowExternalNetwork?: boolean;
+    /** Same-origin namespace where a Worker or HTTP server exposes carousel data. */
+    broadcastBaseUrl?: string | URL;
+    /** Optional bridge to a Service Worker, Cache Storage, or carousel VFS. */
+    resourceStore?: BroadcastResourceStore;
+    /** Receiver/WebView bridge which opens the native EPG or a program detail page. */
+    onOpenProgramGuide?: AribProgramGuideHandler;
+    /** Active caption components requested by the current broadcast document. */
+    onCaptionSubscription?: (subscription: AribCaptionSubscription) => void;
+    /** Resolve Application.replaceApplication() through the receiver's current MH-AIT. */
+    onReplaceApplication?: AribApplicationReplaceHandler;
+    /** Transfer an application to an unmanaged general-application URL. */
+    onExitManagedState?: AribExitManagedStateHandler;
+    /** Override the default browser alert when the receiver cannot open the EPG. */
+    onProgramGuideUnavailable?: AribProgramGuideUnavailableHandler;
+    /** Receiver identity/capabilities exposed to the broadcast application. */
+    systemInformation?: ReceiverSystemInformationOverrides;
+    /** Resolve receiver/CAS identifiers; defaults to the bundled Huggy demo identity. */
+    getDeviceIdentifier?: ReceiverDeviceIdentifierProvider;
+    /** Receiver UI hook for a TR-B39 viewer-participation corner notification. */
+    onViewerParticipation?: (event: AribViewerParticipationEvent) => void;
+};

package/dist/types/receiver-host.d.ts

@@ -1,96 +1,11 @@
-import { type RuntimeApplicationInformation, type RuntimeEvent, type RuntimeWindow } from './runtime/install';
+import { type RuntimeEvent, type RuntimeWindow } from './runtime/install';
 import { type ProgramInfo } from './program-info';
-import type { ReceiverSystemInformationOverrides } from './runtime/system-information';
-import type { ReceiverDeviceIdentifierProvider } from './device-identifier';
-import { type AribMediaPlane, type AribMediaPlaneAdapter } from './media-plane';
-import type { BroadcastResourceChange, BroadcastResourceStore } from './runtime/resources';
-import { type AribProgramGuideHandler, type AribProgramGuideRequest, type AribProgramGuideUnavailableHandler } from './program-guide';
+import type { BroadcastResourceChange } from './runtime/resources';
+import { type AribProgramGuideRequest } from './program-guide';
+import { type AribApplicationPresentationState, type AribViewerParticipationNotification } from './viewer-participation';
+import type { AribApplicationInformation, AribBroadcastClock, AribCaptionPacket, AribReceiverHostOptions } from './receiver/types';
 export type { AribMediaPlane, AribMediaPlaneAdapter, AribMediaPlaneLayer, AribMediaPlaneStackEntry, AribMediaPlaneUnmountReason, AribVideoPlane, } from './media-plane';
-export type AribCaptionPacket = {
-    componentTag: number;
-    payload?: string;
-    dataType?: string;
-    tmd?: string;
-    data?: string;
-};
-export type AribCaptionSubscription = {
-    componentTags: number[];
-};
-export type AribApplicationInformation = RuntimeApplicationInformation;
-export type AribApplicationReplaceRequest = {
-    organizationId: number;
-    applicationId: number;
-    aitUrl: string | null;
-};
-export type AribApplicationReplaceHandler = (request: AribApplicationReplaceRequest) => void | Promise<void>;
-export type AribExitManagedStateHandler = (url: string) => void | Promise<void>;
-export type AribBroadcastClock = {
-    /** Absolute broadcast time at the anchor, as Unix epoch milliseconds. */
-    epochMilliseconds: number;
-    /** Media timeline value which corresponds to epochMilliseconds. */
-    mediaTimeSeconds?: number;
-    /** Current playback position; enables pause, rate, and seek aware projection. */
-    currentMediaTimeSeconds?: () => number;
-};
-export type AribReceiverLifecycleEvent = {
-    type: 'loading';
-    url: string;
-} | {
-    type: 'installed';
-    url: string;
-    runtimeId: string;
-} | {
-    type: 'navigating';
-    url: string;
-} | {
-    type: 'exited';
-} | {
-    type: 'navigation-blocked';
-    url: string;
-} | {
-    type: 'frame-blocked';
-    url: string;
-} | {
-    type: 'error';
-    message: string;
-};
-export type AribReceiverHostOptions = {
-    iframe: HTMLIFrameElement;
-    viewport: HTMLElement;
-    /** Surface used only by the behind-iframe compatibility adapter. */
-    videoSurface?: HTMLElement;
-    mediaPlaneAdapter?: AribMediaPlaneAdapter;
-    onStatus?: (status: string) => void;
-    /** Machine-readable application/runtime lifecycle; never branch on onStatus text. */
-    onLifecycle?: (event: AribReceiverLifecycleEvent) => void;
-    /** Time to wait for a loaded document to install the receiver runtime. 0 disables the fallback. */
-    applicationLoadTimeoutMs?: number;
-    onUrlChange?: (url: string) => void;
-    onMediaPlane?: (plane: AribMediaPlane) => void;
-    /** @deprecated Use onMediaPlane. */
-    onVideoPlane?: (plane: AribMediaPlane) => void;
-    keepVideoVisible?: boolean;
-    /** Allow broadcaster applications to use HTTP origins outside this host. */
-    allowExternalNetwork?: boolean;
-    /** Same-origin namespace where a Worker or HTTP server exposes carousel data. */
-    broadcastBaseUrl?: string | URL;
-    /** Optional bridge to a Service Worker, Cache Storage, or carousel VFS. */
-    resourceStore?: BroadcastResourceStore;
-    /** Receiver/WebView bridge which opens the native EPG or a program detail page. */
-    onOpenProgramGuide?: AribProgramGuideHandler;
-    /** Active caption components requested by the current broadcast document. */
-    onCaptionSubscription?: (subscription: AribCaptionSubscription) => void;
-    /** Resolve Application.replaceApplication() through the receiver's current MH-AIT. */
-    onReplaceApplication?: AribApplicationReplaceHandler;
-    /** Transfer an application to an unmanaged general-application URL. */
-    onExitManagedState?: AribExitManagedStateHandler;
-    /** Override the default browser alert when the receiver cannot open the EPG. */
-    onProgramGuideUnavailable?: AribProgramGuideUnavailableHandler;
-    /** Receiver identity/capabilities exposed to the broadcast application. */
-    systemInformation?: ReceiverSystemInformationOverrides;
-    /** Resolve receiver/CAS identifiers; defaults to the bundled Huggy demo identity. */
-    getDeviceIdentifier?: ReceiverDeviceIdentifierProvider;
-};
+export type { AribApplicationInformation, AribApplicationReplaceHandler, AribApplicationReplaceRequest, AribBroadcastClock, AribCaptionPacket, AribCaptionSubscription, AribExitManagedStateHandler, AribReceiverHostOptions, AribReceiverLifecycleEvent, } from './receiver/types';
 export declare class AribReceiverHost {
     readonly iframe: HTMLIFrameElement;
     readonly viewport: HTMLElement;
@@ -115,30 +30,41 @@ export declare class AribReceiverHost {
     private readonly onProgramGuideUnavailable?;
     private readonly systemInformation?;
     private readonly getDeviceIdentifier?;
-    private readonly resizeObserver;
-    private activeRuntimeId;
-    private logicalWidth;
-    private logicalHeight;
+    private readonly onViewerParticipation?;
+    private readonly viewerParticipation;
+    private readonly canvas;
+    private readonly runtimeSession;
     private captionComponentTags;
     private applicationInformation;
     private programInfo;
-    private readonly pendingStreamEvents;
     private broadcastClock;
     private video;
     private mediaPlaneEnabled;
     private applicationExited;
-    private applicationLoadTimer;
     private destroyed;
     constructor(options: AribReceiverHostOptions);
     installRuntime(target: RuntimeWindow): void;
     /** Set the MH-AIT identity exposed by applicationManager.getOwnerApplication(). */
     setApplicationInformation(application: AribApplicationInformation | null): void;
+    /**
+     * Set the receiver-owned background plane from the current LCT
+     * Background_Color_Descriptor. Pass null when changing service/session or
+     * when the active LCT no longer carries the descriptor.
+     */
+    setLctBackgroundColor(backgroundColorRgb: number | null): void;
     /** @deprecated Pass an AribMediaPlaneAdapter to the constructor. */
     attachVideo(video: HTMLVideoElement): void;
     loadApplication(url: string, status?: string): void;
     /** Leave data-broadcast mode and restore media to the ordinary player. */
     exitApplication(status?: string): void;
-    dispatchKey(code: number): void;
+    dispatchKey(code: number): boolean;
+    /** Transfer or release receiver-key ownership for the broadcast application. */
+    setApplicationInputActive(active: boolean): void;
+    getApplicationPresentationState(): AribApplicationPresentationState;
+    /** Handle the descriptor-less TR-B39 receiver notification outside the application. */
+    notifyViewerParticipationCorner(notification: AribViewerParticipationNotification): void;
+    /** Discard notification versions while changing service or playback session. */
+    resetViewerParticipationNotifications(): void;
     setCaptionTracks(componentTags: number[]): void;
     pushCaption(packet: AribCaptionPacket): void;
     resetCaptions(): void;
@@ -164,12 +90,8 @@ export declare class AribReceiverHost {
     private readonly reportProgramGuideUnavailable;
     private readonly handleRuntimeMessage;
     private applyMediaPlane;
-    private readMediaLayer;
-    private postToRuntime;
-    private armApplicationLoadTimer;
     private failApplicationLoad;
-    private clearApplicationLoadTimer;
     private invalidateRuntime;
-    private fitBroadcastCanvas;
+    private disableRuntime;
     private assertAlive;
 }

package/dist/types/runtime/application-boundary.d.ts

@@ -0,0 +1,45 @@
+export declare const ARIB_PERMISSION_BITS: {
+    readonly broadcastMedia: 12;
+    readonly monomediaOverBroadcastVideo: 11;
+    readonly currentEventInformation: 10;
+    readonly persistentStorage: 9;
+    readonly boundaryExtension: 8;
+    readonly deviceIdentifier: 7;
+    readonly ipNetworkConfirmation: 6;
+    readonly broadcastResources: 5;
+    readonly scheduling: 4;
+    readonly cas: 3;
+};
+export type AribPermissionBit = typeof ARIB_PERMISSION_BITS[keyof typeof ARIB_PERMISSION_BITS];
+/** One loop of the MH-application boundary and permission descriptor. */
+export type RuntimePermissionManagedArea = {
+    /** Raw 16-bit permission_bitmap values, including the three-bit bitmap id. */
+    permissionBitmaps: readonly number[] | null;
+    /** managed_URL values. null or an empty array means all locations. */
+    managedUrls: readonly string[] | null;
+};
+/** Shape exposed by ApplicationBoundaryAndPermissionDescriptor in ARIB STD-B62. */
+export type AribPermissionManagedArea = {
+    /** Raw 16-bit permission_bitmap values, or null for maximum permission. */
+    permission: number[] | null;
+    /** Managed URL strings, or null for all locations. */
+    urls: string[] | null;
+};
+export type AribPermissionEvaluation = {
+    withinBoundary: boolean;
+    permissionBits: number;
+};
+export declare class AribApplicationBoundaryPolicy {
+    private readonly broadcastBaseUrl;
+    private readonly documentUrl;
+    private baseAreas;
+    private readonly addedAreas;
+    constructor(broadcastBaseUrl: string | URL, documentUrl: string | URL, areas?: readonly RuntimePermissionManagedArea[]);
+    /** Apply a new MH-AIT descriptor without discarding areas added by the application. */
+    update(areas?: readonly RuntimePermissionManagedArea[]): void;
+    hasDescriptor(): boolean;
+    getCurrentBoundary(): AribPermissionManagedArea[];
+    addPermissionManagedArea(area: AribPermissionManagedArea): void;
+    evaluate(value: string | URL): AribPermissionEvaluation;
+    permits(value: string | URL, bit: AribPermissionBit): boolean;
+}

package/dist/types/runtime/application-controller.d.ts

@@ -0,0 +1,48 @@
+import { type AribPermissionBit, type RuntimePermissionManagedArea } from './application-boundary';
+type RuntimeWindow = Window & typeof globalThis & Record<string, unknown>;
+export type RuntimeApplicationInformation = {
+    type?: string;
+    organizationId?: number;
+    applicationId?: number;
+    controlCode?: string;
+    autostartPriority?: number;
+    /** Decoded loops from MH-AIT descriptor 0x802C. Omit when absent. */
+    permissionManagedAreas?: readonly RuntimePermissionManagedArea[];
+};
+type RuntimeApplicationControllerOptions = {
+    target: RuntimeWindow;
+    broadcastBaseUrl: string | URL;
+    resolveRuntimeUrl: (value: unknown) => URL;
+    allowExternalNetwork: boolean;
+    application?: RuntimeApplicationInformation;
+    postRuntime: (event: string, detail?: Record<string, unknown>) => void;
+};
+/** Owns the application-manager, permission-boundary, and navigation state. */
+export declare class RuntimeApplicationController {
+    private readonly target;
+    private readonly resolveRuntimeUrl;
+    private readonly allowExternalNetwork;
+    private readonly postRuntime;
+    private readonly boundary;
+    private applicationInformation;
+    private applicationVisible;
+    private applicationInputActive;
+    private navigationCaptureInstalled;
+    private readonly keySet;
+    private readonly boundaryDescriptor;
+    private readonly ownerApplication;
+    constructor(options: RuntimeApplicationControllerOptions);
+    requirePermission(bit: AribPermissionBit): void;
+    permits(bit: AribPermissionBit): boolean;
+    updateApplicationInformation(value: RuntimeApplicationInformation): boolean;
+    setHostInputActive(active: boolean): void;
+    startDocument(): void;
+    startNavigationCapture(): void;
+    dispose(): void;
+    private applyApplicationVisibility;
+    private reportApplicationPresentation;
+    private reportBlockedNavigation;
+    private allowedNavigationUrl;
+    private readonly handleDocumentClick;
+}
+export {};

package/dist/types/runtime/caption-controller.d.ts

@@ -0,0 +1,27 @@
+type RuntimeCaptionControllerOptions = {
+    requirePermission: () => void;
+    postRuntime: (event: string, detail?: Record<string, unknown>) => void;
+};
+type RuntimeCaptionMessage = {
+    event?: unknown;
+    componentTags?: Iterable<unknown> | null;
+    componentTag?: unknown;
+    payload?: unknown;
+    dataType?: unknown;
+    tmd?: unknown;
+    data?: unknown;
+};
+/** Owns the document-side caption tracks, subscriptions, and broadcast object API. */
+export declare class RuntimeCaptionController {
+    private readonly requirePermission;
+    private readonly postRuntime;
+    private readonly tracks;
+    private readonly listeners;
+    constructor(options: RuntimeCaptionControllerOptions);
+    readonly installBroadcastObjectApi: (element: HTMLElement) => void;
+    /** Handle a host caption event; return false when it belongs to another subsystem. */
+    handleHostMessage(message: RuntimeCaptionMessage): boolean;
+    private componentTag;
+    private reportSubscriptions;
+}
+export {};

package/dist/types/runtime/external-media-hole.d.ts

@@ -0,0 +1,28 @@
+import type { AribMediaPlaneStackEntry } from '../media-plane';
+type RuntimeWindow = Window & typeof globalThis;
+/**
+ * Temporarily clears the DOM paint that covers an externally composed media
+ * plane and restores the exact inline values when the slot changes or exits.
+ */
+export declare class ExternalMediaHoleController {
+    private readonly target;
+    private readonly placeholderOpacities;
+    private readonly backgrounds;
+    constructor(target: RuntimeWindow);
+    set(object: HTMLElement, enabled: boolean): void;
+    restore(): void;
+    /** Read application styles while temporarily exposing backgrounds hidden for external video. */
+    withApplicationBackgrounds<T>(callback: () => T): T;
+    describeStackingPath(object: HTMLElement): AribMediaPlaneStackEntry[];
+    private hasTransparentBackground;
+    private placeholderElements;
+    private setPlaceholder;
+    private restorePlaceholder;
+    private restorePlaceholders;
+    private restoreBackground;
+    private applyBackground;
+    private captureApplicationBackgroundChanges;
+    private clearBackground;
+    private restoreBackgrounds;
+}
+export {};

package/dist/types/runtime/external-network.d.ts

@@ -0,0 +1,7 @@
+type ExternalNetworkTarget = Window & typeof globalThis;
+/**
+ * Make the receiver's optional external HTTP communication path fail fast while
+ * preserving same-origin access to receiver-managed broadcast resources.
+ */
+export declare function installExternalNetworkPolicy(target: ExternalNetworkTarget, allowExternalNetwork: boolean | undefined): void;
+export {};

package/dist/types/runtime/install.d.ts

@@ -3,8 +3,11 @@ import type { AribMediaPlaneAdapter } from '../media-plane';
 import { type BroadcastResourceStore } from './resources';
 import { type ReceiverSystemInformationOverrides } from './system-information';
 import { type ReceiverDeviceIdentifierProvider } from '../device-identifier';
+import { type RuntimeApplicationInformation } from './application-controller';
 export type { ProgramInfo } from '../program-info';
 export type { RuntimeEvent, RuntimeEventSelector, RuntimeEventSource, } from './stream-event';
+export type { AribPermissionManagedArea, RuntimePermissionManagedArea, } from './application-boundary';
+export type { RuntimeApplicationInformation } from './application-controller';
 export type RuntimeWindow = Window & typeof globalThis & Record<string, unknown>;
 export type RuntimeOptions = {
     /** Permit HTTP requests outside the receiver-managed application origin. */
@@ -24,11 +27,4 @@ export type RuntimeOptions = {
     /** MH-AIT metadata for the application which owns this document. */
     application?: RuntimeApplicationInformation;
 };
-export type RuntimeApplicationInformation = {
-    type?: string;
-    organizationId?: number;
-    applicationId?: number;
-    controlCode?: string;
-    autostartPriority?: number;
-};
 export declare function installRuntime(target: RuntimeWindow, options?: RuntimeOptions): void;

package/dist/types/runtime/media-plane-runtime.d.ts

@@ -0,0 +1,54 @@
+import type { AribMediaPlaneAdapter, AribMediaPlaneUnmountReason } from '../media-plane';
+type RuntimeWindow = Window & typeof globalThis;
+type RuntimeMediaPlaneControllerOptions = {
+    target: RuntimeWindow;
+    adapter?: AribMediaPlaneAdapter;
+    canUseBroadcastMedia: () => boolean;
+    installBroadcastObjectApi: (object: HTMLElement) => void;
+    postRuntime: (event: string, detail?: Record<string, unknown>) => void;
+};
+/** Owns the document-side media-plane observation and compositor lifecycle. */
+export declare class RuntimeMediaPlaneController {
+    private readonly target;
+    private readonly adapter?;
+    private readonly canUseBroadcastMedia;
+    private readonly installBroadcastObjectApi;
+    private readonly postRuntime;
+    private readonly mediaObjectIds;
+    private readonly externalMediaHole;
+    private readonly resizeObserver;
+    private applicationCanvasStyle;
+    private mutationObserver;
+    private nextMediaObjectId;
+    private activeMediaObject;
+    private lastMediaPlane;
+    private lastStageBackgroundColor;
+    private observedMediaObject;
+    private mediaPlaneFrame;
+    private observing;
+    private disposed;
+    constructor(options: RuntimeMediaPlaneControllerOptions);
+    /** Install APIs needed by static objects, prepare the canvas, and queue a report. */
+    startDocument(): void;
+    /** Start document observers after the runtime's installed handshake was sent. */
+    startObserving(): void;
+    readonly schedule: () => void;
+    /**
+     * Stop observation, run document-owned cleanup, then restore and unmount the
+     * media plane. The cleanup hook preserves the original pagehide ordering.
+     */
+    dispose(reason: Extract<AribMediaPlaneUnmountReason, 'document-unload'>, beforeUnmount?: () => void): void;
+    private findMediaObject;
+    private reportStageStyle;
+    private prepareExternalMediaPlaneCanvas;
+    private withApplicationCanvasBackgrounds;
+    private observeDocumentMutations;
+    private activeMediaAnimation;
+    private observeMediaObject;
+    private logicalViewport;
+    private slotIdFor;
+    private callMediaPlaneAdapter;
+    private unmountMediaPlane;
+    private reportMediaPlane;
+}
+export {};

package/dist/types/runtime/platform.d.ts

@@ -0,0 +1,4 @@
+type NavigatorPlatform = Pick<Navigator, 'maxTouchPoints' | 'platform' | 'userAgent'>;
+/** iOS media elements can replace the receiver player's active media session. */
+export declare function shouldSuppressRomSoundPlayback(navigator: NavigatorPlatform): boolean;
+export {};