libaribhtml5 0.1.4 → 0.1.7

package/dist/types/service-worker-vfs.d.ts

@@ -1,84 +1,3 @@
-export type BroadcastVfsResource = {
-    path: string;
-    contentType?: string;
-    data: Uint8Array | ArrayBuffer;
-};
-export type ServiceWorkerBroadcastVfsOptions = {
-    workerUrl: string | URL;
-    /** Same-origin scope used to expose broadcast files. */
-    baseUrl?: string | URL;
-    /** Compatibility fallback for applications which omit a carousel directory. */
-    uniqueBasenameFallback?: boolean;
-};
-export type BroadcastVfsBackend = {
-    begin(): Promise<void>;
-    put(resource: BroadcastVfsResource): Promise<void>;
-    canRead(path: string): Promise<boolean>;
-};
-export type BroadcastVfsSessionOptions = {
-    /** Report background write failures; ensure() still rejects to its caller. */
-    onError?: (error: unknown) => void;
-    /** Override background scheduling, primarily for embedded hosts and tests. */
-    schedule?: (task: () => void) => void;
-};
-/**
- * Ordered, recoverable write session above a VFS backend. enqueue() copies
- * callback-lifetime data synchronously and returns a revision barrier.
- */
-export declare class BroadcastVfsSession {
-    private readonly backend;
-    private readonly onError?;
-    private readonly scheduleTask;
-    private readonly mirror;
-    private readonly queue;
-    private waiters;
-    private generation;
-    private nextRevision;
-    private completedRevision;
-    private drainScheduled;
-    private ioTail;
-    private sessionReady;
-    private disposed;
-    constructor(backend: BroadcastVfsBackend, options?: BroadcastVfsSessionOptions);
-    beginSession(): Promise<void>;
-    enqueue(resource: BroadcastVfsResource): number;
-    waitFor(revision: number): Promise<void>;
-    /** Ensure a staged path is readable, replaying the page-owned mirror if needed. */
-    ensure(path: string, revision?: number): Promise<void>;
-    /**
-     * Stop accepting resources, discard queued writes, and wait for the one
-     * backend operation which may already be running. The backend itself remains
-     * owned by the caller and can be reset or disposed after this resolves.
-     */
-    dispose(): Promise<void>;
-    private appendIo;
-    private scheduleDrain;
-    private drainOne;
-    private resolveWaiters;
-}
-export declare class ServiceWorkerBroadcastVfs {
-    private readonly workerUrl;
-    private readonly scopeUrl;
-    private readonly uniqueBasenameFallback;
-    private registration;
-    private ready;
-    private readonly inFlight;
-    private disposing;
-    private disposed;
-    constructor(options: ServiceWorkerBroadcastVfsOptions);
-    initialize(): Promise<ServiceWorkerRegistration>;
-    begin(): Promise<void>;
-    put(resource: BroadcastVfsResource): Promise<void>;
-    canRead(path: string): Promise<boolean>;
-    reset(): Promise<void>;
-    /**
-     * Clear the receiver-owned VFS session after outstanding requests finish.
-     * The shared Service Worker registration is intentionally retained so other
-     * tabs and future receiver instances keep a stable scoped fetch handler.
-     */
-    dispose(): Promise<void>;
-    private request;
-    private performRequest;
-    private performRequestWithRegistration;
-    private waitForActivation;
-}
+export { BroadcastVfsSession } from './vfs/session.js';
+export { ServiceWorkerBroadcastVfs } from './vfs/service-worker-backend.js';
+export type { BroadcastVfsBackend, BroadcastVfsResource, BroadcastVfsSessionOptions, ServiceWorkerBroadcastVfsOptions, } from './vfs/types.js';

package/dist/types/vfs/service-worker-backend.d.ts

@@ -0,0 +1,27 @@
+import type { BroadcastVfsResource, ServiceWorkerBroadcastVfsOptions } from './types.js';
+export declare class ServiceWorkerBroadcastVfs {
+    private readonly workerUrl;
+    private readonly scopeUrl;
+    private readonly uniqueBasenameFallback;
+    private registration;
+    private ready;
+    private readonly inFlight;
+    private disposing;
+    private disposed;
+    constructor(options: ServiceWorkerBroadcastVfsOptions);
+    initialize(): Promise<ServiceWorkerRegistration>;
+    begin(): Promise<void>;
+    put(resource: BroadcastVfsResource): Promise<void>;
+    canRead(path: string): Promise<boolean>;
+    reset(): Promise<void>;
+    /**
+     * Clear the receiver-owned VFS session after outstanding requests finish.
+     * The shared Service Worker registration is intentionally retained so other
+     * tabs and future receiver instances keep a stable scoped fetch handler.
+     */
+    dispose(): Promise<void>;
+    private request;
+    private performRequest;
+    private performRequestWithRegistration;
+    private waitForActivation;
+}

