@midscene/playground-app 1.7.3 → 1.7.4

package/dist/es/SessionSetupPanel.mjs

@@ -1,6 +1,8 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { Alert, Button, Form, Input, InputNumber, Radio, Select, Space, Typography } from "antd";
-const { Paragraph, Title } = Typography;
+import { Alert, Form, Input, InputNumber, Radio, Select } from "antd";
+import dropdown_chevron from "./icons/dropdown-chevron.mjs";
+import midscene_logo from "./icons/midscene-logo.mjs";
+import "./SessionSetupPanel.css";
 function getPlatformSelectorFieldKey(setup) {
     var _setup_platformSelector;
     return null == setup ? void 0 : null == (_setup_platformSelector = setup.platformSelector) ? void 0 : _setup_platformSelector.fieldKey;
@@ -18,6 +20,12 @@ function getPlatformSelectorOptions(field, setup) {
         }));
     return registryOptions.length > 0 ? registryOptions : field.options;
 }
+function DropdownSuffix() {
+    return /*#__PURE__*/ jsx(dropdown_chevron, {
+        "aria-hidden": "true",
+        className: "session-setup-select-icon"
+    });
+}
 function renderSessionField(field, sessionSetup) {
     if ('number' === field.type) return /*#__PURE__*/ jsx(InputNumber, {
         style: {
@@ -47,9 +55,11 @@ function renderSessionField(field, sessionSetup) {
                     ]
                 }, String(option.value)))
         });
