@godscene/playground-electron 1.7.11

package/dist/lib/runtime-info.js

@@ -0,0 +1,174 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildFallbackRuntimeInfo: ()=>buildFallbackRuntimeInfo,
+    filterValidExecutionUxHints: ()=>filterValidExecutionUxHints,
+    isValidDeviceType: ()=>isValidDeviceType,
+    normalizeRuntimeDeviceType: ()=>normalizeRuntimeDeviceType,
+    resolvePreviewConnectionInfo: ()=>resolvePreviewConnectionInfo
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+function isRemoteAndroidDeviceId(value) {
+    return 'string' == typeof value && /^\d+\.\d+\.\d+\.\d+:\d+$/.test(value);
+}
+const VALID_DEVICE_TYPES = [
+    'android',
+    'ios',
+    'web',
+    'harmony',
+    'computer'
+];
+const VALID_EXECUTION_UX_HINTS = [
+    'countdown-before-run'
+];
+function isValidDeviceType(type) {
+    return VALID_DEVICE_TYPES.includes(type);
+}
+function normalizeRuntimeDeviceType(runtimeInfo, fallback) {
+    var _runtimeInfo_interface;
+    const candidates = [
+        null == runtimeInfo ? void 0 : runtimeInfo.platformId,
+        null == runtimeInfo ? void 0 : null == (_runtimeInfo_interface = runtimeInfo.interface) ? void 0 : _runtimeInfo_interface.type
+    ].filter((value)=>Boolean(value));
+    for (const candidate of candidates){
+        const normalized = candidate.toLowerCase();
+        if (isValidDeviceType(normalized)) return normalized;
+    }
+    return fallback;
+}
+function buildFallbackRuntimeInfo(previousRuntimeInfo, interfaceInfo) {
+    return _object_spread_props(_object_spread({}, previousRuntimeInfo), {
+        interface: interfaceInfo,
+        preview: (null == previousRuntimeInfo ? void 0 : previousRuntimeInfo.preview) || {
+            kind: 'none',
+            capabilities: []
+        },
+        executionUxHints: (null == previousRuntimeInfo ? void 0 : previousRuntimeInfo.executionUxHints) || [],
+        metadata: (null == previousRuntimeInfo ? void 0 : previousRuntimeInfo.metadata) || {}
+    });
+}
+function filterValidExecutionUxHints(runtimeInfo) {
+    return ((null == runtimeInfo ? void 0 : runtimeInfo.executionUxHints) || []).filter((hint)=>VALID_EXECUTION_UX_HINTS.includes(hint));
+}
+function resolvePreviewConnectionInfo(runtimeInfo, serverUrl) {
+    const preview = null == runtimeInfo ? void 0 : runtimeInfo.preview;
+    if (!preview || 'none' === preview.kind || 'custom' === preview.kind) return {
+        type: 'none'
+    };
+    const resolvedServerUrl = serverUrl || "u" > typeof window && window.location.origin || '';
+    if ('mjpeg' === preview.kind) {
+        const mjpegPath = preview.mjpegPath || '/mjpeg';
+        if (!resolvedServerUrl) return {
+            type: 'screenshot'
+        };
+        return {
+            type: 'mjpeg',
+            mjpegUrl: new URL(mjpegPath, `${resolvedServerUrl}/`).toString()
+        };
+    }
+    if ('scrcpy' === preview.kind) {
+        var _runtimeInfo_metadata, _preview_custom;
+        const runtimeDeviceId = 'string' == typeof (null == runtimeInfo ? void 0 : null == (_runtimeInfo_metadata = runtimeInfo.metadata) ? void 0 : _runtimeInfo_metadata.deviceId) ? runtimeInfo.metadata.deviceId.trim() : void 0;
+        if (isRemoteAndroidDeviceId(runtimeDeviceId)) return {
+            type: 'screenshot'
+        };
+        const scrcpyPort = Number(null == (_preview_custom = preview.custom) ? void 0 : _preview_custom.scrcpyPort);
+        const resolvedScrcpyPort = Number.isFinite(scrcpyPort) ? scrcpyPort : void 0;
+        const scrcpyUrl = resolvedScrcpyPort && resolvedServerUrl ? (()=>{
+            const url = new URL(resolvedServerUrl);
+            url.port = String(resolvedScrcpyPort);
+            url.pathname = '/';
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        })() : void 0;
+        return {
+            deviceId: runtimeDeviceId,
+            type: 'scrcpy',
+            scrcpyPort: resolvedScrcpyPort,
+            scrcpyUrl
+        };
+    }
+    return {
+        type: 'screenshot'
+    };
+}
+exports.buildFallbackRuntimeInfo = __webpack_exports__.buildFallbackRuntimeInfo;
+exports.filterValidExecutionUxHints = __webpack_exports__.filterValidExecutionUxHints;
+exports.isValidDeviceType = __webpack_exports__.isValidDeviceType;
+exports.normalizeRuntimeDeviceType = __webpack_exports__.normalizeRuntimeDeviceType;
+exports.resolvePreviewConnectionInfo = __webpack_exports__.resolvePreviewConnectionInfo;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildFallbackRuntimeInfo",
+    "filterValidExecutionUxHints",
+    "isValidDeviceType",
+    "normalizeRuntimeDeviceType",
+    "resolvePreviewConnectionInfo"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/scrcpy-preview.js

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SCRCPY_METADATA_TIMEOUT_MS: ()=>SCRCPY_METADATA_TIMEOUT_MS,
+    getScrcpyDecoderStatusText: ()=>getScrcpyDecoderStatusText,
+    getScrcpyPreviewStatusText: ()=>getScrcpyPreviewStatusText,
+    getScrcpyMetadataTimeoutMessage: ()=>getScrcpyMetadataTimeoutMessage,
+    isScrcpyPreviewStatusEvent: ()=>isScrcpyPreviewStatusEvent,
+    getDefaultScrcpyWaitingStatusText: ()=>getDefaultScrcpyWaitingStatusText
+});
+const constants_namespaceObject = require("@godscene/shared/constants");
+const SCRCPY_METADATA_TIMEOUT_MS = constants_namespaceObject.SCRCPY_PREVIEW_METADATA_TIMEOUT_MS;
+function isScrcpyPreviewStatusEvent(value) {
+    return 'object' == typeof value && null !== value && 'message' in value && 'string' == typeof value.message;
+}
+function getDefaultScrcpyWaitingStatusText() {
+    return 'Preparing Android device connection…';
+}
+function getScrcpyDecoderStatusText() {
+    return 'Starting video decoder…';
+}
+function getScrcpyPreviewStatusText(status, waitingMessage = getDefaultScrcpyWaitingStatusText()) {
+    switch(status){
+        case 'connected':
+            return 'Live scrcpy preview connected';
+        case 'waiting-for-stream':
+            return waitingMessage;
+        case 'error':
+            return 'Unable to start scrcpy preview';
+        case 'disconnected':
+            return 'scrcpy preview disconnected, retrying…';
+        default:
+            return 'Connecting to scrcpy preview server…';
+    }
+}
+function getScrcpyMetadataTimeoutMessage(timeoutMs = SCRCPY_METADATA_TIMEOUT_MS) {
+    const seconds = Math.max(1, Math.round(timeoutMs / 1000));
+    return `Timed out waiting ${seconds}s for scrcpy video stream metadata.`;
+}
+exports.SCRCPY_METADATA_TIMEOUT_MS = __webpack_exports__.SCRCPY_METADATA_TIMEOUT_MS;
+exports.getDefaultScrcpyWaitingStatusText = __webpack_exports__.getDefaultScrcpyWaitingStatusText;
+exports.getScrcpyDecoderStatusText = __webpack_exports__.getScrcpyDecoderStatusText;
+exports.getScrcpyMetadataTimeoutMessage = __webpack_exports__.getScrcpyMetadataTimeoutMessage;
+exports.getScrcpyPreviewStatusText = __webpack_exports__.getScrcpyPreviewStatusText;
+exports.isScrcpyPreviewStatusEvent = __webpack_exports__.isScrcpyPreviewStatusEvent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SCRCPY_METADATA_TIMEOUT_MS",
+    "getDefaultScrcpyWaitingStatusText",
+    "getScrcpyDecoderStatusText",
+    "getScrcpyMetadataTimeoutMessage",
+    "getScrcpyPreviewStatusText",
+    "isScrcpyPreviewStatusEvent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/scrcpy-stream.js

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createScrcpyVideoStream: ()=>createScrcpyVideoStream
+});
+function createScrcpyVideoStream(socket) {
+    let configurationPacketSent = false;
+    let pendingDataPackets = [];
+    const transformStream = new TransformStream({
+        transform (chunk, controller) {
+            if ('configuration' === chunk.type) {
+                configurationPacketSent = true;
+                controller.enqueue(chunk);
+                pendingDataPackets.forEach((queuedPacket)=>controller.enqueue(queuedPacket));
+                pendingDataPackets = [];
+                return;
+            }
+            if ('data' === chunk.type && !configurationPacketSent) return void pendingDataPackets.push(chunk);
+            controller.enqueue(chunk);
+        }
+    });
+    let cleanupListeners;
+    const readable = new ReadableStream({
+        start (controller) {
+            const handleVideoData = (data)=>{
+                try {
+                    const payload = new Uint8Array(data.data);
+                    if ('configuration' === data.type) return void controller.enqueue({
+                        type: 'configuration',
+                        data: payload
+                    });
+                    controller.enqueue({
+                        type: 'data',
+                        data: payload,
+                        keyframe: data.keyFrame
+                    });
+                } catch (error) {
+                    controller.error(error);
+                }
+            };
+            const handleDisconnect = ()=>controller.close();
+            const handleError = (error)=>controller.error(error);
+            cleanupListeners = ()=>{
+                socket.off('video-data', handleVideoData);
+                socket.off('disconnect', handleDisconnect);
+                socket.off('error', handleError);
+            };
+            socket.on('video-data', handleVideoData);
+            socket.on('disconnect', handleDisconnect);
+            socket.on('error', handleError);
+        },
+        cancel () {
+            null == cleanupListeners || cleanupListeners();
+        }
+    });
+    return readable.pipeThrough(transformStream);
+}
+exports.createScrcpyVideoStream = __webpack_exports__.createScrcpyVideoStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createScrcpyVideoStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/session-setup.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveAutoCreateSessionInput: ()=>resolveAutoCreateSessionInput
+});
+const external_session_state_js_namespaceObject = require("./session-state.js");
+function hasSessionFieldValue(value) {
+    return null != value && '' !== value;
+}
+function resolveAutoCreateSessionInput(setup, existingValues = {}) {
+    if (!(null == setup ? void 0 : setup.autoSubmitWhenReady)) return null;
+    const values = (0, external_session_state_js_namespaceObject.buildSessionInitialValues)(setup, existingValues);
+    for (const field of setup.fields)if (field.required) {
+        if (!hasSessionFieldValue(values[field.key])) return null;
+    }
+    return values;
+}
+exports.resolveAutoCreateSessionInput = __webpack_exports__.resolveAutoCreateSessionInput;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveAutoCreateSessionInput"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/session-state.js

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildSessionInitialValues: ()=>buildSessionInitialValues,
+    resolveSessionViewState: ()=>resolveSessionViewState
+});
+function resolveSessionViewState(runtimeInfo) {
+    const metadata = (null == runtimeInfo ? void 0 : runtimeInfo.metadata) || {};
+    const rawSetupState = metadata.setupState;
+    const setupState = 'blocked' === rawSetupState || 'ready' === rawSetupState || 'required' === rawSetupState ? rawSetupState : 'ready';
+    return {
+        connected: Boolean(metadata.sessionConnected),
+        displayName: 'string' == typeof metadata.sessionDisplayName ? metadata.sessionDisplayName : void 0,
+        setupState,
+        setupBlockingReason: 'string' == typeof metadata.setupBlockingReason ? metadata.setupBlockingReason : void 0
+    };
+}
+function buildSessionInitialValues(setup, existingValues = {}) {
+    if (!setup) return {};
+    return Object.fromEntries(setup.fields.map((field)=>[
+            field.key,
+            resolveSessionFieldValue(field, existingValues[field.key])
+        ]));
+}
+function hasSessionFieldValue(value) {
+    return null != value && '' !== value;
+}
+function resolveSessionFieldValue(field, existingValue) {
+    var _ref;
+    if (hasSessionFieldValue(existingValue)) return existingValue;
+    if ('select' === field.type) {
+        var _ref1, _field_defaultValue;
+        var _field_options_, _field_options;
+        return null != (_ref1 = null != (_field_defaultValue = field.defaultValue) ? _field_defaultValue : null == (_field_options = field.options) ? void 0 : null == (_field_options_ = _field_options[0]) ? void 0 : _field_options_.value) ? _ref1 : '';
+    }
+    return null != (_ref = null != existingValue ? existingValue : field.defaultValue) ? _ref : '';
+}
+exports.buildSessionInitialValues = __webpack_exports__.buildSessionInitialValues;
+exports.resolveSessionViewState = __webpack_exports__.resolveSessionViewState;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildSessionInitialValues",
+    "resolveSessionViewState"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/useServerStatus.js

