libaribhtml5 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 huggy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# libaribhtml5
+
+[日本語](#日本語) | [English](#english)
+
+## 日本語
+
+ブラウザ上で動作する ARIB HTML5 受信機ランタイムのプロトタイプです。初期デモでは、
+展開済みの BS4K アプリケーションを放送時のパスで配信し、アプリケーションの
+スクリプトが実行される前に受信機 API のポリフィルを注入します。
+
+```sh
+pnpm install
+pnpm dev
+```
+
+Vite が出力した URL を開いてください。放送による自動起動アプリケーションには
+**透明起動ページ**を、表示ページを直接確認するには**表示ページ**を使用します。
+
+### 注意事項
+
+- 放送アプリケーションが利用する一部のオンラインデータは、ブラウザから放送局の
+  サーバーへ直接リクエストされます。現在のデモでは、安全のため、このような外部への
+  ネットワークリクエストをすべてブロックしています。
+- ACAS のシリアル番号は `0721 0721 0721 0724 9674` に固定してエミュレートしています。
+
+### SDK バンドル
+
+npm から利用する場合は、パッケージをインストールして ESM エントリを import します。
+
+```sh
+npm install libaribhtml5
+```
+
+```ts
+import { AribReceiverHost, installRuntime } from 'libaribhtml5'
+```
+
+従来の `<script>` 向け IIFE は `libaribhtml5/iife`、Service Worker ファイルは
+`libaribhtml5/arib-vfs-sw.js` として公開されます。
+
+```sh
+pnpm build:sdk
+```
+
+このコマンドは `dist/sdk/libaribhtml5.js` と、ブラウザ VFS 用の
+`dist/sdk/arib-vfs-sw.js` を生成します。SDK は `AribReceiverHost`、
+`ServiceWorkerBroadcastVfs`、`installRuntime` を持つ `window.ARIBHTML5` を公開します。受信機内蔵音は
+`src/runtime/romsound/` 以下で個別の MP3 ファイルとして管理され、SDK のビルド時に
+すべてデータ URL として単一の JavaScript バンドルへ埋め込まれます。
+
+プレーヤーへ統合する際のメディアスロット、adapter、レイヤー、ライフサイクル、字幕の契約は
+[メディアプレーン共通統合ガイド](docs/media-plane-integration.md)を参照してください。
+データ放送へ入る時は `host.loadApplication()`、通常プレーヤーへ戻す時は
+`host.exitApplication()` を使用します。
+
+録画再生ではシステム時計ではなく、ストリームの NTP と再生位置を
+`host.setBroadcastClock()` へ渡します。変換例は
+[録画再生時の放送時計](docs/broadcast-clock.md)を参照してください。
+
+EIT 由来の番組情報と受信機固有情報を host から渡す契約は
+[receiver host contracts](docs/receiver-host-contracts.md)を参照してください。
+
+Service Worker の `/data-broadcast/` ルーティング、データ放送リソースの
+store/update/release ライフサイクル、および ARIB 追加記号フォントは
+[放送リソースとフォント](docs/broadcast-resources-and-fonts.md)を参照してください。
+
+Android/WebView の「放送予定」検索結果から受信機所有の番組表・番組詳細を開く場合は、
+[`onOpenProgramGuide` とブラウザ fallback](docs/android-program-guide.md)を参照してください。
+
+## English
+
+Browser-hosted ARIB HTML5 receiver-runtime prototype. The initial demo serves the
+extracted BS4K application under its broadcast path and injects receiver API
+polyfills before the application scripts execute.
+
+```sh
+pnpm install
+pnpm dev
+```
+
+Open the URL printed by Vite. Use **透明起動ページ** for the broadcast autostart
+application and **表示ページ** to inspect the visible page directly.
+
+### Notes
+
+- Some online data used by broadcast applications is requested directly from the
+  browser to the broadcaster's servers. For safety, the current demo blocks all
+  such external network requests.
+- The ACAS serial number is emulated with the fixed value
+  `0721 0721 0721 0724 9674`.
+
+### SDK bundle
+
+Install the package to use its typed ESM entry point:
+
+```sh
+npm install libaribhtml5
+```
+
+```ts
+import { AribReceiverHost, installRuntime } from 'libaribhtml5'
+```
+
+The browser-global IIFE remains available as `libaribhtml5/iife`, and the
+Service Worker is exported as `libaribhtml5/arib-vfs-sw.js`.
+
+```sh
+pnpm build:sdk
+```
+
+This produces `dist/sdk/libaribhtml5.js` plus `dist/sdk/arib-vfs-sw.js` for the
+optional browser VFS, and exposes `window.ARIBHTML5` with `AribReceiverHost`,
+`ServiceWorkerBroadcastVfs`, and `installRuntime`. Receiver built-in sounds are maintained
+as individual MP3 files under `src/runtime/romsound/`; the SDK build inlines all
+of them as data URLs in the single JavaScript bundle.
+
+See the [common media-plane integration guide](docs/media-plane-integration.md)
+for the shared video layering, geometry, lifecycle, and caption contract.
+See [broadcast resources, Worker routing, and fonts](docs/broadcast-resources-and-fonts.md)
+for the `/data-broadcast/` namespace and cache/font lifecycle.
+See [Android program-guide integration](docs/android-program-guide.md) for handing a
+future-program result to a receiver-owned WebView/native EPG with a browser fallback.
+See [receiver host contracts](docs/receiver-host-contracts.md) for program metadata
+and receiver-owned system information.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,24 @@
+# Third-party notices
+
+`src/runtime/romsound/*.mp3` contains receiver built-in sound data restored from
+[web-bml](https://github.com/otya128/web-bml), used under the MIT License.
+
+Copyright (c) 2022 otya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/sdk/arib-vfs-sw.js

@@ -0,0 +1,336 @@
+(function() {
+  "use strict";
+  function deferRomSoundMarkup(source) {
+    return source.replace(
+      /\s+src\s*=\s*(?:(["'])(romsound:\/\/\d+)\1|(romsound:\/\/\d+)(?=[\s/>]))/gi,
+      (_match, _quote, quoted, bare) => ` data-arib-romsound="${quoted ?? bare}"`
+    );
+  }
+  function normalizeBasePath(value) {
+    const base = value || "/data-broadcast/";
+    return `/${base.replace(/^\/+|\/+$/g, "")}/`;
+  }
+  function rewriteBroadcastObjectMarkup(source) {
+    return source.replace(/<object\b[^>]*>/gi, (tag) => {
+      const broadcast = /\btype\s*=\s*(?:["']video\/x-arib2-broadcast["']|video\/x-arib2-broadcast)(?:\s|\/?>)/i.test(tag);
+      if (!broadcast) return tag;
+      return tag.replace(
+        /\s+type\s*=\s*(?:["']video\/x-arib2-broadcast["']|video\/x-arib2-broadcast)/i,
+        ' data-arib-type="video/x-arib2-broadcast"'
+      ).replace(/\s+data\s*=\s*(["'])(.*?)\1/i, " data-arib-data=$1$2$1");
+    });
+  }
+  function receiverPath(path, base, scope) {
+    if (path.startsWith(scope)) return path;
+    const mount = base.startsWith(scope) ? base.slice(scope.length).replace(/^\/+|\/+$/g, "") : "";
+    const requested = path.replace(/^\/+/, "");
+    if (mount && (requested === mount || requested.startsWith(`${mount}/`))) {
+      return `${scope}${requested}`;
+    }
+    return `${base}${requested}`;
+  }
+  function prefixBroadcastRootAttributes(source, basePath, scopePath) {
+    const base = normalizeBasePath(basePath);
+    const scope = normalizeBasePath(scopePath ?? basePath);
+    return source.replace(
+      /(\b(?:href|src|action|poster)\s*=\s*)(?:(['"])(\/[^/][^"']*)\2|(\/[^\s>]*))/gi,
+      (match, name, quote, quotedPath, barePath) => {
+        const path = quotedPath ?? barePath;
+        if (!path || path.startsWith(base)) return match;
+        const value = receiverPath(path, base, scope);
+        return quote ? `${name}${quote}${value}${quote}` : `${name}${value}`;
+      }
+    );
+  }
+  function prepareBroadcastStylesheet(source, options = {}) {
+    const base = normalizeBasePath(options.basePath);
+    const scope = normalizeBasePath(options.scopePath ?? options.basePath);
+    return source.replace(
+      /url\(\s*(["']?)(\/[^/)][^)]*)\1\s*\)/gi,
+      (match, quote, path) => path.startsWith(base) ? match : `url(${quote}${receiverPath(path, base, scope)}${quote})`
+    ).replace(
+      /(@import\s+)(["'])(\/[^/][^"']*)\2/gi,
+      (match, keyword, quote, path) => path.startsWith(base) ? match : `${keyword}${quote}${receiverPath(path, base, scope)}${quote}`
+    );
+  }
+  function prepareBroadcastHtml(source, options = {}) {
+    const prepared = prefixBroadcastRootAttributes(
+      deferRomSoundMarkup(rewriteBroadcastObjectMarkup(source)),
+      options.basePath,
+      options.scopePath
+    );
+    if (!options.bootstrap) return prepared;
+    const head = /<head(?:\s[^>]*)?>/i.exec(prepared);
+    if (!head) return `${options.bootstrap}${prepared}`;
+    const offset = head.index + head[0].length;
+    return `${prepared.slice(0, offset)}${options.bootstrap}${prepared.slice(offset)}`;
+  }
+  const scopeUrl = new URL(self.registration.scope);
+  const VFS_PREFIX = scopeUrl.pathname.endsWith("/") ? scopeUrl.pathname : `${scopeUrl.pathname}/`;
+  const CACHE_NAME = `libaribhtml5-arib-vfs-v1:${VFS_PREFIX}`;
+  const CACHE_RESOURCE_PATH = `${VFS_PREFIX}.libaribhtml5-arib-vfs-resource`;
+  const CACHE_SESSION_PATH = `${VFS_PREFIX}.libaribhtml5-arib-vfs-session`;
+  const RUNTIME_BOOTSTRAP = "<script>parent.__ARIB_HTML5_INSTALL__?.(window)<\/script>";
+  const resources = /* @__PURE__ */ new Map();
+  const waiters = /* @__PURE__ */ new Map();
+  let enabled = false;
+  let uniqueBasenameFallback = false;
+  let restorePromise = null;
+  function cacheRequest(path) {
+    const url = new URL(CACHE_RESOURCE_PATH, self.location.origin);
+    url.searchParams.set("path", path);
+    return new Request(url.href);
+  }
+  function sessionRequest() {
+    return new Request(new URL(CACHE_SESSION_PATH, self.location.origin).href);
+  }
+  async function beginPersistentSession() {
+    await caches.delete(CACHE_NAME);
+    const cache = await caches.open(CACHE_NAME);
+    await cache.put(sessionRequest(), new Response("", {
+      headers: {
+        "X-Arib-VFS-Session": "active",
+        "X-Arib-VFS-Unique-Basename-Fallback": uniqueBasenameFallback ? "1" : "0"
+      }
+    }));
+    restorePromise = null;
+  }
+  async function persistResource(path, resource) {
+    const cache = await caches.open(CACHE_NAME);
+    await cache.put(cacheRequest(path), new Response(resource.data.slice(), {
+      headers: {
+        "Content-Type": resource.contentType || "application/octet-stream",
+        "X-Arib-VFS-Path": path
+      }
+    }));
+  }
+  async function restorePersistentResources() {
+    if (enabled) return true;
+    if (restorePromise) return restorePromise;
+    restorePromise = (async () => {
+      const cache = await caches.open(CACHE_NAME);
+      const session = await cache.match(sessionRequest());
+      if (!session) return false;
+      uniqueBasenameFallback = session.headers.get("X-Arib-VFS-Unique-Basename-Fallback") === "1";
+      for (const request of await cache.keys()) {
+        const response = await cache.match(request);
+        const path = response?.headers.get("X-Arib-VFS-Path");
+        if (!path) continue;
+        resources.set(path, {
+          data: new Uint8Array(await response.arrayBuffer()),
+          contentType: response.headers.get("Content-Type") || ""
+        });
+      }
+      enabled = true;
+      return true;
+    })();
+    try {
+      return await restorePromise;
+    } finally {
+      restorePromise = null;
+    }
+  }
+  function normalizePath(value) {
+    let pathname;
+    try {
+      pathname = decodeURIComponent(new URL(String(value), self.location.origin).pathname);
+    } catch {
+      return null;
+    }
+    if (pathname.startsWith(VFS_PREFIX)) pathname = pathname.slice(VFS_PREFIX.length);
+    const parts = pathname.split("/").filter(Boolean);
+    if (!parts.length || parts.some((part) => part === "." || part === "..")) return null;
+    return parts.join("/");
+  }
+  function uniqueBasenameMatch(path) {
+    if (!uniqueBasenameFallback) return null;
+    const slash = path.lastIndexOf("/");
+    const basename = slash >= 0 ? path.slice(slash + 1) : path;
+    if (!basename) return null;
+    let match = null;
+    for (const candidate of resources.keys()) {
+      if (candidate !== basename && !candidate.endsWith(`/${basename}`)) continue;
+      if (match !== null) return null;
+      match = candidate;
+    }
+    return match;
+  }
+  function hasBroadcastRoot(path) {
+    const slash = path.indexOf("/");
+    const root = slash < 0 ? path : path.slice(0, slash);
+    for (const candidate of resources.keys()) {
+      if (candidate === root || candidate.startsWith(`${root}/`)) return true;
+    }
+    return false;
+  }
+  function hasResourceCandidate(value) {
+    const path = normalizePath(value);
+    return Boolean(path && (resources.has(path) || hasBroadcastRoot(path) || uniqueBasenameMatch(path) !== null));
+  }
+  function contentType(path, supplied) {
+    if (supplied) return supplied;
+    const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+    return (/* @__PURE__ */ new Map([
+      [".html", "text/html; charset=utf-8"],
+      [".htm", "text/html; charset=utf-8"],
+      [".css", "text/css; charset=utf-8"],
+      [".js", "text/javascript; charset=utf-8"],
+      [".json", "application/json; charset=utf-8"],
+      [".svg", "image/svg+xml"],
+      [".png", "image/png"],
+      [".jpg", "image/jpeg"],
+      [".jpeg", "image/jpeg"],
+      [".gif", "image/gif"],
+      [".webp", "image/webp"],
+      [".woff", "font/woff"],
+      [".woff2", "font/woff2"]
+    ])).get(extension) || "application/octet-stream";
+  }
+  function broadcastRootPath(path) {
+    const separator = path.indexOf("/");
+    return separator <= 0 ? VFS_PREFIX : `${VFS_PREFIX}${path.slice(0, separator)}/`;
+  }
+  function wake(path, resource) {
+    const exact = waiters.get(path);
+    if (exact) {
+      waiters.delete(path);
+      for (const resolve of exact) resolve({ path, resource });
+    }
+    if (!uniqueBasenameFallback) return;
+    for (const [requestedPath, pending] of [...waiters]) {
+      const fallback = uniqueBasenameMatch(requestedPath);
+      if (!fallback) continue;
+      const fallbackResource = resources.get(fallback);
+      if (!fallbackResource) continue;
+      waiters.delete(requestedPath);
+      for (const resolve of pending) resolve({ path: fallback, resource: fallbackResource });
+    }
+  }
+  function waitFor(path, timeout = 3e4) {
+    const current = resources.get(path);
+    if (current) return Promise.resolve({ path, resource: current });
+    const fallback = uniqueBasenameMatch(path);
+    if (fallback) return Promise.resolve({ path: fallback, resource: resources.get(fallback) });
+    return new Promise((resolve) => {
+      const pending = waiters.get(path) || /* @__PURE__ */ new Set();
+      pending.add(resolve);
+      waiters.set(path, pending);
+      setTimeout(() => {
+        pending.delete(resolve);
+        if (!pending.size) waiters.delete(path);
+        resolve(null);
+      }, timeout);
+    });
+  }
+  async function hasAvailableResource(value) {
+    await restorePersistentResources();
+    const path = normalizePath(`/${value || ""}`);
+    return Boolean(enabled && path && resources.has(path));
+  }
+  async function serve(request) {
+    const path = normalizePath(request.url);
+    if (!path) return new Response("Bad broadcast path", { status: 400 });
+    const resolved = await waitFor(path);
+    if (!resolved) return new Response("Broadcast resource is not available", { status: 404 });
+    if (resolved.path !== path) {
+      return Response.redirect(new URL(`${VFS_PREFIX}${resolved.path}`, self.location.origin), 302);
+    }
+    const resource = resolved.resource;
+    const type = contentType(path, resource.contentType);
+    let body = resource.data.slice(0);
+    if (/^text\/html(?:;|$)/i.test(type)) {
+      const source = prepareBroadcastHtml(new TextDecoder().decode(resource.data), {
+        basePath: broadcastRootPath(resolved.path),
+        scopePath: VFS_PREFIX,
+        bootstrap: RUNTIME_BOOTSTRAP
+      });
+      body = new TextEncoder().encode(source);
+    } else if (/^text\/css(?:;|$)/i.test(type)) {
+      const source = prepareBroadcastStylesheet(new TextDecoder().decode(resource.data), {
+        basePath: broadcastRootPath(resolved.path),
+        scopePath: VFS_PREFIX
+      });
+      body = new TextEncoder().encode(source);
+    }
+    return new Response(request.method === "HEAD" ? null : body, {
+      status: 200,
+      headers: {
+        "Cache-Control": "no-store",
+        "Content-Type": type,
+        "Content-Security-Policy": "default-src 'self' data: blob:; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self'; object-src 'none'; frame-src 'none'",
+        "X-Content-Type-Options": "nosniff"
+      }
+    });
+  }
+  self.addEventListener("install", (event) => {
+    event.waitUntil(self.skipWaiting());
+  });
+  self.addEventListener("activate", (event) => {
+    event.waitUntil(self.clients.claim());
+  });
+  self.addEventListener("message", (event) => {
+    const message = event.data || {};
+    const reply = (value) => event.ports[0]?.postMessage(value);
+    const handle = async () => {
+      if (message.type === "arib-vfs-probe") {
+        reply({ ok: true, available: await hasAvailableResource(message.path) });
+        return;
+      }
+      if (message.type === "arib-vfs-begin") {
+        enabled = true;
+        uniqueBasenameFallback = Boolean(message.uniqueBasenameFallback);
+        resources.clear();
+        for (const pending of waiters.values()) {
+          for (const resolve of pending) resolve(null);
+        }
+        waiters.clear();
+        await beginPersistentSession();
+        reply({ ok: true });
+        return;
+      }
+      if (message.type === "arib-vfs-put") {
+        const path = normalizePath(`/${message.path || ""}`);
+        if (!path || !(message.data instanceof ArrayBuffer)) {
+          reply({ ok: false, error: "invalid resource" });
+          return;
+        }
+        const resource = {
+          data: new Uint8Array(message.data),
+          contentType: String(message.contentType || "")
+        };
+        enabled = true;
+        resources.set(path, resource);
+        await persistResource(path, resource);
+        wake(path, resource);
+        reply({ ok: true });
+        return;
+      }
+      if (message.type === "arib-vfs-reset") {
+        enabled = false;
+        uniqueBasenameFallback = false;
+        resources.clear();
+        restorePromise = null;
+        for (const pending of waiters.values()) {
+          for (const resolve of pending) resolve(null);
+        }
+        waiters.clear();
+        await caches.delete(CACHE_NAME);
+        reply({ ok: true });
+        return;
+      }
+      reply({ ok: false, error: "unsupported VFS message" });
+    };
+    event.waitUntil(handle().catch((error) => {
+      reply({ ok: false, error: error?.message || String(error) });
+    }));
+  });
+  self.addEventListener("fetch", (event) => {
+    const url = new URL(event.request.url);
+    if (url.origin !== self.location.origin || !url.pathname.startsWith(VFS_PREFIX) || event.request.method !== "GET" && event.request.method !== "HEAD") return;
+    event.respondWith((async () => {
+      await restorePersistentResources();
+      if (!enabled || !hasResourceCandidate(url.pathname)) return fetch(event.request);
+      return serve(event.request);
+    })());
+  });
+})();