package/dist/types/vfs/session.d.ts

@@ -0,0 +1,36 @@
+import type { BroadcastVfsBackend, BroadcastVfsResource, BroadcastVfsSessionOptions } from './types.js';
+/**
+ * Ordered, recoverable write session above a VFS backend. enqueue() copies
+ * callback-lifetime data synchronously and returns a revision barrier.
+ */
+export declare class BroadcastVfsSession {
+    private readonly backend;
+    private readonly onError?;
+    private readonly scheduleTask;
+    private readonly mirror;
+    private readonly queue;
+    private waiters;
+    private generation;
+    private nextRevision;
+    private completedRevision;
+    private drainScheduled;
+    private ioTail;
+    private sessionReady;
+    private disposed;
+    constructor(backend: BroadcastVfsBackend, options?: BroadcastVfsSessionOptions);
+    beginSession(): Promise<void>;
+    enqueue(resource: BroadcastVfsResource): number;
+    waitFor(revision: number): Promise<void>;
+    /** Ensure a staged path is readable, replaying the page-owned mirror if needed. */
+    ensure(path: string, revision?: number): Promise<void>;
+    /**
+     * Stop accepting resources, discard queued writes, and wait for the one
+     * backend operation which may already be running. The backend itself remains
+     * owned by the caller and can be reset or disposed after this resolves.
+     */
+    dispose(): Promise<void>;
+    private appendIo;
+    private scheduleDrain;
+    private drainOne;
+    private resolveWaiters;
+}

package/dist/types/vfs/types.d.ts

@@ -0,0 +1,23 @@
+export type BroadcastVfsResource = {
+    path: string;
+    contentType?: string;
+    data: Uint8Array | ArrayBuffer;
+};
+export type ServiceWorkerBroadcastVfsOptions = {
+    workerUrl: string | URL;
+    /** Same-origin scope used to expose broadcast files. */
+    baseUrl?: string | URL;
+    /** Compatibility fallback for applications which omit a carousel directory. */
+    uniqueBasenameFallback?: boolean;
+};
+export type BroadcastVfsBackend = {
+    begin(): Promise<void>;
+    put(resource: BroadcastVfsResource): Promise<void>;
+    canRead(path: string): Promise<boolean>;
+};
+export type BroadcastVfsSessionOptions = {
+    /** Report background write failures; ensure() still rejects to its caller. */
+    onError?: (error: unknown) => void;
+    /** Override background scheduling, primarily for embedded hosts and tests. */
+    schedule?: (task: () => void) => void;
+};

package/dist/types/viewer-participation.d.ts

@@ -0,0 +1,29 @@
+export type AribApplicationPresentationState = {
+    visible: boolean;
+    inputActive: boolean;
+};
+export type AribViewerParticipationNotification = {
+    contextId: number;
+    sourcePacketId: number;
+    eventMessageTag: number;
+    dataEventId: number;
+    messageGroupId: number;
+    version: number;
+    currentNext: boolean;
+    sectionNumber: number;
+    lastSectionNumber: number;
+    inputOffset: bigint;
+};
+export type AribViewerParticipationEvent = AribViewerParticipationNotification & {
+    requiresUserAction: true;
+};
+export declare class ViewerParticipationController {
+    private state;
+    private generation;
+    private readonly delivered;
+    get presentation(): AribApplicationPresentationState;
+    setPresentation(state: Partial<AribApplicationPresentationState>): void;
+    resetPresentation(): void;
+    resetSession(): void;
+    notify(notification: AribViewerParticipationNotification): AribViewerParticipationEvent | null;
+}

package/docs/application-lifecycle.md