@@ -0,0 +1,154 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useServerStatus: ()=>useServerStatus
+});
+const external_react_namespaceObject = require("react");
+const external_runtime_info_js_namespaceObject = require("./runtime-info.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function useServerStatus(playgroundSDK, defaultDeviceType, pollIntervalMs) {
+    const [serverOnline, setServerOnline] = (0, external_react_namespaceObject.useState)(false);
+    const [isUserOperating, setIsUserOperating] = (0, external_react_namespaceObject.useState)(false);
+    const [deviceType, setDeviceType] = (0, external_react_namespaceObject.useState)(defaultDeviceType);
+    const [runtimeInfo, setRuntimeInfo] = (0, external_react_namespaceObject.useState)(null);
+    const [executionUxHints, setExecutionUxHints] = (0, external_react_namespaceObject.useState)([]);
+    const runtimeInfoRef = (0, external_react_namespaceObject.useRef)(null);
+    const mountedRef = (0, external_react_namespaceObject.useRef)(true);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        mountedRef.current = true;
+        return ()=>{
+            mountedRef.current = false;
+        };
+    }, []);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        runtimeInfoRef.current = runtimeInfo;
+    }, [
+        runtimeInfo
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        playgroundSDK.onProgressUpdate((tip)=>{
+            setIsUserOperating(Boolean(tip));
+        });
+    }, [
+        playgroundSDK
+    ]);
+    const refreshServerState = (0, external_react_namespaceObject.useCallback)(()=>_async_to_generator(function*() {
+            try {
+                const online = yield playgroundSDK.checkStatus();
+                if (!mountedRef.current) return;
+                setServerOnline(online);
+                if (!online) {
+                    runtimeInfoRef.current = null;
+                    setRuntimeInfo(null);
+                    setExecutionUxHints([]);
+                    return;
+                }
+                try {
+                    const nextRuntimeInfo = yield playgroundSDK.getRuntimeInfo();
+                    if (!mountedRef.current) return;
+                    if (nextRuntimeInfo) {
+                        runtimeInfoRef.current = nextRuntimeInfo;
+                        setRuntimeInfo(nextRuntimeInfo);
+                        setDeviceType((0, external_runtime_info_js_namespaceObject.normalizeRuntimeDeviceType)(nextRuntimeInfo, defaultDeviceType));
+                        setExecutionUxHints((0, external_runtime_info_js_namespaceObject.filterValidExecutionUxHints)(nextRuntimeInfo));
+                        return;
+                    }
+                } catch (error) {
+                    console.warn('Failed to get runtime info:', error);
+                }
+                try {
+                    const interfaceInfo = yield playgroundSDK.getInterfaceInfo();
+                    if (!mountedRef.current || !(null == interfaceInfo ? void 0 : interfaceInfo.type)) return;
+                    const fallbackRuntimeInfo = (0, external_runtime_info_js_namespaceObject.buildFallbackRuntimeInfo)(runtimeInfoRef.current, interfaceInfo);
+                    runtimeInfoRef.current = fallbackRuntimeInfo;
+                    setRuntimeInfo(fallbackRuntimeInfo);
+                    setDeviceType((0, external_runtime_info_js_namespaceObject.normalizeRuntimeDeviceType)(fallbackRuntimeInfo, defaultDeviceType));
+                    setExecutionUxHints((0, external_runtime_info_js_namespaceObject.filterValidExecutionUxHints)(fallbackRuntimeInfo));
+                } catch (error) {
+                    console.warn('Failed to get interface info:', error);
+                }
+            } catch (error) {
+                if (!mountedRef.current) return;
+                console.error('Failed to check server status:', error);
+                setServerOnline(false);
+            }
+        })(), [
+        defaultDeviceType,
+        playgroundSDK
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        refreshServerState();
+        const interval = window.setInterval(()=>{
+            refreshServerState();
+        }, pollIntervalMs);
+        return ()=>{
+            window.clearInterval(interval);
+        };
+    }, [
+        pollIntervalMs,
+        refreshServerState
+    ]);
+    return {
+        serverOnline,
+        isUserOperating,
+        deviceType,
+        runtimeInfo,
+        executionUxHints,
+        refreshServerState
+    };
+}
+exports.useServerStatus = __webpack_exports__.useServerStatus;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useServerStatus"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/DeviceInteractionLayer.d.ts

