@lingxia/bridge 0.18.0 → 0.19.0

package/dist/es2020/error.js

@@ -58,8 +58,7 @@ function escapeHtml(str) {
     div.textContent = str;
     return div.innerHTML;
 }
-export function renderErrorUI(errorInfo) {
-    const { failedPath, reason } = errorInfo;
+function renderPanel({ code, title, description, detail, reason }) {
     const styleEl = document.createElement('style');
     styleEl.textContent = ERROR_STYLES;
     document.head.appendChild(styleEl);
@@ -67,11 +66,11 @@ export function renderErrorUI(errorInfo) {
     document.body.style.cssText = '';
     const container = document.createElement('div');
     container.className = 'lx-error';
-    let html = '<div class="lx-error-code">404</div>';
-    html += '<h1 class="lx-error-title">Page Not Found</h1>';
-    html += '<p class="lx-error-desc">The page you\'re looking for doesn\'t exist.</p>';
-    if (failedPath) {
-        html += `<div class="lx-error-path">${escapeHtml(failedPath)}</div>`;
+    let html = `<div class="lx-error-code">${escapeHtml(code)}</div>`;
+    html += `<h1 class="lx-error-title">${escapeHtml(title)}</h1>`;
+    html += `<p class="lx-error-desc">${escapeHtml(description)}</p>`;
+    if (detail) {
+        html += `<div class="lx-error-path">${escapeHtml(detail)}</div>`;
     }
     if (reason) {
         html += `<p class="lx-error-desc" style="margin-top:12px">${escapeHtml(reason)}</p>`;
@@ -79,6 +78,48 @@ export function renderErrorUI(errorInfo) {
     container.innerHTML = html;
     document.body.appendChild(container);
 }
+export function renderErrorUI(errorInfo) {
+    renderPanel({
+        code: '404',
+        title: 'Page Not Found',
+        description: "The page you're looking for doesn't exist.",
+        detail: errorInfo.failedPath,
+        reason: errorInfo.reason,
+    });
+}
+/**
+ * A page whose Logic has not delivered its first state in time — it failed to
+ * load, threw before the page could start, or is very slow. Shown over the page
+ * instead of a blank screen, naming the page; returns a function that removes
+ * it, for when the state does arrive after all.
+ */
+export function renderPageFault(pagePath, reason) {
+    const styleEl = document.createElement('style');
+    styleEl.textContent = `
+.lx-page-fault { position: fixed; inset: 0; z-index: 2147483647; overflow: auto;
+  background: #fff; color: #1d1d1f; }
+@media (prefers-color-scheme: dark) { .lx-page-fault { background: #000; color: #f5f5f7; } }
+${ERROR_STYLES.replace(/\bbody\b/g, '.lx-page-fault')}`;
+    document.head.appendChild(styleEl);
+    const overlay = document.createElement('div');
+    overlay.className = 'lx-page-fault';
+    overlay.setAttribute('role', 'alert');
+    const container = document.createElement('div');
+    container.className = 'lx-error';
+    let html = '<div class="lx-error-code">Page</div>';
+    html += `<h1 class="lx-error-title">${escapeHtml("This page couldn't start")}</h1>`;
+    html += `<p class="lx-error-desc">${escapeHtml('Its Logic has not delivered the page state. Check the Logic log for an error.')}</p>`;
+    if (pagePath)
+        html += `<div class="lx-error-path">${escapeHtml(pagePath)}</div>`;
+    html += `<p class="lx-error-desc" style="margin-top:12px">${escapeHtml(reason)}</p>`;
+    container.innerHTML = html;
+    overlay.appendChild(container);
+    document.body.appendChild(overlay);
+    return () => {
+        overlay.remove();
+        styleEl.remove();
+    };
+}
 export function hasError() {
     const config = window.__LX_RUNTIME_CONFIG;
     return !!(config && config.error);

package/dist/es2020/host.js

@@ -0,0 +1,53 @@
+import { BRIDGE_CONFIG, getDisplayLanguage, getPlatformOS, isDesktop, subscribeDisplayLanguage, } from './runtime-env';
+import { getSurfaceContext, subscribeSurfaceContext } from './surface-context';
+let current = null;
+function read() {
+    const surface = getSurfaceContext();
+    return {
+        sizeClass: surface.sizeClass,
+        aside: surface.aside,
+        displayLanguage: getDisplayLanguage(),
+        formFactor: isDesktop() ? 'desktop' : 'mobile',
+        os: getPlatformOS(),
+        runner: BRIDGE_CONFIG.runner === true,
+    };
+}
+function same(a, b) {
+    return a.sizeClass === b.sizeClass
+        && a.aside === b.aside
+        && a.displayLanguage === b.displayLanguage
+        && a.formFactor === b.formFactor
+        && a.os === b.os
+        && a.runner === b.runner;
+}
+/**
+ * The host facts for this page. The same object is returned until a field
+ * changes, so it composes with `useSyncExternalStore` and with memoization.
+ */
+export function getHost() {
+    const next = read();
+    if (current === null || !same(current, next))
+        current = next;
+    return current;
+}
+/**
+ * Follow the host facts. Change-only: the listener runs when a field of
+ * `getHost()` changes — not on subscribe, and not when only the viewport's
+ * size moves within its size class. Returns an unsubscribe.
+ */
+export function subscribeHost(listener) {
+    let last = getHost();
+    const check = () => {
+        const next = getHost();
+        if (next === last)
+            return;
+        last = next;
+        listener();
+    };
+    const stopLanguage = subscribeDisplayLanguage(check);
+    const stopSurface = subscribeSurfaceContext(check);
+    return () => {
+        stopLanguage();
+        stopSurface();
+    };
+}

package/dist/es2020/index.js

@@ -7,8 +7,8 @@
  */
 export { LingXiaBridge, channel, initBridge, invoke, notify, stream, } from './bridge';
 export { isNativeError } from './invocation';
-export { getDisplayLanguage, subscribeDisplayLanguage } from './runtime-env';
-export { renderErrorUI, hasError, getErrorInfo } from './error';
+export { getHost, subscribeHost } from './host';
+export { renderErrorUI, renderPageFault, hasError, getErrorInfo } from './error';
 export { boot, bootWhenReady } from './boot';
 import { bootWhenReady } from './boot';
 import { registerUIHandlers } from './ui';

package/dist/es2020/runtime-env.js

@@ -23,9 +23,30 @@ function store() {
     }
     return window.__lxDisplayLanguage;
 }
+/** Primary subtags of languages written right to left, for engines without `Intl.Locale#getTextInfo`. */
+const RTL_LANGUAGES = new Set(['ar', 'ckb', 'dv', 'fa', 'he', 'ps', 'sd', 'ug', 'ur', 'yi']);
+/** The writing direction of a BCP-47 tag. */
+export function textDirection(tag) {
+    try {
+        const locale = new Intl.Locale(tag);
+        const info = typeof locale.getTextInfo === 'function' ? locale.getTextInfo() : locale.textInfo;
+        if (info?.direction === 'rtl' || info?.direction === 'ltr')
+            return info.direction;
+    }
+    catch {
+        // Not a tag `Intl` accepts; fall through to the subtag list.
+    }
+    return RTL_LANGUAGES.has(tag.split(/[-_]/)[0].toLowerCase()) ? 'rtl' : 'ltr';
+}
+/**
+ * `lang` and `dir` on `<html>` follow the display language, so a page never
+ * sets either: CSS logical properties and `:dir()` just work.
+ */
 function stampDocumentLanguage() {
     if (typeof document !== 'undefined' && document.documentElement) {
-        document.documentElement.lang = store().value;
+        const language = store().value;
+        document.documentElement.lang = language;
+        document.documentElement.dir = textDirection(language);
     }
 }
 stampDocumentLanguage();
@@ -33,10 +54,21 @@ stampDocumentLanguage();
  * Host entry point for a language the user changed while this document was
  * open. Bootstrap alone would leave a live page in the language it started in,
  * with the native chrome around it already switched.
+ *
+ * The host pushes each change once, and again — the current value — when a
+ * document's bridge reports ready, since a change made while it loaded found
+ * no hook to call. Those two can land in either order, so a push carries the
+ * host revision it took effect at and an older one never overwrites a newer
+ * one. A push without a revision applies as it always did.
  */
-function applyDisplayLanguage(next) {
+function applyDisplayLanguage(next, revision) {
     const normalized = typeof next === 'string' ? next.trim() : '';
     const current = store();
+    if (typeof revision === 'number' && Number.isFinite(revision)) {
+        if (revision <= (current.revision ?? 0))
+            return;
+        current.revision = revision;
+    }
     if (!normalized || normalized === current.value)
         return;
     current.value = normalized;

package/dist/es2020/surface-context.js

@@ -0,0 +1,86 @@
+/** What a host that sends nothing — one older than this API — is taken to say. */
+const UNREPORTED = { sizeClass: 'compact', width: 0, height: 0, aside: false };
+/**
+ * One store per document, on `window`, for the same reason as the display
+ * language: the bridge module is present twice in a page, and the host must
+ * reach the copy the framework hooks read.
+ */
+function store() {
+    if (typeof window === 'undefined')
+        return fallbackStore;
+    if (!window.__lxSurfaceContext) {
+        // Seeded by the host in this document's bridge config, before any script.
+        const config = window.__LX_BRIDGE_CFG;
+        window.__lxSurfaceContext = {
+            value: parse(config?.surfaceContext) ?? UNREPORTED,
+            revision: typeof config?.surfaceContextRevision === 'number' ? config.surfaceContextRevision : 0,
+            listeners: new Set(),
+        };
+    }
+    return window.__lxSurfaceContext;
+}
+const fallbackStore = { value: UNREPORTED, revision: 0, listeners: new Set() };
+function parse(next) {
+    if (typeof next !== 'object' || next === null)
+        return null;
+    const { sizeClass, width, height, aside } = next;
+    if (sizeClass !== 'compact' && sizeClass !== 'regular')
+        return null;
+    if (typeof width !== 'number' || typeof height !== 'number')
+        return null;
+    return { sizeClass, width, height, aside: aside === true };
+}
+function same(a, b) {
+    return a.sizeClass === b.sizeClass
+        && a.width === b.width
+        && a.height === b.height
+        && a.aside === b.aside;
+}
+/**
+ * Host entry point: once the page's bridge is up, and on every change. Pushes
+ * can run out of order across host threads, so each carries a revision and an
+ * older one than the store holds is dropped.
+ */
+function applySurfaceContext(next, revision) {
+    const context = parse(next);
+    const current = store();
+    if (!context)
+        return;
+    if (typeof revision === 'number') {
+        if (revision <= current.revision)
+            return;
+        current.revision = revision;
+    }
+    if (same(current.value, context))
+        return;
+    // A new object per change, so `useSyncExternalStore` sees it changed.
+    current.value = context;
+    for (const listener of [...current.listeners])
+        listener();
+}
+if (typeof window !== 'undefined' && !window.__lingxiaApplySurfaceContext) {
+    Object.defineProperty(window, '__lingxiaApplySurfaceContext', {
+        configurable: false,
+        enumerable: false,
+        value: applySurfaceContext,
+    });
+}
+/**
+ * The lxapp's adaptive context. The host seeds it into every page before any
+ * script runs and pushes each change, so there is always a value; a host older
+ * than this API reports `compact` with a 0×0 viewport.
+ */
+export function getSurfaceContext() {
+    return store().value;
+}
+/**
+ * Follow the adaptive context. Change-only, like `subscribeDisplayLanguage`,
+ * so it composes with `useSyncExternalStore`. Returns an unsubscribe.
+ */
+export function subscribeSurfaceContext(listener) {
+    const listeners = store().listeners;
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}

package/dist/es5/bridge.js

@@ -96,7 +96,8 @@ import { BRIDGE_ERROR } from "./types";
 import { toBridgeError, toNativeError } from "./invocation";
 import { installNativeComponentCoverageMonitor } from "./nativecomponents/coverage-monitor";
 import { consumeV3Bootstrap, } from "./protocol-v3";
-import { BRIDGE_CONFIG, getCommunicationMethod, getDisplayLanguage, getPlatformOS, subscribeDisplayLanguage, isAndroid, isHarmony, isIOS, isMacOS, isWindows, isDesktop, isMobile, isApple, isDevSession, isRunner, } from "./runtime-env";
+import { getHost, subscribeHost } from "./host";
+import { BRIDGE_CONFIG, getCommunicationMethod, getPlatformOS, isAndroid, isHarmony, isIOS, isMacOS, isWindows, isDesktop, isMobile, isApple, isDevSession, isRunner, } from "./runtime-env";
 var NATIVE_HANDLER_NAME = "LingXia";
 var GLOBAL_RECEIVER_NAME = "__LingXiaRecvMessage";
 var DEFAULT_TIMEOUT_MS = 5000;
@@ -930,6 +931,16 @@ function createStreamHandle(id, cancelFn) {
                         pendingReads.push({ resolve: resolve, reject: reject });
                     });
                 },
+                // Leaving a `for await` early cancels the stream, as with a
+                // ReadableStream: nothing is left buffering for a gone reader.
+                return: function () {
+                    iteratorRequested = false;
+                    pendingData.length = 0;
+                    // The cancel settles `result` with BRIDGE_CANCELED; the reader asked for it.
+                    result.catch(function () { });
+                    handle.cancel();
+                    return Promise.resolve({ done: true, value: undefined });
+                },
             };
         },
         _a.cancel = function () {
@@ -1031,6 +1042,7 @@ function createChannel(id, sendFn, closeFn) {
     var open = false;
     var outboundSeq = 0;
     var closed = false;
+    var closeEmitted = false;
     // Only buffer for the async iterator or pre-first-listener replay;
     // otherwise a listener-driven channel would accumulate payloads forever.
     var iteratorRequested = false;
@@ -1102,13 +1114,20 @@ function createChannel(id, sendFn, closeFn) {
                         pendingReads.push({ resolve: resolve, reject: reject });
                     });
                 },
+                // Leaving a `for await` early closes the channel, as with a
+                // ReadableStream: nothing is left buffering for a gone reader.
+                return: function () {
+                    iteratorRequested = false;
+                    pendingData.length = 0;
+                    channel.close();
+                    return Promise.resolve({ done: true, value: undefined });
+                },
             };
         },
         _a.close = function (code, reason) {
             if (!open)
                 return;
             open = false;
-            closed = true;
             closeFn(code, reason);
             channel._emitClose(code, reason);
         },
@@ -1143,7 +1162,12 @@ function createChannel(id, sendFn, closeFn) {
         },
         _a._emitClose = function (code, reason) {
             var e_14, _a;
+            // One close notification, whichever side closed first.
+            open = false;
             closed = true;
+            if (closeEmitted)
+                return;
+            closeEmitted = true;
             while (pendingReads.length > 0) {
                 pendingReads.shift().resolve({ done: true, value: undefined });
             }
@@ -1168,6 +1192,7 @@ function createChannel(id, sendFn, closeFn) {
         },
         _a._reject = function (err) {
             var e_15, _a;
+            open = false;
             closed = true;
             while (pendingReads.length > 0) {
                 pendingReads.shift().reject(err);
@@ -2181,11 +2206,11 @@ export var LingXiaBridge = {
             handleIncomingMessage(messageString);
     },
     debug: createDebugObject(debugFlags),
-    // The host language, for documents that cannot bundle `@lingxia/bridge` —
+    // The host facts, for documents that cannot bundle `@lingxia/bridge` —
     // browser internal pages and plain-HTML lxapps load this runtime as a script.
-    displayLanguage: {
-        get: getDisplayLanguage,
-        subscribe: subscribeDisplayLanguage,
+    host: {
+        get: getHost,
+        subscribe: subscribeHost,
     },
     platform: {
         isHarmony: isHarmony,
@@ -2308,8 +2333,19 @@ function wrapNativeStream(handle) {
 function wrapNativeChannel(channel) {
     var messageListeners = new Set();
     var closeListeners = new Set();
+    // Messages that arrive with the open ack, before the caller could call
+    // `onMessage`, wait for it until the next task; a channel nobody listens
+    // to buffers nothing after that.
+    var early = [];
+    setTimeout(function () {
+        early = null;
+    }, 0);
     channel.on("data", function (message) {
         var e_21, _a;
+        if (messageListeners.size === 0) {
+            early === null || early === void 0 ? void 0 : early.push(message);
+            return;
+        }
         try {
             for (var messageListeners_1 = __values(messageListeners), messageListeners_1_1 = messageListeners_1.next(); !messageListeners_1_1.done; messageListeners_1_1 = messageListeners_1.next()) {
                 var listener = messageListeners_1_1.value;
@@ -2346,7 +2382,23 @@ function wrapNativeChannel(channel) {
             channel.send(message);
         },
         onMessage: function (listener) {
+            var e_23, _a;
             messageListeners.add(listener);
+            var replay = early;
+            early = null;
+            try {
+                for (var _b = __values(replay !== null && replay !== void 0 ? replay : []), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var message = _c.value;
+                    listener(message);
+                }
+            }
+            catch (e_23_1) { e_23 = { error: e_23_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_23) throw e_23.error; }
+            }
             return function () {
                 messageListeners.delete(listener);
             };

package/dist/es5/error.js

@@ -4,8 +4,8 @@ function escapeHtml(str) {
     div.textContent = str;
     return div.innerHTML;
 }
-export function renderErrorUI(errorInfo) {
-    var failedPath = errorInfo.failedPath, reason = errorInfo.reason;
+function renderPanel(_a) {
+    var code = _a.code, title = _a.title, description = _a.description, detail = _a.detail, reason = _a.reason;
     var styleEl = document.createElement('style');
     styleEl.textContent = ERROR_STYLES;
     document.head.appendChild(styleEl);
@@ -13,11 +13,11 @@ export function renderErrorUI(errorInfo) {
     document.body.style.cssText = '';
     var container = document.createElement('div');
     container.className = 'lx-error';
-    var html = '<div class="lx-error-code">404</div>';
-    html += '<h1 class="lx-error-title">Page Not Found</h1>';
-    html += '<p class="lx-error-desc">The page you\'re looking for doesn\'t exist.</p>';
-    if (failedPath) {
-        html += "<div class=\"lx-error-path\">".concat(escapeHtml(failedPath), "</div>");
+    var html = "<div class=\"lx-error-code\">".concat(escapeHtml(code), "</div>");
+    html += "<h1 class=\"lx-error-title\">".concat(escapeHtml(title), "</h1>");
+    html += "<p class=\"lx-error-desc\">".concat(escapeHtml(description), "</p>");
+    if (detail) {
+        html += "<div class=\"lx-error-path\">".concat(escapeHtml(detail), "</div>");
     }
     if (reason) {
         html += "<p class=\"lx-error-desc\" style=\"margin-top:12px\">".concat(escapeHtml(reason), "</p>");
@@ -25,6 +25,44 @@ export function renderErrorUI(errorInfo) {
     container.innerHTML = html;
     document.body.appendChild(container);
 }
+export function renderErrorUI(errorInfo) {
+    renderPanel({
+        code: '404',
+        title: 'Page Not Found',
+        description: "The page you're looking for doesn't exist.",
+        detail: errorInfo.failedPath,
+        reason: errorInfo.reason,
+    });
+}
+/**
+ * A page whose Logic has not delivered its first state in time — it failed to
+ * load, threw before the page could start, or is very slow. Shown over the page
+ * instead of a blank screen, naming the page; returns a function that removes
+ * it, for when the state does arrive after all.
+ */
+export function renderPageFault(pagePath, reason) {
+    var styleEl = document.createElement('style');
+    styleEl.textContent = "\n.lx-page-fault { position: fixed; inset: 0; z-index: 2147483647; overflow: auto;\n  background: #fff; color: #1d1d1f; }\n@media (prefers-color-scheme: dark) { .lx-page-fault { background: #000; color: #f5f5f7; } }\n".concat(ERROR_STYLES.replace(/\bbody\b/g, '.lx-page-fault'));
+    document.head.appendChild(styleEl);
+    var overlay = document.createElement('div');
+    overlay.className = 'lx-page-fault';
+    overlay.setAttribute('role', 'alert');
+    var container = document.createElement('div');
+    container.className = 'lx-error';
+    var html = '<div class="lx-error-code">Page</div>';
+    html += "<h1 class=\"lx-error-title\">".concat(escapeHtml("This page couldn't start"), "</h1>");
+    html += "<p class=\"lx-error-desc\">".concat(escapeHtml('Its Logic has not delivered the page state. Check the Logic log for an error.'), "</p>");
+    if (pagePath)
+        html += "<div class=\"lx-error-path\">".concat(escapeHtml(pagePath), "</div>");
+    html += "<p class=\"lx-error-desc\" style=\"margin-top:12px\">".concat(escapeHtml(reason), "</p>");
+    container.innerHTML = html;
+    overlay.appendChild(container);
+    document.body.appendChild(overlay);
+    return function () {
+        overlay.remove();
+        styleEl.remove();
+    };
+}
 export function hasError() {
     var config = window.__LX_RUNTIME_CONFIG;
     return !!(config && config.error);

package/dist/es5/host.js

@@ -0,0 +1,53 @@
+import { BRIDGE_CONFIG, getDisplayLanguage, getPlatformOS, isDesktop, subscribeDisplayLanguage, } from './runtime-env';
+import { getSurfaceContext, subscribeSurfaceContext } from './surface-context';
+var current = null;
+function read() {
+    var surface = getSurfaceContext();
+    return {
+        sizeClass: surface.sizeClass,
+        aside: surface.aside,
+        displayLanguage: getDisplayLanguage(),
+        formFactor: isDesktop() ? 'desktop' : 'mobile',
+        os: getPlatformOS(),
+        runner: BRIDGE_CONFIG.runner === true,
+    };
+}
+function same(a, b) {
+    return a.sizeClass === b.sizeClass
+        && a.aside === b.aside
+        && a.displayLanguage === b.displayLanguage
+        && a.formFactor === b.formFactor
+        && a.os === b.os
+        && a.runner === b.runner;
+}
+/**
+ * The host facts for this page. The same object is returned until a field
+ * changes, so it composes with `useSyncExternalStore` and with memoization.
+ */
+export function getHost() {
+    var next = read();
+    if (current === null || !same(current, next))
+        current = next;
+    return current;
+}
+/**
+ * Follow the host facts. Change-only: the listener runs when a field of
+ * `getHost()` changes — not on subscribe, and not when only the viewport's
+ * size moves within its size class. Returns an unsubscribe.
+ */
+export function subscribeHost(listener) {
+    var last = getHost();
+    var check = function () {
+        var next = getHost();
+        if (next === last)
+            return;
+        last = next;
+        listener();
+    };
+    var stopLanguage = subscribeDisplayLanguage(check);
+    var stopSurface = subscribeSurfaceContext(check);
+    return function () {
+        stopLanguage();
+        stopSurface();
+    };
+}

package/dist/es5/index.js

@@ -7,8 +7,8 @@
  */
 export { LingXiaBridge, channel, initBridge, invoke, notify, stream, } from './bridge';
 export { isNativeError } from './invocation';
-export { getDisplayLanguage, subscribeDisplayLanguage } from './runtime-env';
-export { renderErrorUI, hasError, getErrorInfo } from './error';
+export { getHost, subscribeHost } from './host';
+export { renderErrorUI, renderPageFault, hasError, getErrorInfo } from './error';
 export { boot, bootWhenReady } from './boot';
 import { bootWhenReady } from './boot';
 import { registerUIHandlers } from './ui';

package/dist/es5/runtime-env.js

@@ -61,9 +61,30 @@ function store() {
     }
     return window.__lxDisplayLanguage;
 }
+/** Primary subtags of languages written right to left, for engines without `Intl.Locale#getTextInfo`. */
+var RTL_LANGUAGES = new Set(['ar', 'ckb', 'dv', 'fa', 'he', 'ps', 'sd', 'ug', 'ur', 'yi']);
+/** The writing direction of a BCP-47 tag. */
+export function textDirection(tag) {
+    try {
+        var locale = new Intl.Locale(tag);
+        var info = typeof locale.getTextInfo === 'function' ? locale.getTextInfo() : locale.textInfo;
+        if ((info === null || info === void 0 ? void 0 : info.direction) === 'rtl' || (info === null || info === void 0 ? void 0 : info.direction) === 'ltr')
+            return info.direction;
+    }
+    catch (_a) {
+        // Not a tag `Intl` accepts; fall through to the subtag list.
+    }
+    return RTL_LANGUAGES.has(tag.split(/[-_]/)[0].toLowerCase()) ? 'rtl' : 'ltr';
+}
+/**
+ * `lang` and `dir` on `<html>` follow the display language, so a page never
+ * sets either: CSS logical properties and `:dir()` just work.
+ */
 function stampDocumentLanguage() {
     if (typeof document !== 'undefined' && document.documentElement) {
-        document.documentElement.lang = store().value;
+        var language = store().value;
+        document.documentElement.lang = language;
+        document.documentElement.dir = textDirection(language);
     }
 }
 stampDocumentLanguage();
@@ -71,25 +92,37 @@ stampDocumentLanguage();
  * Host entry point for a language the user changed while this document was
  * open. Bootstrap alone would leave a live page in the language it started in,
  * with the native chrome around it already switched.
+ *
+ * The host pushes each change once, and again — the current value — when a
+ * document's bridge reports ready, since a change made while it loaded found
+ * no hook to call. Those two can land in either order, so a push carries the
+ * host revision it took effect at and an older one never overwrites a newer
+ * one. A push without a revision applies as it always did.
  */
-function applyDisplayLanguage(next) {
+function applyDisplayLanguage(next, revision) {
     var e_1, _a;
+    var _b;
     var normalized = typeof next === 'string' ? next.trim() : '';
     var current = store();
+    if (typeof revision === 'number' && Number.isFinite(revision)) {
+        if (revision <= ((_b = current.revision) !== null && _b !== void 0 ? _b : 0))
+            return;
+        current.revision = revision;
+    }
     if (!normalized || normalized === current.value)
         return;
     current.value = normalized;
     stampDocumentLanguage();
     try {
-        for (var _b = __values(__spreadArray([], __read(current.listeners), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var listener = _c.value;
+        for (var _c = __values(__spreadArray([], __read(current.listeners), false)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var listener = _d.value;
             listener(normalized);
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
     finally {
         try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
         finally { if (e_1) throw e_1.error; }
     }