@go-go-golems/os-scripting 0.1.0

package/runtime-host/RuntimeSurfaceSessionHost.js

@@ -0,0 +1,384 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { shallowEqual, useDispatch, useSelector, useStore } from 'react-redux';
+import { showToast } from '@go-go-golems/os-core';
+import { registerRuntimeSession, resolveCapabilityPolicy, selectRuntimeSurfaceState, selectProjectedRuntimeDomains, selectRuntimeSession, selectRuntimeSessionState, setRuntimeSessionStatus, } from '../features/runtimeSessions';
+import { selectFocusedWindowId, selectSessionCurrentNav, selectSessionNavDepth } from '@go-go-golems/os-core/desktop-core';
+import { markRuntimeSurfaceInjectionResults } from '../hypercard/artifacts/artifactsSlice';
+import { getPendingRuntimeSurfaces, hasRuntimeSurface, injectPendingRuntimeSurfacesWithReport, onRegistryChange } from '../plugin-runtime/runtimeSurfaceRegistry';
+import { DEFAULT_RUNTIME_SESSION_MANAGER } from '../runtime-session-manager';
+import { dispatchRuntimeAction } from './pluginIntentRouting';
+import { normalizeRuntimeSurfaceTypeId, renderRuntimeSurfaceTree, validateRuntimeSurfaceTree, } from '../runtime-packs';
+function getPluginConfig(bundle) {
+    if (bundle.plugin && bundle.plugin.bundleCode.length > 0) {
+        return bundle.plugin;
+    }
+    return null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function projectRuntimeState(domains, opts) {
+    const projectedDomains = { ...domains };
+    const inventory = isRecord(projectedDomains.inventory) ? projectedDomains.inventory : null;
+    const sales = isRecord(projectedDomains.sales) ? projectedDomains.sales : null;
+    if (inventory) {
+        projectedDomains.inventory = {
+            ...inventory,
+            items: asArray(inventory.items),
+            selectedSku: typeof opts.currentNavParam === 'string' ? opts.currentNavParam : undefined,
+        };
+    }
+    if (sales) {
+        projectedDomains.sales = {
+            ...sales,
+            log: asArray(sales.log),
+        };
+    }
+    return {
+        self: {
+            bundleId: opts.bundleId,
+            sessionId: opts.sessionId,
+            surfaceId: opts.surfaceId,
+            windowId: opts.windowId,
+        },
+        nav: {
+            current: opts.surfaceId,
+            param: opts.currentNavParam,
+            depth: opts.navDepth,
+            canBack: opts.navDepth > 1,
+        },
+        ui: {
+            focusedWindowId: opts.focusedWindowId,
+            runtimeStatus: opts.runtimeStatus,
+        },
+        filters: opts.sessionState,
+        draft: opts.surfaceState,
+        ...projectedDomains,
+    };
+}
+export function RuntimeSurfaceSessionHost({ windowId, sessionId, bundle, mode = 'interactive', }) {
+    const dispatch = useDispatch();
+    const store = useStore();
+    const pluginConfig = useMemo(() => getPluginConfig(bundle), [bundle]);
+    const currentNav = useSelector((state) => selectSessionCurrentNav(state, sessionId));
+    const navDepth = useSelector((state) => selectSessionNavDepth(state, sessionId));
+    const focusedWindowId = useSelector((state) => selectFocusedWindowId(state));
+    // Accept surfaces from the static bundle definition OR runtime-injected surfaces.
+    const currentSurfaceId = currentNav?.surface && (bundle.surfaces[currentNav.surface] || hasRuntimeSurface(currentNav.surface))
+        ? currentNav.surface
+        : bundle.homeSurface;
+    const runtimeSession = useSelector((state) => selectRuntimeSession(state, sessionId));
+    const sessionState = useSelector((state) => selectRuntimeSessionState(state, sessionId));
+    const surfaceState = useSelector((state) => selectRuntimeSurfaceState(state, sessionId, currentSurfaceId));
+    const projectedDomainAccess = useMemo(() => runtimeSession?.capabilities.domain ?? resolveCapabilityPolicy(pluginConfig?.capabilities).domain, [pluginConfig, runtimeSession?.capabilities.domain]);
+    const projectedDomains = useSelector((state) => selectProjectedRuntimeDomains(state, projectedDomainAccess), shallowEqual);
+    const loadedBundleRef = useRef(null);
+    const isPreview = mode === 'preview';
+    const localRuntimeReady = DEFAULT_RUNTIME_SESSION_MANAGER.getSession(sessionId) !== null;
+    const readRuntimeBundleMeta = useCallback((runtimeHandle) => {
+        if (loadedBundleRef.current) {
+            return loadedBundleRef.current;
+        }
+        if (!runtimeHandle) {
+            return null;
+        }
+        try {
+            const runtimeBundle = runtimeHandle.getBundleMeta();
+            loadedBundleRef.current = runtimeBundle;
+            return runtimeBundle;
+        }
+        catch {
+            return null;
+        }
+    }, []);
+    const resolveSurfacePackId = useCallback((surfaceId, runtimeHandle) => {
+        const runtimeSurface = getPendingRuntimeSurfaces().find((surface) => surface.surfaceId === surfaceId);
+        const runtimeBundle = readRuntimeBundleMeta(runtimeHandle);
+        return normalizeRuntimeSurfaceTypeId(runtimeSurface?.packId ?? runtimeBundle?.surfaceTypes?.[surfaceId]);
+    }, [readRuntimeBundleMeta]);
+    useEffect(() => {
+        if (!pluginConfig) {
+            return;
+        }
+        if (runtimeSession) {
+            return;
+        }
+        dispatch(registerRuntimeSession({
+            sessionId,
+            bundleId: bundle.id,
+            status: 'loading',
+            capabilities: pluginConfig.capabilities,
+        }));
+    }, [dispatch, pluginConfig, runtimeSession, sessionId, bundle.id]);
+    useEffect(() => {
+        if (!pluginConfig || !runtimeSession) {
+            return;
+        }
+        const runtimeStatus = runtimeSession.status;
+        const recoveringReadySession = runtimeStatus === 'ready' && !localRuntimeReady;
+        if (runtimeStatus !== 'loading' && !recoveringReadySession) {
+            return;
+        }
+        let cancelled = false;
+        const config = pluginConfig;
+        async function loadBundle() {
+            try {
+                if (recoveringReadySession) {
+                    console.warn('[RuntimeSurfaceSessionHost] Recovering ready runtime session into fresh service', {
+                        sessionId,
+                        bundleId: bundle.id,
+                        currentSurfaceId,
+                        serviceSessions: DEFAULT_RUNTIME_SESSION_MANAGER.listSessions().map((session) => session.sessionId),
+                    });
+                }
+                const runtimeHandle = await DEFAULT_RUNTIME_SESSION_MANAGER.ensureSession({
+                    bundleId: bundle.id,
+                    sessionId,
+                    packageIds: config.packageIds,
+                    bundleCode: config.bundleCode,
+                });
+                if (cancelled) {
+                    return;
+                }
+                const runtimeBundle = runtimeHandle.getBundleMeta();
+                loadedBundleRef.current = runtimeBundle;
+                if (runtimeStatus === 'loading') {
+                    dispatch(setRuntimeSessionStatus({ sessionId, status: 'ready' }));
+                }
+                // Inject any runtime surfaces that were registered before the session loaded
+                const report = injectPendingRuntimeSurfacesWithReport({
+                    defineRuntimeSurface(_runtimeSessionId, surfaceId, code, packId) {
+                        return runtimeHandle.defineSurface(surfaceId, code, packId);
+                    },
+                }, sessionId);
+                if (report.injected.length > 0 || report.failed.length > 0) {
+                    dispatch(markRuntimeSurfaceInjectionResults({
+                        injectedSurfaceIds: report.injected,
+                        failed: report.failed.map((item) => ({ surfaceId: item.surfaceId, error: item.error })),
+                    }));
+                }
+                if (report.injected.length > 0) {
+                    console.log(`[RuntimeSurfaceSessionHost] Injected ${report.injected.length} runtime surfaces into ${sessionId}:`, report.injected);
+                }
+                if (runtimeStatus === 'loading' &&
+                    runtimeBundle.initialSessionState &&
+                    typeof runtimeBundle.initialSessionState === 'object') {
+                    dispatchRuntimeAction({
+                        type: 'filters.patch',
+                        payload: runtimeBundle.initialSessionState,
+                    }, {
+                        dispatch: (action) => dispatch(action),
+                        getState: () => store.getState(),
+                        sessionId,
+                        surfaceId: currentSurfaceId,
+                        windowId,
+                    });
+                }
+                if (runtimeStatus === 'loading' &&
+                    runtimeBundle.initialSurfaceState &&
+                    typeof runtimeBundle.initialSurfaceState === 'object') {
+                    for (const [surfaceId, value] of Object.entries(runtimeBundle.initialSurfaceState)) {
+                        if (typeof value === 'object' && value !== null) {
+                            dispatchRuntimeAction({
+                                type: 'draft.patch',
+                                payload: value,
+                            }, {
+                                dispatch: (action) => dispatch(action),
+                                getState: () => store.getState(),
+                                sessionId,
+                                surfaceId,
+                                windowId,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (cancelled) {
+                    return;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                loadedBundleRef.current = null;
+                console.error('[RuntimeSurfaceSessionHost] Failed to load or recover runtime session', {
+                    sessionId,
+                    bundleId: bundle.id,
+                    recoveringReadySession,
+                    message,
+                });
+                dispatch(setRuntimeSessionStatus({ sessionId, status: 'error', error: message }));
+            }
+        }
+        void loadBundle();
+        return () => {
+            cancelled = true;
+        };
+    }, [bundle.id, currentSurfaceId, dispatch, localRuntimeReady, pluginConfig, runtimeSession, sessionId, store, windowId]);
+    // Subscribe to the runtime surface registry and inject new surfaces as they arrive.
+    useEffect(() => {
+        if (!pluginConfig || !runtimeSession || runtimeSession.status !== 'ready' || !localRuntimeReady) {
+            return;
+        }
+        const runtimeHandle = DEFAULT_RUNTIME_SESSION_MANAGER.getSession(sessionId);
+        if (!runtimeHandle) {
+            return;
+        }
+        return onRegistryChange(() => {
+            const report = injectPendingRuntimeSurfacesWithReport({
+                defineRuntimeSurface(_runtimeSessionId, surfaceId, code, packId) {
+                    return runtimeHandle.defineSurface(surfaceId, code, packId);
+                },
+            }, sessionId);
+            if (report.injected.length > 0 || report.failed.length > 0) {
+                dispatch(markRuntimeSurfaceInjectionResults({
+                    injectedSurfaceIds: report.injected,
+                    failed: report.failed.map((item) => ({ surfaceId: item.surfaceId, error: item.error })),
+                }));
+            }
+            if (report.injected.length > 0) {
+                console.log(`[RuntimeSurfaceSessionHost] Live-injected ${report.injected.length} runtime surfaces into ${sessionId}:`, report.injected);
+            }
+        });
+    }, [dispatch, localRuntimeReady, pluginConfig, runtimeSession, sessionId]);
+    useEffect(() => {
+        if (!pluginConfig || !runtimeSession || runtimeSession.status !== 'ready' || !localRuntimeReady) {
+            return;
+        }
+        const runtimeHandle = DEFAULT_RUNTIME_SESSION_MANAGER.getSession(sessionId);
+        if (!runtimeHandle) {
+            return;
+        }
+        return runtimeHandle.attachView(windowId);
+    }, [localRuntimeReady, pluginConfig, runtimeSession, sessionId, windowId]);
+    useEffect(() => {
+        return () => {
+            loadedBundleRef.current = null;
+        };
+    }, []);
+    const projectState = useCallback(() => projectRuntimeState(projectedDomains, {
+        bundleId: bundle.id,
+        sessionId,
+        surfaceId: currentSurfaceId,
+        windowId,
+        navDepth,
+        currentNavParam: currentNav?.param,
+        focusedWindowId,
+        runtimeStatus: runtimeSession?.status ?? 'missing',
+        sessionState,
+        surfaceState,
+    }), [
+        projectedDomains,
+        bundle.id,
+        sessionId,
+        currentSurfaceId,
+        windowId,
+        navDepth,
+        currentNav?.param,
+        focusedWindowId,
+        runtimeSession?.status,
+        sessionState,
+        surfaceState,
+    ]);
+    const renderOutcome = useMemo(() => {
+        if (!pluginConfig || !runtimeSession || runtimeSession.status !== 'ready' || !localRuntimeReady) {
+            return { tree: null, packId: null, error: null };
+        }
+        const projectedState = projectState();
+        try {
+            const runtimeHandle = DEFAULT_RUNTIME_SESSION_MANAGER.getSession(sessionId);
+            if (!runtimeHandle) {
+                return { tree: null, packId: null, error: null };
+            }
+            const packId = resolveSurfacePackId(currentSurfaceId, runtimeHandle);
+            return {
+                tree: (() => {
+                    const rawTree = runtimeHandle.renderSurface(currentSurfaceId, projectedState);
+                    return rawTree === null ? null : validateRuntimeSurfaceTree(packId, rawTree);
+                })(),
+                packId,
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                tree: null,
+                packId: null,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }, [currentSurfaceId, localRuntimeReady, pluginConfig, projectState, resolveSurfacePackId, runtimeSession, sessionId]);
+    const tree = renderOutcome.tree;
+    const packId = renderOutcome.packId;
+    const renderError = renderOutcome.error;
+    const lastRenderErrorRef = useRef(null);
+    useEffect(() => {
+        if (!renderError) {
+            lastRenderErrorRef.current = null;
+            return;
+        }
+        if (lastRenderErrorRef.current === renderError) {
+            return;
+        }
+        lastRenderErrorRef.current = renderError;
+        dispatch(showToast(renderError));
+    }, [dispatch, renderError]);
+    const emitRuntimeEvent = useCallback((handler, args) => {
+        if (!pluginConfig || !runtimeSession || runtimeSession.status !== 'ready' || !localRuntimeReady) {
+            return;
+        }
+        let actions;
+        try {
+            const projectedState = projectState();
+            const runtimeHandle = DEFAULT_RUNTIME_SESSION_MANAGER.getSession(sessionId);
+            if (!runtimeHandle) {
+                return;
+            }
+            actions = runtimeHandle.eventSurface(currentSurfaceId, handler, args, projectedState) ?? [];
+        }
+        catch (error) {
+            dispatch(showToast(error instanceof Error ? error.message : String(error)));
+            return;
+        }
+        actions.forEach((runtimeAction) => {
+            dispatchRuntimeAction(runtimeAction, {
+                dispatch: (action) => dispatch(action),
+                getState: () => store.getState(),
+                sessionId,
+                surfaceId: currentSurfaceId,
+                windowId,
+            });
+        });
+    }, [
+        currentSurfaceId,
+        dispatch,
+        localRuntimeReady,
+        pluginConfig,
+        projectState,
+        runtimeSession,
+        sessionId,
+        windowId,
+        store,
+    ]);
+    if (!pluginConfig) {
+        return _jsx("div", { style: { padding: 12, color: '#9f1d1d' }, children: "Plugin bundle configuration is required for this host." });
+    }
+    if (!runtimeSession || runtimeSession.status === 'loading' || (runtimeSession.status === 'ready' && !localRuntimeReady)) {
+        return _jsx("div", { style: { padding: 12 }, children: isPreview ? 'Loading plugin preview…' : 'Loading plugin runtime…' });
+    }
+    if (runtimeSession.status === 'error') {
+        return _jsxs("div", { style: { padding: 12, color: '#9f1d1d' }, children: ["Runtime error: ", runtimeSession.error] });
+    }
+    if (!tree) {
+        if (renderError) {
+            return _jsxs("div", { style: { padding: 12, color: '#9f1d1d' }, children: ["Runtime render error: ", renderError] });
+        }
+        return _jsxs("div", { style: { padding: 12 }, children: ["No plugin output for surface: ", currentSurfaceId] });
+    }
+    if (!packId) {
+        return _jsxs("div", { style: { padding: 12, color: '#9f1d1d' }, children: ["Runtime render error: Missing runtime surface type id for ", currentSurfaceId] });
+    }
+    return _jsx(_Fragment, { children: renderRuntimeSurfaceTree(packId, tree, emitRuntimeEvent) });
+}

package/runtime-host/fixtures/CardSessionHost.chat.vm.js

@@ -0,0 +1,61 @@
+defineRuntimeBundle(({ ui }) => {
+  function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  }
+
+  return {
+    id: 'chat-demo',
+    title: 'Chat Demo',
+    packageIds: ["ui"],
+    initialSurfaceState: {
+      chat: {
+        draft: '',
+        messages: [
+          'Hello! How can I help you today?',
+          'Try asking about report export or low stock alerts.',
+        ],
+      },
+    },
+    surfaces: {
+      chat: {
+        packId: 'ui.card.v1',
+        render({ state }) {
+          const draftState = asRecord(state?.draft);
+          const messages = Array.isArray(draftState.messages) ? draftState.messages : [];
+          const draft = String(draftState.draft || '');
+
+          return ui.panel([
+            ui.text('Assistant'),
+            ui.column(messages.map((message) => ui.text('• ' + String(message)))),
+            ui.input(draft, { onChange: { handler: 'changeDraft' } }),
+            ui.row([
+              ui.button('Send', { onClick: { handler: 'send' } }),
+              ui.button('Clear', { onClick: { handler: 'clear' } }),
+            ]),
+          ]);
+        },
+        handlers: {
+          changeDraft({ dispatch }, args) {
+            dispatch({ type: 'draft.set', payload: { path: 'draft', value: asRecord(args).value } });
+          },
+          send({ state, dispatch }) {
+            const draftState = asRecord(state?.draft);
+            const draft = String(draftState.draft || '').trim();
+            if (!draft) return;
+            const messages = Array.isArray(draftState.messages) ? draftState.messages : [];
+            dispatch({
+              type: 'draft.patch',
+              payload: {
+                draft: '',
+                messages: messages.concat(['You: ' + draft, 'Assistant: Thanks, received.']).slice(-10),
+              },
+            });
+          },
+          clear({ dispatch }) {
+            dispatch({ type: 'draft.patch', payload: { draft: '', messages: [] } });
+          },
+        },
+      },
+    },
+  };
+});

package/runtime-host/fixtures/CardSessionHost.list.vm.js

@@ -0,0 +1,29 @@
+defineRuntimeBundle(({ ui }) => {
+  const ITEMS = [
+    ['W-1001', 'Widget A', 'Widgets', '$12.00', '45'],
+    ['G-2001', 'Gadget B', 'Gadgets', '$25.50', '38'],
+    ['P-3001', 'Doohickey C', 'Parts', '$8.75', '73'],
+    ['W-1002', 'Widget D', 'Widgets', '$15.00', '12'],
+    ['G-2002', 'Gizmo E', 'Gadgets', '$42.00', '5'],
+    ['P-3002', 'Thingamajig F', 'Parts', '$3.25', '120'],
+  ];
+
+  return {
+    id: 'list-demo',
+    title: 'List Demo',
+    packageIds: ["ui"],
+    surfaces: {
+      browse: {
+        packId: 'ui.card.v1',
+        render() {
+          return ui.panel([
+            ui.text('Browse Items'),
+            ui.table(ITEMS, { headers: ['SKU', 'Name', 'Category', 'Price', 'Qty'] }),
+            ui.text('Use Desktop Shell stories for richer interactions.'),
+          ]);
+        },
+        handlers: {},
+      },
+    },
+  };
+});

package/runtime-host/fixtures/CardSessionHost.nav.vm.js

@@ -0,0 +1,101 @@
+defineRuntimeBundle(({ ui }) => {
+  function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  }
+
+  function navParam(state) {
+    const param = asRecord(asRecord(state).nav).param;
+    return typeof param === 'string' ? param : '';
+  }
+
+  function item(id) {
+    const records = {
+      'widget-a': {
+        name: 'Widget A',
+        sku: 'W-1001',
+        category: 'Widgets',
+        price: '$12.00',
+        stock: '45 units',
+        supplier: 'Acme Corp',
+        lastRestock: 'Feb 10, 2026',
+      },
+      'widget-b': {
+        name: 'Widget B',
+        sku: 'W-1002',
+        category: 'Widgets',
+        price: '$15.00',
+        stock: '12 units',
+        supplier: 'Acme Corp',
+        lastRestock: 'Feb 12, 2026',
+      },
+      'widget-c': {
+        name: 'Widget C',
+        sku: 'W-1003',
+        category: 'Widgets',
+        price: '$19.00',
+        stock: '9 units',
+        supplier: 'Globex',
+        lastRestock: 'Feb 14, 2026',
+      },
+    };
+    return records[id] || records['widget-a'];
+  }
+
+  return {
+    id: 'nav-demo',
+    title: 'Nav Demo',
+    packageIds: ["ui"],
+    surfaces: {
+      list: {
+        packId: 'ui.card.v1',
+        render() {
+          return ui.panel([
+            ui.text('Items'),
+            ui.button('🔍 View Widget A', { onClick: { handler: 'go', args: { surfaceId: 'detail', param: 'widget-a' } } }),
+            ui.button('🔍 View Widget B', { onClick: { handler: 'go', args: { surfaceId: 'detail', param: 'widget-b' } } }),
+            ui.button('🔍 View Widget C', { onClick: { handler: 'go', args: { surfaceId: 'detail', param: 'widget-c' } } }),
+          ]);
+        },
+        handlers: {
+          go({ dispatch }, args) {
+            const payload = asRecord(args);
+            dispatch({ type: 'nav.go', payload: { surfaceId: String(payload.surfaceId || 'list'), param: String(payload.param || '') } });
+          },
+        },
+      },
+      detail: {
+        packId: 'ui.card.v1',
+        render({ state }) {
+          const current = item(navParam(state));
+          return ui.panel([
+            ui.text('Item Detail'),
+            ui.table(
+              [
+                ['Name', current.name],
+                ['SKU', current.sku],
+                ['Category', current.category],
+                ['Price', current.price],
+                ['Stock', current.stock],
+                ['Supplier', current.supplier],
+                ['Last Restock', current.lastRestock],
+              ],
+              { headers: ['Field', 'Value'] }
+            ),
+            ui.row([
+              ui.button('← Back', { onClick: { handler: 'back' } }),
+              ui.button('🛒 Reorder', { onClick: { handler: 'notify', args: { message: 'Reorder placed' } } }),
+            ]),
+          ]);
+        },
+        handlers: {
+          back({ dispatch }) {
+            dispatch({ type: 'nav.back' });
+          },
+          notify({ dispatch }, args) {
+            dispatch({ type: 'notify.show', payload: { message: String(asRecord(args).message || '') } });
+          },
+        },
+      },
+    },
+  };
+});

package/runtime-host/fixtures/CardSessionHost.report.vm.js

@@ -0,0 +1,34 @@
+defineRuntimeBundle(({ ui }) => {
+  return {
+    id: 'report-demo',
+    title: 'Report Demo',
+    packageIds: ["ui"],
+    surfaces: {
+      report: {
+        packId: 'ui.card.v1',
+        render() {
+          return ui.panel([
+            ui.text('Monthly Report'),
+            ui.table(
+              [
+                ['Gross Revenue', '$12,450.00'],
+                ['Net Revenue', '$10,830.00'],
+                ['Refunds', '$620.00'],
+                ['Items in Stock', '156'],
+                ['Low Stock Alerts', '3'],
+                ['Out of Stock', '0'],
+              ],
+              { headers: ['Metric', 'Value'] }
+            ),
+            ui.button('📄 Export CSV', { onClick: { handler: 'notify' } }),
+          ]);
+        },
+        handlers: {
+          notify({ dispatch }) {
+            dispatch({ type: 'notify.show', payload: { message: 'Export not available in demo' } });
+          },
+        },
+      },
+    },
+  };
+});

package/runtime-host/pluginIntentRouting.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeAction } from '../plugin-runtime/contracts';
+interface DispatchLike {
+    (action: unknown): unknown;
+}
+interface ActionDispatchContext {
+    dispatch: DispatchLike;
+    getState?: () => unknown;
+    sessionId: string;
+    surfaceId: string;
+    windowId: string;
+}
+export declare function dispatchRuntimeAction(action: RuntimeAction, context: ActionDispatchContext): void;
+export {};