@lingxia/html 0.18.0 → 0.20.0

package/dist/global.es5.js

@@ -9,9 +9,55 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var LingXiaPage = (function (exports) {
+    var _a;
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-    //#region dist/__page_runtime_runtime__.js
+    //#region ../lingxia-page-runtime/dist/shared/runtime.js
     var snapshot = {};
     var stateInfo = {
         rev: -1,
@@ -19,7 +65,16 @@ var LingXiaPage = (function (exports) {
     };
     var subscribed = false;
     var subscribeRetryTimer = null;
+    var snapshotRetryTimer = null;
+    var snapshotRetries = 0;
+    /**
+    * The host pushes a page's first state at bridge-ready, so the request is only
+    * a fallback: a few tries, backing off, then stop. A page with no Logic never
+    * answers, and must not be asked for the life of the page.
+    */
+    var MAX_SNAPSHOT_RETRIES = 3;
     var initialSnapshotResolved = false;
+    var actions = null;
     var snapshotRequestInFlight = false;
     var listeners = /* @__PURE__ */ new Set();
     function notifyListeners() {
@@ -30,8 +85,28 @@ var LingXiaPage = (function (exports) {
             catch (_a) { }
         });
     }
+    /**
+    * In a dev session the page data is frozen, so a View that writes to it fails
+    * at the write instead of drifting from Logic until the next update. Each
+    * push is a fresh copy, so nothing else holds these objects.
+    */
+    function isDevSession() {
+        var _a;
+        return typeof window !== "undefined" && ((_a = window.__LX_BRIDGE_CFG) === null || _a === void 0 ? void 0 : _a.dev) === true;
+    }
+    function deepFreeze(value) {
+        if (!value || typeof value !== "object" || Object.isFrozen(value))
+            return;
+        Object.freeze(value);
+        for (var _i = 0, _a = Object.keys(value); _i < _a.length; _i++) {
+            var key = _a[_i];
+            deepFreeze(value[key]);
+        }
+    }
     function updateSnapshot(next, info) {
         snapshot = next && typeof next === "object" ? next : {};
+        if (isDevSession())
+            deepFreeze(snapshot);
         stateInfo = info;
         notifyListeners();
     }
@@ -43,17 +118,35 @@ var LingXiaPage = (function (exports) {
             ensurePageBridgeSubscription();
         }, 10);
     }
+    /**
+    * Retry the snapshot request itself. The subscription is already in place, so
+    * retrying it (as this used to) returned at once and never asked again; the
+    * page then relied on the host's own push at bridge-ready.
+    */
+    function scheduleSnapshotRetry() {
+        if (snapshotRetryTimer !== null || snapshotRetries >= MAX_SNAPSHOT_RETRIES)
+            return;
+        snapshotRetries += 1;
+        snapshotRetryTimer = setTimeout(function () {
+            snapshotRetryTimer = null;
+            requestInitialSnapshot(window.LingXiaBridge);
+        }, 250 * Math.pow(2, (snapshotRetries - 1)));
+    }
     function requestInitialSnapshot(bridge) {
         var _a;
+        if (stateInfo.rev >= 0)
+            initialSnapshotResolved = true;
         if (initialSnapshotResolved || snapshotRequestInFlight)
             return;
-        if (!((_a = bridge === null || bridge === void 0 ? void 0 : bridge.raw) === null || _a === void 0 ? void 0 : _a.call))
+        if (!((_a = bridge === null || bridge === void 0 ? void 0 : bridge.raw) === null || _a === void 0 ? void 0 : _a.call)) {
+            scheduleSnapshotRetry();
             return;
+        }
         snapshotRequestInFlight = true;
         bridge.raw.call("state.getSnapshot", { scope: "page" }).then(function () {
             initialSnapshotResolved = true;
         }).catch(function () {
-            scheduleSubscribeRetry();
+            scheduleSnapshotRetry();
         }).finally(function () {
             snapshotRequestInFlight = false;
         });
@@ -81,41 +174,68 @@ var LingXiaPage = (function (exports) {
             listeners.delete(listener);
         };
     }
-    function subscribePageData(callback) {
-        if (typeof callback !== "function")
-            return function () { };
+    /** Whether the page's first state has arrived. Flips once per document. */
+    function isPageReady() {
         ensurePageBridgeSubscription();
-        if (stateInfo.rev >= 0)
-            callback(snapshot, {
-                rev: stateInfo.rev,
-                initial: true
-            });
-        return subscribePageSnapshot(function () {
-            callback(snapshot, stateInfo);
+        return stateInfo.rev >= 0;
+    }
+    /**
+    * Resolves once the page's first state has arrived — the host pushes it at
+    * bridge-ready, before `onLoad`, carrying `Page({ data })`'s defaults — so a
+    * page can mount with its data whole. With `timeoutMs`, rejects if Logic has
+    * not delivered it by then (it failed to load, or threw first); `null` waits
+    * without limit.
+    */
+    function whenPageReady(options) {
+        if (options === void 0) { options = {}; }
+        if (isPageReady())
+            return Promise.resolve();
+        var timeoutMs = options.timeoutMs === void 0 ? 1e4 : options.timeoutMs;
+        return new Promise(function (resolve, reject) {
+            var timer = null;
+            var check = function () {
+                if (stateInfo.rev < 0)
+                    return;
+                if (timer !== null)
+                    clearTimeout(timer);
+                listeners.delete(check);
+                resolve();
+            };
+            if (timeoutMs !== null)
+                timer = setTimeout(function () {
+                    listeners.delete(check);
+                    reject(/* @__PURE__ */ new Error("Page Logic did not deliver the page state within ".concat(timeoutMs, " ms")));
+                }, timeoutMs);
+            listeners.add(check);
         });
     }
     function getPageSnapshot() {
         ensurePageBridgeSubscription();
         return snapshot;
     }
+    /**
+    * The page's actions: one object for the whole page, so it is a stable
+    * dependency. Built on first use — the page's action names arrive with its
+    * bridge metadata, after the page module has evaluated.
+    */
     function getPageActions() {
-        var actions = {};
+        if (actions)
+            return actions;
         var bridge = window.__pageBridge;
         if (!(bridge === null || bridge === void 0 ? void 0 : bridge.__names))
-            return actions;
+            throw new Error("Page actions are not ready. Read useLxPage() during component setup/render, or getPage() after pageReady(); pass actions into shared helpers.");
+        var built = {};
         for (var _i = 0, _a = bridge.__names; _i < _a.length; _i++) {
             var name = _a[_i];
             if (typeof name !== "string")
                 continue;
             var fn = getOrCreatePageAction(bridge, name);
             if (typeof fn === "function")
-                actions[name] = fn;
+                built[name] = fn;
         }
+        actions = built;
         return actions;
     }
-    function getPageStateInfo() {
-        return stateInfo;
-    }
     function getOrCreatePageAction(bridge, name) {
         var existing = bridge[name];
         if (typeof existing === "function")
@@ -127,7 +247,9 @@ var LingXiaPage = (function (exports) {
     function resolvePageActionMode(bridge, name) {
         var _a;
         var mode = (_a = bridge.__modes) === null || _a === void 0 ? void 0 : _a[name];
-        return mode === "call" || mode === "stream" ? mode : "notify";
+        if (mode === "call" || mode === "stream")
+            return mode;
+        throw new Error("Invalid bridge mode for page action '".concat(name, "'; regenerate the page with the current CLI"));
     }
     function definePageBridgeAction(name, mode) {
         function action() {
@@ -148,14 +270,14 @@ var LingXiaPage = (function (exports) {
                 return handle;
             }
             if (mode === "call") {
-                var promise = bridge.raw.call(name, payload);
+                var promise = callUnaryPageAction(bridge, name, payload);
                 if (promise && typeof promise.catch === "function")
                     promise.catch(function (err) {
                         console.warn("[PageFunc] ".concat(name, " failed:"), err instanceof Error ? err.message : err);
                     });
                 return promise;
             }
-            bridge.raw.notify(name, payload);
+            throw new Error("Invalid bridge mode for page action '".concat(name, "'"));
         }
         Object.assign(action, {
             __logicFunc: true,
@@ -164,35 +286,463 @@ var LingXiaPage = (function (exports) {
         });
         return action;
     }
+    /**
+    * The one wire path of a unary action. It has no bridge deadline: an action
+    * may wait for a person or poll for minutes, and settles when Logic settles
+    * or the document goes away.
+    */
+    function callUnaryPageAction(bridge_1, name_1, payload_1) {
+        return __awaiter(this, arguments, void 0, function (bridge, name, payload, dropWhenGone) {
+            var error_1;
+            if (dropWhenGone === void 0) { dropWhenGone = true; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!isPageReady()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, whenPageReady({ timeoutMs: null })];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, bridge.raw.call(name, payload, { timeoutMs: 0 })];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_1 = _a.sent();
+                        if (dropWhenGone && (error_1 === null || error_1 === void 0 ? void 0 : error_1.code) === "BRIDGE_NOT_READY")
+                            return [2 /*return*/, new Promise(function () { })];
+                        throw error_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+    * A DOM or framework event, in this realm or another. A JSON payload never
+    * carries methods, so event methods tell the two apart.
+    */
+    function isEventLike(value) {
+        if (typeof Event !== "undefined" && value instanceof Event)
+            return true;
+        if (!value || typeof value !== "object")
+            return false;
+        var event = value;
+        return typeof event.preventDefault === "function" && typeof event.stopPropagation === "function";
+    }
+    var PAGE_ACTIONS_NOT_READY = "PAGE_ACTIONS_NOT_READY";
+    function pageActionError(code, message) {
+        return Object.assign(new Error(message), { code: code });
+    }
+    /**
+    * Automation entry (`PageDriver.action`): invoke one unary action of this
+    * page with a JSON payload, as the View would. The payload is passed as is —
+    * no DOM-event repackaging.
+    */
+    function invokePageActionForAutomation(name, payload) {
+        var _a;
+        if (typeof name !== "string" || name === "")
+            return Promise.reject(pageActionError("BRIDGE_MALFORMED_MESSAGE", "Page action name must be a non-empty string"));
+        var metadata = window.__pageBridge;
+        var bridge = window.LingXiaBridge;
+        if (!Array.isArray(metadata === null || metadata === void 0 ? void 0 : metadata.__names) || !(bridge === null || bridge === void 0 ? void 0 : bridge.raw))
+            return Promise.reject(pageActionError(PAGE_ACTIONS_NOT_READY, "Page actions are not ready yet"));
+        if (!metadata.__names.includes(name)) {
+            var known = metadata.__names.length ? metadata.__names.join(", ") : "none";
+            return Promise.reject(pageActionError("BRIDGE_METHOD_NOT_FOUND", "'".concat(name, "' is not an action of this page (actions: ").concat(known, ")")));
+        }
+        if (((_a = metadata.__modes) === null || _a === void 0 ? void 0 : _a[name]) !== "call")
+            return Promise.reject(pageActionError("PAGE_ACTION_NOT_UNARY", "Page action '".concat(name, "' is a stream action; only unary actions can be invoked")));
+        return callUnaryPageAction(bridge, name, payload, false);
+    }
+    if (typeof window !== "undefined")
+        Object.defineProperty(window, "__lxInvokePageAction", {
+            value: invokePageActionForAutomation,
+            configurable: true
+        });
     function filterPayload(name, args) {
         var clean = [];
         for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
             var value = args_1[_i];
-            if (typeof CustomEvent !== "undefined" && value instanceof CustomEvent) {
-                clean.push({
-                    type: value.type,
-                    detail: value.detail
-                });
-                continue;
-            }
-            var maybeEvent = value;
-            if (maybeEvent && typeof maybeEvent === "object" && typeof maybeEvent.type === "string" && "detail" in maybeEvent) {
-                clean.push({
-                    type: maybeEvent.type,
-                    detail: maybeEvent.detail
-                });
+            if (isEventLike(value)) {
+                var event = value;
+                if (typeof event.type === "string" && "detail" in event)
+                    clean.push({
+                        type: event.type,
+                        detail: event.detail
+                    });
                 continue;
             }
-            if (value instanceof Event)
-                continue;
-            if (value && typeof value === "object" && "stopPropagation" in value && typeof value.stopPropagation === "function")
-                continue;
             clean.push(value);
         }
         if (clean.length > 1)
             throw new Error("Page action '".concat(name, "' accepts at most one payload argument"));
         return clean[0];
     }
+    //#endregion
+    //#region ../lingxia-bridge/dist/es2020/error.js
+    var ERROR_STYLES = "\n* { margin: 0; padding: 0; box-sizing: border-box; }\nbody {\n  font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Text', 'Segoe UI', Roboto, sans-serif;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  min-height: 100vh;\n  background: #f5f5f7;\n  color: #1d1d1f;\n  padding: 20px;\n  -webkit-font-smoothing: antialiased;\n}\n.lx-error {\n  text-align: center;\n  max-width: 400px;\n}\n.lx-error-code {\n  font-size: 120px;\n  font-weight: 700;\n  color: #d1d1d6;\n  line-height: 1;\n  letter-spacing: -4px;\n}\n.lx-error-title {\n  font-size: 21px;\n  font-weight: 600;\n  margin: 16px 0 8px;\n  color: #1d1d1f;\n}\n.lx-error-desc {\n  font-size: 15px;\n  color: #86868b;\n  line-height: 1.5;\n}\n.lx-error-path {\n  display: inline-block;\n  margin-top: 20px;\n  padding: 10px 16px;\n  background: rgba(0,0,0,0.04);\n  border-radius: 8px;\n  font-family: 'SF Mono', ui-monospace, Menlo, Monaco, monospace;\n  font-size: 13px;\n  color: #1d1d1f;\n  word-break: break-all;\n  max-width: 100%;\n}\n@media (prefers-color-scheme: dark) {\n  body { background: #000; color: #f5f5f7; }\n  .lx-error-code { color: #3a3a3c; }\n  .lx-error-title { color: #f5f5f7; }\n  .lx-error-desc { color: #86868b; }\n  .lx-error-path { background: rgba(255,255,255,0.08); color: #f5f5f7; }\n}\n";
+    function escapeHtml(str) {
+        var div = document.createElement("div");
+        div.textContent = str;
+        return div.innerHTML;
+    }
+    /**
+    * 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.
+    */
+    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();
+        };
+    }
+    //#endregion
+    //#region ../lingxia-bridge/dist/es2020/runtime-env.js
+    var BRIDGE_CONFIG = typeof window !== "undefined" && window.__LX_BRIDGE_CFG || {};
+    /**
+    * One store per document, deliberately on `window`.
+    *
+    * This module is present twice in a page: once as the global bridge runtime
+    * the host injects, once bundled into the page's own JS. Module-local state
+    * would give each copy its own value — the host would push the change into
+    * whichever copy won the race to install the hook, and the other, which is the
+    * one the framework hooks read, would answer with the boot value forever.
+    */
+    var fallbackStore$1 = {
+        value: ((_a = BRIDGE_CONFIG.displayLanguage) === null || _a === void 0 ? void 0 : _a.trim()) || "en-US",
+        listeners: /* @__PURE__ */ new Set()
+    };
+    function store$1() {
+        var _a;
+        if (typeof window === "undefined")
+            return fallbackStore$1;
+        if (!window.__lxDisplayLanguage)
+            window.__lxDisplayLanguage = {
+                value: ((_a = BRIDGE_CONFIG.displayLanguage) === null || _a === void 0 ? void 0 : _a.trim()) || "en-US",
+                listeners: /* @__PURE__ */ new Set()
+            };
+        return window.__lxDisplayLanguage;
+    }
+    /** Primary subtags of languages written right to left, for engines without `Intl.Locale#getTextInfo`. */
+    var RTL_LANGUAGES = /* @__PURE__ */ new Set([
+        "ar",
+        "ckb",
+        "dv",
+        "fa",
+        "he",
+        "ps",
+        "sd",
+        "ug",
+        "ur",
+        "yi"
+    ]);
+    /** The writing direction of a BCP-47 tag. */
+    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) { }
+        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) {
+            var language = store$1().value;
+            document.documentElement.lang = language;
+            document.documentElement.dir = textDirection(language);
+        }
+    }
+    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, revision) {
+        var _a;
+        var normalized = typeof next === "string" ? next.trim() : "";
+        var current = store$1();
+        if (typeof revision === "number" && Number.isFinite(revision)) {
+            if (revision <= ((_a = current.revision) !== null && _a !== void 0 ? _a : 0))
+                return;
+            current.revision = revision;
+        }
+        if (!normalized || normalized === current.value)
+            return;
+        current.value = normalized;
+        stampDocumentLanguage();
+        for (var _i = 0, _b = __spreadArray([], current.listeners, true); _i < _b.length; _i++) {
+            var listener = _b[_i];
+            listener(normalized);
+        }
+    }
+    if (typeof window !== "undefined" && !window.__lingxiaApplyDisplayLanguage)
+        Object.defineProperty(window, "__lingxiaApplyDisplayLanguage", {
+            configurable: false,
+            enumerable: false,
+            value: applyDisplayLanguage
+        });
+    function getDisplayLanguage() {
+        return store$1().value;
+    }
+    /**
+    * Subscribe to host display-language changes. Returns an unsubscribe.
+    *
+    * Change-only, so that this composes with `useSyncExternalStore`: the listener
+    * runs when the language changes, never on subscribe. Read the current value
+    * with `getDisplayLanguage()`. Logic's `lx.host.displayLanguage.watch` differs
+    * deliberately — it has no render loop to feed, so it delivers immediately.
+    */
+    function subscribeDisplayLanguage(listener) {
+        var listeners = store$1().listeners;
+        listeners.add(listener);
+        return function () {
+            listeners.delete(listener);
+        };
+    }
+    function getPlatformOS() {
+        return BRIDGE_CONFIG.os || "unknown";
+    }
+    /**
+    * Which kind of machine this is, mobile or desktop. Read through `isMobile()`
+    * and `isDesktop()`; the class itself is host vocabulary, not lxapp API.
+    *
+    * Fixed for the life of the document. A shipped host is one machine; the
+    * Runner re-serves the page when its simulated device changes class, so this
+    * never has to change under a page that is already rendering.
+    *
+    * Hosts from before this config key shipped send nothing, so fall back to the
+    * OS: every one of them is the machine it names.
+    */
+    function hostClass() {
+        if (BRIDGE_CONFIG.hostClass === "mobile" || BRIDGE_CONFIG.hostClass === "desktop")
+            return BRIDGE_CONFIG.hostClass;
+        return BRIDGE_CONFIG.os === "macOS" || BRIDGE_CONFIG.os === "Windows" ? "desktop" : "mobile";
+    }
+    function isDesktop() {
+        return hostClass() === "desktop";
+    }
+    //#endregion
+    //#region ../lingxia-bridge/dist/es2020/surface-context.js
+    /** What a host that sends nothing — one older than this API — is taken to say. */
+    var 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() {
+        var _a;
+        if (typeof window === "undefined")
+            return fallbackStore;
+        if (!window.__lxSurfaceContext) {
+            var config = window.__LX_BRIDGE_CFG;
+            window.__lxSurfaceContext = {
+                value: (_a = parse(config === null || config === void 0 ? void 0 : config.surfaceContext)) !== null && _a !== void 0 ? _a : UNREPORTED,
+                revision: typeof (config === null || config === void 0 ? void 0 : config.surfaceContextRevision) === "number" ? config.surfaceContextRevision : 0,
+                listeners: /* @__PURE__ */ new Set()
+            };
+        }
+        return window.__lxSurfaceContext;
+    }
+    var fallbackStore = {
+        value: UNREPORTED,
+        revision: 0,
+        listeners: /* @__PURE__ */ new Set()
+    };
+    function parse(next) {
+        if (typeof next !== "object" || next === null)
+            return null;
+        var sizeClass = next.sizeClass, width = next.width, height = next.height, aside = next.aside;
+        if (sizeClass !== "compact" && sizeClass !== "regular")
+            return null;
+        if (typeof width !== "number" || typeof height !== "number")
+            return null;
+        return {
+            sizeClass: sizeClass,
+            width: width,
+            height: height,
+            aside: aside === true
+        };
+    }
+    function same$1(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) {
+        var context = parse(next);
+        var current = store();
+        if (!context)
+            return;
+        if (typeof revision === "number") {
+            if (revision <= current.revision)
+                return;
+            current.revision = revision;
+        }
+        if (same$1(current.value, context))
+            return;
+        current.value = context;
+        for (var _i = 0, _a = __spreadArray([], current.listeners, true); _i < _a.length; _i++) {
+            var listener = _a[_i];
+            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.
+    */
+    function getSurfaceContext() {
+        return store().value;
+    }
+    /**
+    * Follow the adaptive context. Change-only, like `subscribeDisplayLanguage`,
+    * so it composes with `useSyncExternalStore`. Returns an unsubscribe.
+    */
+    function subscribeSurfaceContext(listener) {
+        var listeners = store().listeners;
+        listeners.add(listener);
+        return function () {
+            listeners.delete(listener);
+        };
+    }
+    //#endregion
+    //#region ../lingxia-bridge/dist/es2020/host.js
+    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.
+    */
+    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.
+    */
+    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();
+        };
+    }
+    //#endregion
+    //#region ../lingxia-page-runtime/dist/shared/startup.js
+    var pending;
+    /** Mount with complete initial data; a delayed startup stays recoverable. */
+    function waitForPageState() {
+        if (isPageReady())
+            return Promise.resolve();
+        return pending !== null && pending !== void 0 ? pending : (pending = wait().finally(function () {
+            pending = void 0;
+        }));
+    }
+    function wait() {
+        return __awaiter(this, void 0, void 0, function () {
+            var delay, panel, timer;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        delay = 1e4;
+                        panel = {};
+                        timer = setTimeout(function () {
+                            var reason = "Page Logic has not delivered the page state after ".concat(delay, " ms");
+                            console.error("[LingXia] ".concat(location.pathname, ": ").concat(reason));
+                            panel.dismiss = renderPageFault(location.pathname, reason);
+                        }, delay);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, whenPageReady({ timeoutMs: null })];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        clearTimeout(timer);
+                        (_a = panel.dismiss) === null || _a === void 0 ? void 0 : _a.call(panel);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    //#endregion
+    //#region ../lingxia-page-runtime/dist/page-chrome.js
     var initialLayout = Object.freeze({
         revision: 0,
         topInset: 0,
@@ -208,24 +758,18 @@ var LingXiaPage = (function (exports) {
         root === null || root === void 0 ? void 0 : root.style.setProperty("--lx-page-chrome-top-inset", "".concat(layout.topInset, "px"));
         root === null || root === void 0 ? void 0 : root.style.setProperty("--lx-page-chrome-bottom-inset", "".concat(layout.bottomInset, "px"));
         root === null || root === void 0 ? void 0 : root.style.setProperty("--lx-page-chrome-capsule-inline-end-inset", "".concat(layout.capsuleInlineEndInset, "px"));
-    }
-    /** Read the latest realized page-chrome layout synchronously. */
-    function getPageChromeLayout() {
-        var _a, _b;
-        if (typeof window === "undefined")
-            return initialLayout;
-        return (_b = (_a = installPageChromeRuntime()) === null || _a === void 0 ? void 0 : _a.layout) !== null && _b !== void 0 ? _b : initialLayout;
-    }
-    /** Subscribe to realized page-chrome layout changes. */
-    function subscribePageChromeLayout(listener) {
-        if (typeof window === "undefined")
-            return function () { };
-        installPageChromeRuntime();
-        var handleChange = function (event) {
-            listener(event.detail);
-        };
-        window.addEventListener("lxpagechromechange", handleChange);
-        return function () { return window.removeEventListener("lxpagechromechange", handleChange); };
+        var capsule = layout.capsuleRect;
+        for (var _i = 0, _a = [
+            "top",
+            "right",
+            "bottom",
+            "left",
+            "width",
+            "height"
+        ]; _i < _a.length; _i++) {
+            var edge = _a[_i];
+            root === null || root === void 0 ? void 0 : root.style.setProperty("--lx-page-chrome-capsule-".concat(edge), "".concat(capsule ? capsule[edge] : 0, "px"));
+        }
     }
     /** Ensure browser previews have the same synchronous contract as native pages. */
     function installPageChromeRuntime() {
@@ -264,12 +808,34 @@ var LingXiaPage = (function (exports) {
     }
     installPageChromeRuntime();
     //#endregion
-    exports.getActions = getPageActions;
-    exports.getPageChromeLayout = getPageChromeLayout;
-    exports.getSnapshot = getPageSnapshot;
-    exports.getStateInfo = getPageStateInfo;
-    exports.subscribe = subscribePageData;
-    exports.subscribePageChromeLayout = subscribePageChromeLayout;
-    exports.subscribeSnapshot = subscribePageSnapshot;
+    //#region dist/page.js
+    /**
+    * Resolves once the first state arrives. By default a delayed startup shows
+    * a fault panel and keeps waiting, just like React/Vue. An explicit timeout
+    * rejects instead; `null` waits without the panel. Await before `getPage()`.
+    */
+    function pageReady(options) {
+        return (options === null || options === void 0 ? void 0 : options.timeoutMs) === void 0 ? waitForPageState() : whenPageReady(options);
+    }
+    /**
+    * This page's Logic state and actions — `this.data` and the page's methods.
+    * `data` is readonly: Logic owns it (in a dev session a write throws).
+    */
+    function getPage() {
+        return {
+            data: getPageSnapshot(),
+            actions: getPageActions()
+        };
+    }
+    /** Follow the page's state. Change-only; read it with `getPage()`. Returns an unsubscribe. */
+    function subscribePage(listener) {
+        return subscribePageSnapshot(listener);
+    }
+    //#endregion
+    exports.getHost = getHost;
+    exports.getPage = getPage;
+    exports.pageReady = pageReady;
+    exports.subscribeHost = subscribeHost;
+    exports.subscribePage = subscribePage;
     return exports;
 })({});