@@ -65,6 +65,40 @@ const host = new AribReceiverHost({
 許可境界と外部 network policy を receiver 側で検証し、対応する場合だけ
 `onExitManagedState` で処理します。
 
+## アプリケーション境界と権限
+
+MH-AIT の `MH-Application Boundary and Permission Descriptor` (`descriptor_tag=0x802C`)
+は、decoder 側で一つの application に属する loop を平坦化し、次の形で渡します。
+
+```ts
+host.setApplicationInformation({
+  organizationId: application.organizationId,
+  applicationId: application.applicationId,
+  permissionManagedAreas: application.boundaryDescriptors.flatMap(descriptor =>
+    descriptor.areas.map(area => ({
+      // bitmap ID を含む raw 16-bit 値
+      permissionBitmaps: area.permissionBitmaps,
+      managedUrls: area.managedUrls,
+    })),
+  ),
+})
+```
+
+descriptor がない場合は `permissionManagedAreas` 自体を省略します。この場合は境界が無限で
+全権限です。descriptor が存在し、ある area の `managed_URL_count` が 0 の場合は
+`managedUrls: []`（または `null`）で全 location を表します。より狭い domain/sub-directory の
+設定が一致した場合はそちらを優先します。放送 VFS (`broadcastBaseUrl`) から取得した content は、
+TR-B39 の規定どおり descriptor にかかわらず境界内・全権限として扱います。
+
+runtime は bitmap 0/1 を解釈し、bit 12/10/9/8/7/5 を現在実装済みの broadcast media、番組情報、
+persistent array、boundary extension、receiver ID、application/cache/EMT/system-information API に
+適用します。権限がない同期 API は `Error` (`code="NOT_AUTHORIZED_ERR"`) を送出し、AIT 更新後も
+同じ runtime に直ちに反映します。更新によって現在の communication document が境界外になった場合、
+host は application を終了します。
+
+境界権限と `allowExternalNetwork` は別条件です。MH-AIT が URL を許可しても、host の network policy が
+offline なら外部 HTTP へは遷移・通信できません。
+
 ## AUTOSTART と PRESENT の同居
 
 一つの tuning/session generation につき managed application slot は一つにします。

package/docs/browser-iframe-compositing.md

@@ -43,6 +43,26 @@ iframe より前の layer に置きます。標準の `BehindIframeMediaPlaneAda
 object の CSS を複製せず、報告された `getBoundingClientRect()` を logical viewport に対する割合へ
 変換して配置します。
 
+## プレーヤー操作への pointer 穿透
+
+データ放送 iframe は全面が透明でも、一つの不透明な矩形と同じように hit test されます。そのまま
+プレーヤーへ重ねると、特に touch device で下の再生 UI がクリックできなくなります。
+
+`AribReceiverHost` は iframe を表示専用の application plane として扱い、既定で `inert`、
+`pointer-events: none !important`、`tabindex="-1"` を設定します。`tabindex="-1"` だけでは iframe 内の
+document が focus を取得できるため不十分です。`inert` によって子 document 全体を focus と hit test の
+対象から外し、下のプレーヤー container へ mouse / touch event と `:hover` を渡します。描画、timer、通信、
+media-plane report は継続します。リモコン入力は iframe の focus に頼らず `host.dispatchKey()` で
+document へ送ってください。
+
+iframe 内の pointer event を親へ再送する実装は使いません。iframe の event は親 document へ bubble
+しないため、再送には座標から対象要素を再決定する処理が必要になり、player controller の click、drag、
+pointer capture を壊します。
+
+HTML/iframe には SVG の `pointer-events: painted` に相当する、非透明 pixel だけを hit test する
+モードはありません。透明度や root の背景色を見て iframe を `display: none` にすると、debug overlay
+以外の application UI や後から表示される画面まで失われるため使用しません。
+
 ## Chromium の白い iframe backdrop
 
 Chromium は iframe owner と iframe 内 root の used `color-scheme` が異なる場合、透明 iframe の

package/docs/media-plane-integration.md

@@ -26,6 +26,24 @@ MMT の source of truth は LCT です。実装時の優先順位は次の通り
    fallback として使ってよい。ただし、これはアプリケーション CSS を LCT と解釈するものではない。
 3. どちらも得られない間の receiver-owned fallback は黒 (`#000`) とする。
 
+`tlvdemux` の WASM 回調は LCT の 24 bit RGB を `backgroundColorRgb` として渡す。
+その値はページ CSS に変換せず、receiver host の背景プレーンへ渡す。
+
+```ts
+const demuxer = new TlvDemuxer({
+  onLayoutConfiguration(layout) {
+    host.setLctBackgroundColor(layout.backgroundColorRgb)
+  },
+})
+
+// 選局・別サービス・別チューニング session へ移る前に前回の LCT を破棄する。
+host.setLctBackgroundColor(null)
+```
+
+LCT の色が設定されている間、後から到着した application stage の CSS 色は
+背景プレーンを上書きしない。`null` で LCT 色を解除した場合だけ、stage 色または
+黒の fallback へ戻る。
+
 この fallback は規格上の既定色ではありません。白いブラウザ canvas の露出を避けるための
 実装上の選択です。確認に使った NHK BS8K の `8k.mmts` から抽出したファイルも、
 `top/source/top.css` の `body` と `#vstream`、および
@@ -127,6 +145,11 @@ window.__ARIB_HTML5_INSTALL__ = (child: RuntimeWindow) => {
 }
 ```
 
+`AribReceiverHost` は全面 iframe を表示専用の inert overlay として扱うため、データ放送の描画を
+残したまま touch/mouse 操作と `:hover` は下のプレーヤー UI へ通り、iframe 内へ browser focus も
+移りません。`pointer-events: none !important` と `tabindex="-1"` も互換用 fallback として設定します。
+放送アプリケーションのリモコン操作には `host.dispatchKey()` を使用してください。
+
 データ放送への出入りは次の二つだけです。
 
 ```ts

package/docs/receiver-compatibility-roadmap.md

@@ -0,0 +1,300 @@
+# Receiver compatibility roadmap
+
+## Purpose and scope
+
+This document records the remaining receiver-runtime work needed to run long-lived ARIB
+HTML5 data services in HonomiTV. The primary target is live and recorded BS4K/BS8K
+playback, including viewer-participation programmes. An isolated demo and Komorebi are useful
+secondary checks, but they are not the integration source of truth.
+
+The component boundary is:
+
+| Component | Responsibility |
+| --- | --- |
+| `tlvdemux` | Parse MMT/TLV, MMT-SI, LCT, MH-AIT, EMT, EIT, and carousel resources |
+| DPlayer | Own playback and forward typed TLV events without changing their meaning |
+| `libaribhtml5` | Own iframe/VFS, receiver API objects, application state, permissions, media slots, and receiver input state |
+| HonomiTV | Own live/recorded mode, service/session lifetime, remote-control UI, network proxy, and user-facing notices |
+
+Broadcaster directory names such as `sh4`, `sh8`, or `bsfuji4k` are not protocol fields and
+must not become policy. Application entries come from the active MH-AIT/resource context.
+
+This status was reviewed on 2026-08-02 against the English ARIB TR-B39 2.5 and STD-B62 2.2
+documents in `../ARIB-docs`, plus extracted NHK BS4K/BS8K applications.
+
+## Current coverage
+
+The current runtime already covers the receiver API surface exercised by the inspected NHK
+applications:
+
+- early runtime bootstrap and `receiverDevice.getSystemInformation(null)`;
+- `getDeviceIdentifier()` and the legacy `bmlCompat.browserPseudo.getIRDID()` path;
+- persistent-array compatibility and receiver-owned regional information;
+- current/following EIT delivery;
+- immediate general event-message delivery;
+- carousel resource retention callbacks;
+- caption existence, subscription, and TTML/resource delivery;
+- MH-AIT identity, application replacement, destruction, and managed-state exit;
+- application boundary/permission bitmap evaluation;
+- broadcast media-slot discovery and external media-plane composition;
+- LCT receiver background colour with an application-stage fallback;
+- receiver clock projection from stream time and media position.
+
+The important remaining work is mostly state and lifecycle semantics rather than adding names
+which only return a placeholder value.
+
+## P0: required for long-lived interactive broadcasts
+
+### Viewer-participation corner notification and input ownership
+
+TR-B39 Part 1 Volume 3 section 6.2.5 defines a receiver-level notification for games,
+questionnaires, and viewer voting:
+
+- `data_event_id` is `0xF`;
+- `event_msg_group_id` is `0xF00`;
+- the EMT has no event-message descriptor;
+- receiving it does not raise an interrupt event in the broadcast application;
+- when receiver input is not directed to the data application, the receiver may show a notice
+  which lets the viewer make the application controllable with a simple operation.
+
+This differs from an application `GeneralEventMessageListener`. It must not be injected into
+the page as an invented EMT callback.
+
+`Application.show()`, `hide()`, `activateInput()`, and `deactivateInput()` currently return
+success without changing receiver state. They need to update a receiver-owned application
+presentation/input state. `AribReceiverHost` then needs a host-facing viewer-participation
+notification contract. HonomiTV remains responsible for rendering the notice and deciding
+which UI action transfers control to the application.
+
+A future API may resemble the following, but these names are not yet a stable contract:
+
+```ts
+const host = new AribReceiverHost({
+  iframe,
+  viewport,
+  onViewerParticipation(event) {
+    if (event.requiresUserAction) showDataBroadcastParticipationNotice()
+  },
+})
+
+host.notifyViewerParticipationCorner({
+  contextId,
+  serviceId,
+  version,
+})
+```
+
+Repeated transmissions must be deduplicated by the current tuning generation, service, and
+message version. A service/session reset clears the notification state.
+
+Parser prerequisite: the current `tlvdemux` EMT parser emits events only for an event-message
+descriptor (`descriptor_tag=0xF003`). It must expose the descriptor-less `0xF00` receiver
+notification separately instead of fabricating a general event message.
+
+Acceptance criteria:
+
+1. A hidden or input-inactive application causes one host notification for a new participation
+   corner version.
+2. An already controllable application does not cause an unnecessary notice.
+3. Repeated transmission of the same version does not spam the UI.
+4. The notification is never delivered to an application EMT listener.
+5. Changing service or playback session discards the old notification.
+
+### Carousel resource update and deletion semantics
+
+Real NHK application code uses `storeDataResource("./", listener)` to monitor a directory and
+detect source updates or disappearance. The current cache implementation is centered on an
+exact resolved URL:
+
+- directory listeners do not observe descendant resource changes;
+- VFS `put()` does not automatically notify the active receiver runtime;
+- the Service Worker protocol has no single-resource deletion operation;
+- `notifyDataResource()` is a separate manual action which an integrator may omit;
+- a removed resource may therefore remain readable from the VFS mirror.
+
+VFS mutation and CacheEvent notification should share one receiver-owned lifecycle. The
+event contract needs atomic `updated`, `deleted`, `store_finished`, and `store_failed`
+semantics for both file and directory targets. A directory listener must match descendants
+without receiving unrelated application resources.
+
+A future high-level host contract should cover update, deletion, and session reset in one place,
+for example:
+
+```ts
+host.updateBroadcastResource({ path, revision })
+host.removeBroadcastResource(path)
+host.resetBroadcastResources()
+```
+
+The VFS may retain older bytes until a complete new resource is committed, but the runtime
+must not report `updated` before those new bytes are readable.
+
+### Complete MH-AIT state and update listeners
+
+`setApplicationInformation()` currently describes only the application owning the active
+document. The receiver also needs the complete current MH-AIT so it can implement:
+
+- `Application.getOwnerAIT()`;
+- `ApplicationInformationTable.getApplications()`;
+- `streamEvent.addAITUpdateListener()`;
+- `streamEvent.removeAITUpdateListener()`.
+
+The host should accept one detached, validated table snapshot containing the table version and
+all applications in transmission order. Updating the table must preserve the currently running
+document when the continuation rules allow it, update its identity/permission snapshot in
+place, and notify registered AIT listeners. A removed or killed active application must exit.
+
+HonomiTV already maintains all demuxed application states, so it should pass that snapshot
+rather than reimplementing the AIT object in application code.
+
+### Correct event-ID update behaviour
+
+TR-B39 requires `addEventIDUpdateListener()` to call the listener once immediately with an
+`ISDBResourceReference`, then again whenever the current event ID changes. The current
+runtime queues a zero-argument callback only after a later `program-info` update.
+
+The runtime must additionally:
+
+- provide `original_network_id`, `tlv_stream_id`, `service_id`, and `event_id`;
+- use `event_id: null` when no current event exists;
+- distinguish `tlv_stream_id` from the legacy `transport_stream_id` compatibility alias;
+- avoid notifying merely because a title, description, or duration changed;
+- return the present/following fields and `null` values required by the receiver API contract.
+
+The inspected NHK application includes a delayed polling fallback when this listener does not
+start, so fixing the semantics removes a real receiver-compatibility workaround rather than an
+abstract completeness issue.
+
+### Atomic broadcast-session reset
+
+An integrator currently has to clear captions, EIT, the broadcast clock, LCT colour,
+application information, queued EMT events, resource state, and the iframe separately. Missing
+one call leaks old-service state into the next application.
+
+Add one generation-changing operation, tentatively `resetBroadcastSession()` or
+`beginBroadcastSession()`, which atomically:
+
+- invalidates the previous runtime and asynchronous completions;
+- clears application/AIT and participation state;
+- clears EIT, EMT backlog, UTC/NPT alarms, and broadcast clock;
+- clears caption tracks/subscriptions;
+- clears LCT colour and application-stage fallback;
+- resets retained carousel resources and CacheEvent listeners;
+- restores the ordinary media plane.
+
+The individual setters may remain for incremental updates within a session.
+
+## P1: compatibility needed after the P0 state model
+
+### Capabilities and playback source
+
+Implement `navigator.capabilities.hasCapability()` as a host-configurable feature matrix.
+Unknown queries must return `false`; advertising a feature requires the corresponding API and
+host bridge to work.
+
+Implement `receiverDevice.streamEvent.sourceIs("onair")`. HonomiTV already knows whether
+the manager was created for live or recorded playback, so the runtime must not guess from a
+carousel path or current URL. TR-B39 recommends this optional API for receivers that execute
+data content during recording playback.
+
+### Broadcast video/audio object controls
+
+Only caption discovery/listener methods are currently implemented. STD-B62 Volume 2 section
+2.2 also defines:
+
+- fullscreen enable, disable, and query;
+- audio mute enable, disable, and query;
+- video/audio source selection and query;
+- caption source selection;
+- caption visibility set/query.
+
+These operations should be added to the media-plane adapter contract. The runtime must not
+pretend they succeeded without changing DPlayer/native media state.
+
+### Receiver API error and callback conformance
+
+Centralize ARIB receiver errors with `INVALID_PARAM_ERR`, `NOT_AUTHORIZED_ERR`,
+`NOT_FOUND_ERR`, `TIMEOUT_ERR`, and `MISC_ERR`. In particular:
+
+- asynchronous callbacks must not run after a synchronous API exception;
+- device-identifier acquisition failure returns `null`, not an empty string;
+- `confirmIPNetwork(destination, confirmType, timeout)` needs argument validation and a
+  host-provided result rather than only returning the configuration flag;
+- synchronous APIs must validate object shapes and integer ranges consistently.
+
+### Storage and network isolation
+
+All broadcast documents currently share the HonomiTV origin. Without an emulated application
+storage boundary, different broadcasters can collide in `_wlocal*`, Ureg, and other
+`localStorage` names. Persistence should be scoped by receiver policy and application identity
+while retaining explicitly receiver-owned regional information.
+
+Application-boundary permission bit 9 must apply to direct storage access as well as the
+`readPersistentArray()` and `writePersistentArray()` compatibility functions.
+
+External traffic should use a typed host request provider. HonomiTV currently rewrites
+`fetch`, XHR, and `sendBeacon` to its same-origin proxy after runtime installation. Moving that
+contract into the receiver host allows permission/boundary checks to precede the proxy and
+avoids competing monkey patches. Subresources, forms, WebSocket/EventSource, redirects, and
+managed-state navigation need an explicit support or rejection policy.
+
+## P2: optional and lower-risk receiver functions
+
+Implement these only after the session state and parser inputs are stable:
+
+- UTC-NPT reference listeners, `getUTCNPT()`, alarms, and cancellation;
+- data-event-ID update listeners;
+- `tuneTo()` through an explicit host callback;
+- viewing/recording scheduling APIs through the receiver EPG/backend;
+- CAS-provider-specific extensions.
+
+The runtime must not expose these through `hasCapability()` until their end-to-end behaviour is
+available.
+
+## Integration event matrix
+
+| Input/state | `tlvdemux`/DPlayer output | `libaribhtml5` action | HonomiTV action |
+| --- | --- | --- | --- |
+| LCT background | layout configuration | Set/reset receiver background plane | Forward event only |
+| MH-AIT | complete table/application states | Update AIT, active application, permissions, listeners | Select lifecycle candidate and pass snapshot |
+| Carousel file | complete resource/revision/delete | Commit VFS mutation and CacheEvent atomically | Forward owned bytes and session generation |
+| MH-EIT p/f | present/following event | Update event object and event-ID listeners | Convert demux time/fields only |
+| General EMT | typed event message | Match registered application listeners | Forward without interpreting broadcaster IDs |
+| Participation EMT `0xF00` | dedicated receiver notification | Evaluate visibility/input state and request a notice | Render notice and transfer control on user action |
+| Liveness source | host playback mode | Implement `sourceIs("onair")` | Supply live versus recorded state |
+| Service/session change | generation change | Atomic receiver-session reset | Call once before replaying the new snapshot |
+
+## Validation plan
+
+Library tests should cover each contract without requiring broadcaster media:
+
+- immediate and change-only event-ID callbacks with structured references;
+- complete AIT snapshots, ordering, version changes, continuation, removal, and KILL;
+- directory CacheEvent matching, atomic update, deletion, and reset;
+- participation notification deduplication and input/visibility combinations;
+- session-reset rejection of late callbacks from the old generation;
+- capability truthfulness and live/recorded `sourceIs()` behaviour;
+- media object state and adapter command failures;
+- application-scoped storage and permission changes.
+
+End-to-end replay should then use:
+
+- NHK BS Premium 4K for ordinary startup, EIT, receiver API, and long-running resource updates;
+- NHK BS8K for LCT/background, external media holes, caption applications, and 8K viewport state;
+- BS Fuji 4K for a non-NHK application entry and storage/path compatibility check;
+- a synthetic descriptor-less `0xF00` EMT fixture for viewer-participation UI, because an
+  archived programme is not guaranteed to contain that notification.
+
+Passing unit tests or a local SDK build is not equivalent to proving the deployed HonomiTV
+bundle, browser composition, remote focus, or multi-hour live behaviour.
+
+## Standards references
+
+- ARIB TR-B39 2.5-E1, Part 1 Volume 3, section 6.2.5 and Appendix 1: viewer-participation
+  corner notification and expected receiver UI.
+- ARIB TR-B39 2.5-E1, Part 1 Volume 3, section 10.7: permissions and receiver extended APIs.
+- ARIB STD-B62 2.2-E1, Volume 2, section 2.2: broadcast video/audio object.
+- ARIB STD-B62 2.2-E1, Volume 2, sections 3.3.7 through 3.3.13: application, capabilities,
+  receiver device, stream events, and cache control.
+- ARIB STD-B60 and STD-B62: MH-AIT/LCT transport state and receiver media/background-plane
+  composition; see the focused lifecycle and media-plane documents in this repository.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libaribhtml5",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Browser runtime and receiver host for ARIB HTML5 data broadcasting",
   "keywords": [
     "arib",
@@ -60,9 +60,10 @@
   },
   "scripts": {
     "dev": "vite --host 127.0.0.1",
-    "test": "node --experimental-strip-types scripts/test-runtime-contracts.mjs && node --experimental-strip-types scripts/test-vfs-worker.mjs",
+    "test": "node --experimental-strip-types scripts/test-runtime-contracts.mjs && node --experimental-strip-types scripts/test-external-network.mjs && node --experimental-strip-types scripts/test-caption-controller.mjs && node --experimental-strip-types scripts/test-runtime-application.mjs && node --experimental-strip-types scripts/test-receiver-protocol.mjs && node --experimental-strip-types scripts/test-receiver-canvas.mjs && node --experimental-strip-types scripts/test-receiver-session.mjs && node --experimental-strip-types scripts/test-media-plane-characterization.mjs && node --experimental-strip-types scripts/test-vfs-worker.mjs",
     "build": "tsc --noEmit && vite build && vite build --config vite.sdk.config.mjs && vite build --config vite.worker.config.mjs",
     "build:sdk": "tsc --noEmit && vite build --config vite.sdk.config.mjs && vite build --config vite.worker.config.mjs && npm run build:types",
+    "build:tv": "tsc --noEmit && node --experimental-strip-types scripts/test-tv-input.mjs && vite build --config vite.tv.config.mjs",
     "build:types": "tsc -p tsconfig.build.json && node scripts/rewrite-declaration-imports.mjs",
     "preview": "vite preview --host 127.0.0.1"
   }