+        var _ref;
         return /*#__PURE__*/ jsx(Select, {
             placeholder: field.placeholder,
-            options: (platformOptions || field.options || []).map((option)=>({
+            suffixIcon: /*#__PURE__*/ jsx(DropdownSuffix, {}),
+            options: (null != (_ref = null != platformOptions ? platformOptions : field.options) ? _ref : []).map((option)=>({
                     label: option.label,
                     value: option.value,
                     description: option.description
@@ -77,63 +87,74 @@ function renderSessionField(field, sessionSetup) {
         placeholder: field.placeholder
     });
 }
-function SessionSetupPanel({ form, sessionSetup, sessionSetupError, sessionViewState, sessionLoading, sessionMutating, onCreateSession, onRefreshTargets }) {
+const DEFAULT_TITLE = 'Create Agent';
+const DEFAULT_DESCRIPTION = 'Create a platform session before running actions.';
+function SessionSetupPanel({ form, sessionSetup, sessionSetupError, sessionViewState, sessionLoading, sessionMutating, onCreateSession }) {
+    const submitDisabled = sessionMutating || sessionLoading || 'blocked' === sessionViewState.setupState;
+    var _sessionSetup_primaryActionLabel;
+    const primaryLabel = null != (_sessionSetup_primaryActionLabel = null == sessionSetup ? void 0 : sessionSetup.primaryActionLabel) ? _sessionSetup_primaryActionLabel : DEFAULT_TITLE;
+    var _sessionSetup_title;
+    const title = null != (_sessionSetup_title = null == sessionSetup ? void 0 : sessionSetup.title) ? _sessionSetup_title : DEFAULT_TITLE;
+    var _sessionSetup_description;
+    const description = null != (_sessionSetup_description = null == sessionSetup ? void 0 : sessionSetup.description) ? _sessionSetup_description : DEFAULT_DESCRIPTION;
+    var _sessionSetup_fields;
     return /*#__PURE__*/ jsx("div", {
         className: "session-setup-panel",
         children: /*#__PURE__*/ jsxs("div", {
             className: "session-setup-card",
             children: [
-                /*#__PURE__*/ jsx(Title, {
-                    level: 4,
-                    children: (null == sessionSetup ? void 0 : sessionSetup.title) || 'Create Agent'
+                /*#__PURE__*/ jsx(midscene_logo, {
+                    "aria-hidden": "true",
+                    className: "session-setup-logo"
+                }),
+                /*#__PURE__*/ jsx("h1", {
+                    className: "session-setup-title",
+                    children: title
                 }),
-                /*#__PURE__*/ jsx(Paragraph, {
-                    type: "secondary",
-                    children: (null == sessionSetup ? void 0 : sessionSetup.description) || 'Create a platform session before running actions.'
+                /*#__PURE__*/ jsx("p", {
+                    className: "session-setup-description",
+                    children: description
                 }),
                 'blocked' === sessionViewState.setupState && sessionViewState.setupBlockingReason && /*#__PURE__*/ jsx(Alert, {
                     type: "error",
                     showIcon: true,
                     message: "Setup blocked",
-                    description: sessionViewState.setupBlockingReason
+                    description: sessionViewState.setupBlockingReason,
+                    className: "session-setup-alert"
                 }),
                 sessionSetupError ? /*#__PURE__*/ jsx(Alert, {
                     type: "error",
                     showIcon: true,
                     message: "Failed to load setup",
-                    description: sessionSetupError
+                    description: sessionSetupError,
+                    className: "session-setup-alert"
                 }) : null,
-                /*#__PURE__*/ jsx(Form, {
+                /*#__PURE__*/ jsxs(Form, {
                     form: form,
                     layout: "vertical",
                     className: "session-setup-form",
-                    children: ((null == sessionSetup ? void 0 : sessionSetup.fields) || []).map((field)=>/*#__PURE__*/ jsx(Form.Item, {
-                            label: field.label,
-                            name: field.key,
-                            tooltip: field.description,
-                            rules: field.required ? [
-                                {
-                                    required: true,
-                                    message: `${field.label} is required`
-                                }
-                            ] : void 0,
-                            children: renderSessionField(field, sessionSetup)
-                        }, field.key))
-                }),
-                /*#__PURE__*/ jsxs(Space, {
-                    size: 12,
+                    onFinish: ()=>{
+                        if (submitDisabled) return;
+                        onCreateSession();
+                    },
                     children: [
-                        /*#__PURE__*/ jsx(Button, {
-                            type: "primary",
-                            loading: sessionMutating,
-                            disabled: sessionLoading || 'blocked' === sessionViewState.setupState,
-                            onClick: onCreateSession,
-                            children: (null == sessionSetup ? void 0 : sessionSetup.primaryActionLabel) || 'Create Agent'
-                        }),
-                        /*#__PURE__*/ jsx(Button, {
-                            onClick: onRefreshTargets,
-                            loading: sessionLoading,
-                            children: "Refresh targets"
+                        (null != (_sessionSetup_fields = null == sessionSetup ? void 0 : sessionSetup.fields) ? _sessionSetup_fields : []).map((field)=>/*#__PURE__*/ jsx(Form.Item, {
+                                label: field.label,
+                                name: field.key,
+                                tooltip: field.description,
+                                rules: field.required ? [
+                                    {
+                                        required: true,
+                                        message: `${field.label} is required`
+                                    }
+                                ] : void 0,
+                                children: renderSessionField(field, sessionSetup)
+                            }, field.key)),
+                        /*#__PURE__*/ jsx("button", {
+                            type: "submit",
+                            className: "session-setup-submit",
+                            disabled: submitDisabled,
+                            children: sessionMutating ? 'Creating...' : primaryLabel
                         })
                     ]
                 })

package/dist/es/controller/ai-config.mjs

@@ -0,0 +1,37 @@
+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 hasPlaygroundAiConfig(config) {
+    return Object.keys(config).length > 0;
+}
+function applyPlaygroundAiConfig(playgroundSDK, config) {
+    return _async_to_generator(function*() {
+        if (!hasPlaygroundAiConfig(config)) return false;
+        yield playgroundSDK.overrideConfig(config);
+        return true;
+    })();
+}
+export { applyPlaygroundAiConfig, hasPlaygroundAiConfig };

package/dist/es/controller/auto-create.mjs

@@ -0,0 +1,19 @@
+function serializeAutoCreateInput(autoCreateInput) {
+    if (!autoCreateInput) return null;
+    return JSON.stringify(autoCreateInput);
+}
+function resolveAutoCreateDecision({ autoCreateInput, lastAttemptedSignature, blockedSignature }) {
+    const signature = serializeAutoCreateInput(autoCreateInput);
+    if (!signature) return {
+        signature: null,
+        shouldCreate: false
+    };
+    return {
+        signature,
+        shouldCreate: signature !== lastAttemptedSignature && signature !== blockedSignature
+    };
+}
+function shouldResetAutoCreateBlock(options) {
+    return !(null == options ? void 0 : options.silent);
+}
+export { resolveAutoCreateDecision, serializeAutoCreateInput, shouldResetAutoCreateBlock };

package/dist/es/controller/selectors.mjs

@@ -0,0 +1,66 @@
+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 selectors_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 selectors_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+function buildConversationConfig(state, playgroundConfig) {
+    return _object_spread({
+        showContextPreview: false,
+        layout: 'vertical',
+        showVersionInfo: true,
+        enableScrollToBottom: true,
+        serverMode: true,
+        showEnvConfigReminder: true,
+        deviceType: state.deviceType,
+        executionUx: {
+            hints: state.executionUxHints,
+            countdownSeconds: state.countdownSeconds
+        }
+    }, playgroundConfig);
+}
+function buildConversationBranding(runtimeInfo, title, appVersion, deviceType, branding) {
+    var _runtimeInfo_title, _runtimeInfo_platformId, _ref, _ref1;
+    return _object_spread_props(_object_spread({}, branding), {
+        title: null != (_runtimeInfo_title = null == runtimeInfo ? void 0 : runtimeInfo.title) ? _runtimeInfo_title : title,
+        version: appVersion,
+        targetName: null != (_ref1 = null != (_ref = null != (_runtimeInfo_platformId = null == runtimeInfo ? void 0 : runtimeInfo.platformId) ? _runtimeInfo_platformId : null == branding ? void 0 : branding.targetName) ? _ref : deviceType) ? _ref1 : 'screen'
+    });
+}
+export { buildConversationBranding, buildConversationConfig };

package/dist/es/controller/usePlaygroundController.mjs

@@ -0,0 +1,356 @@
+import { PlaygroundSDK } from "@midscene/playground";
+import { useEnvConfig } from "@midscene/visualizer";
+import { Form, message } from "antd";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { resolveAutoCreateSessionInput } from "../session-setup.mjs";
+import { buildSessionInitialValues, resolveSessionViewState } from "../session-state.mjs";
+import { useServerStatus } from "../useServerStatus.mjs";
+import { applyPlaygroundAiConfig, hasPlaygroundAiConfig } from "./ai-config.mjs";
+import { resolveAutoCreateDecision, serializeAutoCreateInput, shouldResetAutoCreateBlock } from "./auto-create.mjs";
+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 _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 usePlaygroundController_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 usePlaygroundController_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+function getPlatformSelectorFieldKey(setup) {
+    var _setup_platformSelector;
+    return null == setup ? void 0 : null == (_setup_platformSelector = setup.platformSelector) ? void 0 : _setup_platformSelector.fieldKey;
+}
+function usePlaygroundController({ serverUrl, defaultDeviceType = 'web', pollIntervalMs = 5000, countdownSeconds = 3 }) {
+    const [form] = Form.useForm();
+    var _Form_useWatch;
+    const formValues = null != (_Form_useWatch = Form.useWatch([], form)) ? _Form_useWatch : {};
+    const [countdown, setCountdown] = useState(null);
+    const [sessionSetup, setSessionSetup] = useState(null);
+    const [sessionSetupError, setSessionSetupError] = useState(null);
+    const [sessionLoading, setSessionLoading] = useState(false);
+    const [sessionMutating, setSessionMutating] = useState(false);
+    const aiConfig = useEnvConfig((state)=>state.config);
+    const platformSelectorFieldKey = getPlatformSelectorFieldKey(sessionSetup);
+    const selectedPlatformId = 'string' == typeof platformSelectorFieldKey ? formValues[platformSelectorFieldKey] : void 0;
+    const playgroundSDK = useMemo(()=>new PlaygroundSDK({
+            type: 'remote-execution',
+            serverUrl
+        }), [
+        serverUrl
+    ]);
+    const { serverOnline, isUserOperating, deviceType, runtimeInfo, executionUxHints, refreshServerState } = useServerStatus(playgroundSDK, defaultDeviceType, pollIntervalMs);
+    const sessionViewState = useMemo(()=>resolveSessionViewState(runtimeInfo), [
+        runtimeInfo
+    ]);
+    const applyAiConfig = useCallback(()=>_async_to_generator(function*() {
+            if (!hasPlaygroundAiConfig(aiConfig)) return true;
+            try {
+                yield applyPlaygroundAiConfig(playgroundSDK, aiConfig);
+                return true;
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to apply AI configuration';
+                message.error(errorMessage);
+                return false;
+            }
+        })(), [
+        aiConfig,
+        playgroundSDK
+    ]);
+    const countdownTimerRef = useRef(null);
+    const countdownResolveRef = useRef(null);
+    const mountedRef = useRef(true);
+    const lastSetupPlatformIdRef = useRef(void 0);
+    const autoCreateSignatureRef = useRef(null);
+    const autoCreateBlockedSignatureRef = useRef(null);
+    const finishCountdown = useCallback(()=>{
+        if (null !== countdownTimerRef.current) {
+            window.clearInterval(countdownTimerRef.current);
+            countdownTimerRef.current = null;
+        }
+        const resolve = countdownResolveRef.current;
+        countdownResolveRef.current = null;
+        if (mountedRef.current) setCountdown(null);
+        null == resolve || resolve();
+    }, []);
+    const showCountdownModal = useCallback(()=>_async_to_generator(function*() {
+            if (countdownSeconds <= 0) return;
+            finishCountdown();
+            return new Promise((resolve)=>{
+                countdownResolveRef.current = resolve;
+                let count = countdownSeconds;
+                if (mountedRef.current) setCountdown(count);
+                countdownTimerRef.current = window.setInterval(()=>{
+                    count -= 1;
+                    if (count > 0) {
+                        if (mountedRef.current) setCountdown(count);
+                        return;
+                    }
+                    if (0 === count) {
+                        if (mountedRef.current) setCountdown('GO!');
+                        return;
+                    }
+                    finishCountdown();
+                }, 1000);
+            });
+        })(), [
+        countdownSeconds,
+        finishCountdown
+    ]);
+    useEffect(()=>{
+        mountedRef.current = true;
+        return ()=>{
+            mountedRef.current = false;
+            finishCountdown();
+        };
+    }, [
+        finishCountdown
+    ]);
+    useEffect(()=>{
+        if (!executionUxHints.includes('countdown-before-run')) return void playgroundSDK.setBeforeActionHook(void 0);
+        playgroundSDK.setBeforeActionHook(()=>_async_to_generator(function*() {
+                yield showCountdownModal();
+            })());
+        return ()=>{
+            playgroundSDK.setBeforeActionHook(void 0);
+        };
+    }, [
+        executionUxHints,
+        playgroundSDK,
+        showCountdownModal
+    ]);
+    const refreshSessionSetup = useCallback((input)=>_async_to_generator(function*() {
+            const currentValues = _object_spread({}, form.getFieldsValue(true), input || {});
+            setSessionLoading(true);
+            try {
+                const setup = yield playgroundSDK.getSessionSetup(input);
+                setSessionSetup(setup);
+                setSessionSetupError(null);
+                const currentPlatformSelectorFieldKey = getPlatformSelectorFieldKey(setup);
+                lastSetupPlatformIdRef.current = currentPlatformSelectorFieldKey && 'string' == typeof currentValues[currentPlatformSelectorFieldKey] ? currentValues[currentPlatformSelectorFieldKey] : void 0;
+                form.setFieldsValue(buildSessionInitialValues(setup, currentValues));
+            } catch (error) {
+                console.error('Failed to load session setup:', error);
+                setSessionSetupError(error instanceof Error ? error.message : 'Failed to load session setup');
+            } finally{
+                setSessionLoading(false);
+            }
+        })(), [
+        form,
+        playgroundSDK
+    ]);
+    const createSession = useCallback((input, options)=>_async_to_generator(function*() {
+            try {
+                if (!(yield applyAiConfig())) return false;
+                const values = null != input ? input : yield form.validateFields();
+                setSessionMutating(true);
+                yield playgroundSDK.createSession(values);
+                if (shouldResetAutoCreateBlock(options)) autoCreateBlockedSignatureRef.current = null;
+                if (!(null == options ? void 0 : options.silent)) message.success('Agent created');
+                yield refreshServerState();
+                return true;
+            } catch (error) {
+                if (error.errorFields) return false;
+                const errorMessage = error instanceof Error ? error.message : 'Failed to create Agent';
+                message.error(errorMessage);
+                return false;
+            } finally{
+                setSessionMutating(false);
+            }
+        })(), [
+        applyAiConfig,
+        form,
+        playgroundSDK,
+        refreshServerState
+    ]);
+    const destroySession = useCallback(()=>_async_to_generator(function*() {
+            try {
+                autoCreateBlockedSignatureRef.current = serializeAutoCreateInput(resolveAutoCreateSessionInput(sessionSetup, form.getFieldsValue(true)));
+                setSessionMutating(true);
+                yield playgroundSDK.destroySession();
+                message.success('Session disconnected');
+                yield refreshServerState();
+                yield refreshSessionSetup();
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to disconnect session';
+                message.error(errorMessage);
+            } finally{
+                setSessionMutating(false);
+            }
+        })(), [
+        form,
+        playgroundSDK,
+        refreshServerState,
+        refreshSessionSetup,
+        sessionSetup
+    ]);
+    useEffect(()=>{
+        if (!serverOnline) return;
+        applyAiConfig();
+    }, [
+        applyAiConfig,
+        serverOnline
+    ]);
+    useEffect(()=>{
+        if (!serverOnline || sessionViewState.connected) return;
+        let disposed = false;
+        let refreshing = false;
+        const refreshTargets = ()=>_async_to_generator(function*() {
+                if (disposed || refreshing) return;
+                refreshing = true;
+                try {
+                    yield refreshSessionSetup(form.getFieldsValue(true));
+                } finally{
+                    refreshing = false;
+                }
+            })();
+        refreshTargets();
+        const intervalId = window.setInterval(()=>{
+            refreshTargets();
+        }, pollIntervalMs);
+        return ()=>{
+            disposed = true;
+            window.clearInterval(intervalId);
+        };
+    }, [
+        form,
+        pollIntervalMs,
+        refreshSessionSetup,
+        serverOnline,
+        sessionViewState.connected
+    ]);
+    useEffect(()=>{
+        if (!serverOnline || sessionViewState.connected || !selectedPlatformId) return;
+        const currentPlatformSelectorFieldKey = getPlatformSelectorFieldKey(sessionSetup);
+        if (!currentPlatformSelectorFieldKey) return;
+        if (lastSetupPlatformIdRef.current === selectedPlatformId) return;
+        refreshSessionSetup(_object_spread_props(_object_spread({}, form.getFieldsValue(true)), {
+            [currentPlatformSelectorFieldKey]: selectedPlatformId
+        }));
+    }, [
+        form,
+        refreshSessionSetup,
+        selectedPlatformId,
+        serverOnline,
+        sessionSetup,
+        sessionViewState.connected
+    ]);
+    useEffect(()=>{
+        if (sessionViewState.connected) {
+            autoCreateSignatureRef.current = null;
+            return;
+        }
+        if (!serverOnline || sessionLoading || sessionMutating || sessionSetupError) return;
+        const autoCreateInput = resolveAutoCreateSessionInput(sessionSetup, form.getFieldsValue(true));
+        const { signature, shouldCreate } = resolveAutoCreateDecision({
+            autoCreateInput,
+            lastAttemptedSignature: autoCreateSignatureRef.current,
+            blockedSignature: autoCreateBlockedSignatureRef.current
+        });
+        if (!shouldCreate || !signature) {
+            if (!signature) autoCreateSignatureRef.current = null;
+            return;
+        }
+        autoCreateSignatureRef.current = signature;
+        (()=>_async_to_generator(function*() {
+                const created = yield createSession(null != autoCreateInput ? autoCreateInput : void 0, {
+                    silent: true
+                });
+                if (!created) autoCreateSignatureRef.current = null;
+            })())();
+    }, [
+        createSession,
+        form,
+        serverOnline,
+        sessionLoading,
+        sessionMutating,
+        sessionSetup,
+        sessionSetupError,
+        sessionViewState.connected
+    ]);
+    return {
+        state: {
+            playgroundSDK,
+            form,
+            formValues,
+            serverOnline,
+            isUserOperating,
+            deviceType,
+            runtimeInfo,
+            executionUxHints,
+            sessionViewState,
+            sessionSetup,
+            sessionSetupError,
+            sessionLoading,
+            sessionMutating,
+            countdown,
+            countdownSeconds
+        },
+        actions: {
+            refreshServerState,
+            refreshSessionSetup,
+            createSession,
+            destroySession,
+            finishCountdown
+        }
+    };
+}
+export { usePlaygroundController };