@@ -0,0 +1,50 @@
+import React, { type CSSProperties } from 'react';
+export interface DeviceSize {
+    width: number;
+    height: number;
+}
+export interface DeviceInteractionLayerProps {
+    enabled: boolean;
+    deviceSize?: DeviceSize | null;
+    onTap?: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    onSwipe?: (start: {
+        x: number;
+        y: number;
+    }, end: {
+        x: number;
+        y: number;
+    }, duration: number) => void;
+    keyboardEnabled?: boolean;
+    onTextInput?: (text: string, point?: {
+        x: number;
+        y: number;
+    }) => void;
+    onKeyboardPress?: (keyName: string, point?: {
+        x: number;
+        y: number;
+    }) => void;
+    /**
+     * Tap classification thresholds. Pointer movement below this distance and
+     * total duration below this delay is reported as a Tap; anything else is a
+     * Swipe.
+     */
+    tapMaxDistance?: number;
+    tapMaxDurationMs?: number;
+    style?: CSSProperties;
+}
+export declare function keyNameForKeyboardEvent(event: Pick<React.KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>): string | null;
+export declare function inscribedContentRect(panel: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, deviceSize: DeviceSize): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function DeviceInteractionLayer({ enabled, deviceSize, onTap, onSwipe, keyboardEnabled, onTextInput, onKeyboardPress, tapMaxDistance, tapMaxDurationMs, style, }: DeviceInteractionLayerProps): React.JSX.Element | null;

package/dist/types/PlaygroundApp.d.ts

@@ -0,0 +1,14 @@
+import { type DeviceType, type PlaygroundBranding, type UniversalPlaygroundConfig } from '@godscene/visualizer';
+import './PlaygroundApp.less';
+export interface PlaygroundAppProps {
+    serverUrl: string;
+    appVersion: string;
+    title?: string;
+    defaultDeviceType?: DeviceType;
+    branding?: Partial<PlaygroundBranding>;
+    playgroundConfig?: Partial<UniversalPlaygroundConfig>;
+    offlineTitle?: string;
+    offlineStatusText?: string;
+    pollIntervalMs?: number;
+}
+export declare function PlaygroundApp({ serverUrl, appVersion, title, defaultDeviceType, branding, playgroundConfig, offlineTitle, offlineStatusText, pollIntervalMs, }: PlaygroundAppProps): import("react").JSX.Element;