@go-go-golems/os-scripting 0.1.0

package/README.md

@@ -0,0 +1,147 @@
+# @go-go-golems/os-scripting
+
+QuickJS-backed scripting runtime for go-go-os React hosts.
+
+Use this package when a standalone app needs to load JavaScript runtime bundles as data, execute them inside a sandbox, render runtime surfaces, and route surface events back into host state.
+
+## Install
+
+```bash
+npm install @go-go-golems/os-scripting @go-go-golems/os-ui-cards @go-go-golems/os-shell @go-go-golems/os-core
+npm install react react-dom react-redux @reduxjs/toolkit
+```
+
+`react`, `react-dom`, `react-redux`, and `@reduxjs/toolkit` are peer dependencies.
+
+## Main exports
+
+```ts
+import {
+  createAppStore,
+  RuntimeSurfaceSessionHost,
+  registerRuntimePackage,
+  registerRuntimeSurfaceType,
+} from '@go-go-golems/os-scripting';
+```
+
+Consumer-facing APIs:
+
+- `createAppStore(domainReducers, options)` — creates a Redux store with runtime session reducers and middleware.
+- `RuntimeSurfaceSessionHost` — React bridge that loads a runtime bundle and renders the current surface.
+- `registerRuntimePackage(definition)` — registers a VM-side package prelude such as `ui` or `kanban`.
+- `registerRuntimeSurfaceType(definition)` — registers a host-side validator/renderer such as `ui.card.v1`.
+
+Advanced APIs include the QuickJS runtime service, runtime session manager, attached REPL drivers, debug windows, and dynamic runtime surface registry.
+
+## Minimal runtime registration
+
+```ts
+import { registerRuntimePackage, registerRuntimeSurfaceType } from '@go-go-golems/os-scripting';
+import { UI_RUNTIME_PACKAGE, UI_CARD_V1_RUNTIME_SURFACE_TYPE } from '@go-go-golems/os-ui-cards';
+
+let registered = false;
+
+export function registerRuntimePackages() {
+  if (registered) return;
+  registered = true;
+
+  registerRuntimePackage(UI_RUNTIME_PACKAGE);
+  registerRuntimeSurfaceType(UI_CARD_V1_RUNTIME_SURFACE_TYPE);
+}
+```
+
+Call this once at app startup before rendering runtime surfaces.
+
+## Minimal store
+
+```tsx
+import { Provider } from 'react-redux';
+import { createAppStore } from '@go-go-golems/os-scripting';
+
+const { store } = createAppStore({});
+
+export function AppProviders({ children }: { children: React.ReactNode }) {
+  return <Provider store={store}>{children}</Provider>;
+}
+```
+
+Use `createAppStore` when rendering VM surfaces. It includes `runtimeSessions`, runtime lifecycle middleware, and artifact projection middleware. For shell-only apps that never render VM surfaces, `createLauncherStore` from `@go-go-golems/os-shell` is lighter.
+
+## Minimal surface host
+
+```tsx
+import { RuntimeSurfaceSessionHost } from '@go-go-golems/os-scripting';
+import type { RuntimeBundleDefinition } from '@go-go-golems/os-shell';
+
+export function RuntimeWindow({ bundle }: { bundle: RuntimeBundleDefinition }) {
+  return (
+    <RuntimeSurfaceSessionHost
+      windowId="window:demo"
+      sessionId="session:demo"
+      bundle={bundle}
+    />
+  );
+}
+```
+
+## Runtime bundle shape
+
+Host TypeScript:
+
+```ts
+import type { RuntimeBundleDefinition } from '@go-go-golems/os-shell';
+import bundleCode from './bundle.vm.js?raw';
+
+export const BUNDLE: RuntimeBundleDefinition = {
+  id: 'hello-vm',
+  name: 'Hello VM',
+  icon: '🧪',
+  homeSurface: 'home',
+  plugin: {
+    packageIds: ['ui'],
+    bundleCode,
+    capabilities: { domain: [], system: [] },
+  },
+  surfaces: {
+    home: {
+      id: 'home',
+      type: 'ui.card.v1',
+      title: 'Hello VM',
+      icon: '🧪',
+      ui: {},
+    },
+  },
+};
+```
+
+VM JavaScript:
+
+```js
+defineRuntimeBundle(({ ui }) => ({
+  id: 'hello-vm',
+  title: 'Hello VM',
+  packageIds: ['ui'],
+  surfaces: {
+    home: {
+      packId: 'ui.card.v1',
+      render({ state }) {
+        return ui.panel([
+          ui.text('Hello from QuickJS'),
+          ui.text('Session: ' + state.self.sessionId),
+        ]);
+      },
+    },
+  },
+}));
+```
+
+## Security model
+
+Runtime bundle code runs inside QuickJS, not in the browser global environment. It does not receive direct DOM, network, local storage, filesystem, or Node.js access. It communicates with the host by returning structured UI trees and dispatching validated runtime actions from event handlers.
+
+## Related packages
+
+- `@go-go-golems/os-ui-cards` — base `ui` VM package and `ui.card.v1` renderer.
+- `@go-go-golems/os-kanban` — higher-level Kanban VM package and renderer.
+- `@go-go-golems/os-shell` — desktop shell, app launcher, and window content adapter types.
+- `@go-go-golems/os-repl` — terminal UI used by scripting REPL integrations.

package/app/createAppStore.d.ts

@@ -0,0 +1,89 @@
+import { type Reducer } from '@reduxjs/toolkit';
+export declare const CORE_APP_REDUCER_KEYS: readonly ["pluginCardRuntime", "runtimeSessions", "windowing", "notifications", "debug", "hypercardArtifacts"];
+/** Options for `createAppStore`. */
+export interface CreateAppStoreOptions {
+    /** Enable Redux throughput/FPS diagnostics middleware. Default: false. */
+    enableReduxDiagnostics?: boolean;
+    /** Rolling window duration in ms for diagnostics aggregation. Default: 5000. */
+    diagnosticsWindowMs?: number;
+}
+/**
+ * Creates a Redux store factory pre-wired with all HyperCard engine reducers
+ * (runtimeSessions, windowing, notifications, debug).
+ *
+ * Optionally enables Redux throughput/FPS diagnostics when
+ * `options.enableReduxDiagnostics` is true (intended for dev-mode only).
+ * Diagnostics data is stored outside of Redux in a module-level store
+ * to avoid polluting the dispatch/render cycle it measures.
+ *
+ * Returns both a singleton store and a createStore() factory for Storybook.
+ *
+ * @example
+ * ```ts
+ * const { store, createStore } = createAppStore({
+ *   contacts: contactsReducer,
+ *   companies: companiesReducer,
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With diagnostics enabled (dev mode):
+ * const { store, createStore } = createAppStore(
+ *   { inventory: inventoryReducer },
+ *   { enableReduxDiagnostics: import.meta.env.DEV },
+ * );
+ * ```
+ */
+export declare function createAppStore<T extends Record<string, Reducer>>(domainReducers: T, options?: CreateAppStoreOptions): {
+    store: import("@reduxjs/toolkit").EnhancedStore<{
+        [x: string]: /*elided*/ any;
+        runtimeSessions: import("..").RuntimeSessionsState;
+        windowing: import("@go-go-golems/os-core/desktop-core").WindowingState;
+        notifications: import("@go-go-golems/os-core/features/notifications/notificationsSlice").NotificationsState;
+        debug: import("@go-go-golems/os-core").DebugState;
+        hypercardArtifacts: import("..").ArtifactsState;
+    }, import("@reduxjs/toolkit").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("@reduxjs/toolkit").StoreEnhancer<{
+        dispatch: import("@reduxjs/toolkit").ThunkDispatch<{
+            [x: string]: /*elided*/ any;
+            runtimeSessions: import("..").RuntimeSessionsState;
+            windowing: import("@go-go-golems/os-core/desktop-core").WindowingState;
+            notifications: import("@go-go-golems/os-core/features/notifications/notificationsSlice").NotificationsState;
+            debug: import("@go-go-golems/os-core").DebugState;
+            hypercardArtifacts: import("..").ArtifactsState;
+        }, undefined, import("@reduxjs/toolkit").UnknownAction> & ((action: import("@reduxjs/toolkit").Action<"listenerMiddleware/add">) => import("@reduxjs/toolkit").UnsubscribeListener);
+    }>, import("@reduxjs/toolkit").StoreEnhancer]>>;
+    createStore: () => import("@reduxjs/toolkit").EnhancedStore<{
+        [x: string]: /*elided*/ any;
+        runtimeSessions: import("..").RuntimeSessionsState;
+        windowing: import("@go-go-golems/os-core/desktop-core").WindowingState;
+        notifications: import("@go-go-golems/os-core/features/notifications/notificationsSlice").NotificationsState;
+        debug: import("@go-go-golems/os-core").DebugState;
+        hypercardArtifacts: import("..").ArtifactsState;
+    }, import("@reduxjs/toolkit").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("@reduxjs/toolkit").StoreEnhancer<{
+        dispatch: import("@reduxjs/toolkit").ThunkDispatch<{
+            [x: string]: /*elided*/ any;
+            runtimeSessions: import("..").RuntimeSessionsState;
+            windowing: import("@go-go-golems/os-core/desktop-core").WindowingState;
+            notifications: import("@go-go-golems/os-core/features/notifications/notificationsSlice").NotificationsState;
+            debug: import("@go-go-golems/os-core").DebugState;
+            hypercardArtifacts: import("..").ArtifactsState;
+        }, undefined, import("@reduxjs/toolkit").UnknownAction> & ((action: import("@reduxjs/toolkit").Action<"listenerMiddleware/add">) => import("@reduxjs/toolkit").UnsubscribeListener);
+    }>, import("@reduxjs/toolkit").StoreEnhancer]>>;
+    RootState: {
+        [x: string]: /*elided*/ any;
+        runtimeSessions: import("..").RuntimeSessionsState;
+        windowing: import("@go-go-golems/os-core/desktop-core").WindowingState;
+        notifications: import("@go-go-golems/os-core/features/notifications/notificationsSlice").NotificationsState;
+        debug: import("@go-go-golems/os-core").DebugState;
+        hypercardArtifacts: import("..").ArtifactsState;
+    };
+    AppDispatch: import("@reduxjs/toolkit").ThunkDispatch<{
+        [x: string]: /*elided*/ any;
+        runtimeSessions: import("..").RuntimeSessionsState;
+        windowing: import("@go-go-golems/os-core/desktop-core").WindowingState;
+        notifications: import("@go-go-golems/os-core/features/notifications/notificationsSlice").NotificationsState;
+        debug: import("@go-go-golems/os-core").DebugState;
+        hypercardArtifacts: import("..").ArtifactsState;
+    }, undefined, import("@reduxjs/toolkit").UnknownAction> & ((action: import("@reduxjs/toolkit").Action<"listenerMiddleware/add">) => import("@reduxjs/toolkit").UnsubscribeListener) & import("@reduxjs/toolkit").Dispatch<import("@reduxjs/toolkit").UnknownAction>;
+};

package/app/createAppStore.js

@@ -0,0 +1,90 @@
+import { configureStore } from '@reduxjs/toolkit';
+import { createReduxPerfMiddleware, debugReducer, initDiagnostics, notificationsReducer, startFrameMonitor, } from '@go-go-golems/os-core';
+import { windowingReducer } from '@go-go-golems/os-core/desktop-core';
+import { runtimeSessionsReducer } from '../features/runtimeSessions/runtimeSessionsSlice';
+import { createArtifactProjectionMiddleware } from '../hypercard/artifacts/artifactProjectionMiddleware';
+import { hypercardArtifactsReducer } from '../hypercard/artifacts/artifactsSlice';
+import { createRuntimeSessionLifecycleMiddleware } from './runtimeSessionLifecycleMiddleware';
+export const CORE_APP_REDUCER_KEYS = [
+    'pluginCardRuntime',
+    'runtimeSessions',
+    'windowing',
+    'notifications',
+    'debug',
+    'hypercardArtifacts',
+];
+const CORE_APP_REDUCER_KEY_SET = new Set(CORE_APP_REDUCER_KEYS);
+function assertNoReservedDomainReducerKeys(domainReducers) {
+    const reservedKeys = Object.keys(domainReducers).filter((key) => CORE_APP_REDUCER_KEY_SET.has(key));
+    if (reservedKeys.length === 0) {
+        return;
+    }
+    throw new Error(`createAppStore domain reducer keys are reserved by engine core reducers: ${reservedKeys.join(', ')}`);
+}
+/**
+ * Creates a Redux store factory pre-wired with all HyperCard engine reducers
+ * (runtimeSessions, windowing, notifications, debug).
+ *
+ * Optionally enables Redux throughput/FPS diagnostics when
+ * `options.enableReduxDiagnostics` is true (intended for dev-mode only).
+ * Diagnostics data is stored outside of Redux in a module-level store
+ * to avoid polluting the dispatch/render cycle it measures.
+ *
+ * Returns both a singleton store and a createStore() factory for Storybook.
+ *
+ * @example
+ * ```ts
+ * const { store, createStore } = createAppStore({
+ *   contacts: contactsReducer,
+ *   companies: companiesReducer,
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With diagnostics enabled (dev mode):
+ * const { store, createStore } = createAppStore(
+ *   { inventory: inventoryReducer },
+ *   { enableReduxDiagnostics: import.meta.env.DEV },
+ * );
+ * ```
+ */
+export function createAppStore(domainReducers, options = {}) {
+    const enableDiag = options.enableReduxDiagnostics === true;
+    assertNoReservedDomainReducerKeys(domainReducers);
+    const reducer = {
+        runtimeSessions: runtimeSessionsReducer,
+        windowing: windowingReducer,
+        notifications: notificationsReducer,
+        debug: debugReducer,
+        hypercardArtifacts: hypercardArtifactsReducer,
+        ...domainReducers,
+    };
+    // Initialise module-level diagnostics storage when enabled
+    if (enableDiag) {
+        initDiagnostics({ windowMs: options.diagnosticsWindowMs ?? 5000 });
+    }
+    const perfMiddleware = enableDiag
+        ? createReduxPerfMiddleware({ windowMs: options.diagnosticsWindowMs ?? 5000 })
+        : null;
+    function createStore() {
+        const artifactProjectionMiddleware = createArtifactProjectionMiddleware();
+        const runtimeSessionLifecycleMiddleware = createRuntimeSessionLifecycleMiddleware();
+        const store = configureStore({
+            reducer,
+            middleware: (getDefault) => perfMiddleware
+                ? getDefault().concat(artifactProjectionMiddleware.middleware, runtimeSessionLifecycleMiddleware.middleware, perfMiddleware)
+                : getDefault().concat(artifactProjectionMiddleware.middleware, runtimeSessionLifecycleMiddleware.middleware),
+        });
+        // Start frame monitor when diagnostics are enabled
+        if (enableDiag && typeof requestAnimationFrame !== 'undefined') {
+            startFrameMonitor();
+        }
+        return store;
+    }
+    const store = createStore();
+    return {
+        store,
+        createStore,
+    };
+}

package/app/index.d.ts

@@ -0,0 +1,2 @@
+export { CORE_APP_REDUCER_KEYS, createAppStore, type CreateAppStoreOptions } from './createAppStore';
+export { createRuntimeSessionLifecycleMiddleware } from './runtimeSessionLifecycleMiddleware';

package/app/index.js

@@ -0,0 +1,2 @@
+export { CORE_APP_REDUCER_KEYS, createAppStore } from './createAppStore';
+export { createRuntimeSessionLifecycleMiddleware } from './runtimeSessionLifecycleMiddleware';

package/app/runtimeSessionLifecycleMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { type RuntimeSessionManager } from '../runtime-session-manager';
+interface CreateRuntimeSessionLifecycleMiddlewareOptions {
+    manager?: RuntimeSessionManager;
+}
+export declare function createRuntimeSessionLifecycleMiddleware(options?: CreateRuntimeSessionLifecycleMiddlewareOptions): import("@reduxjs/toolkit").ListenerMiddlewareInstance<unknown, import("@reduxjs/toolkit").ThunkDispatch<unknown, unknown, import("@reduxjs/toolkit").UnknownAction>, unknown>;
+export {};

package/app/runtimeSessionLifecycleMiddleware.js

@@ -0,0 +1,42 @@
+import { createListenerMiddleware } from '@reduxjs/toolkit';
+import { closeWindow } from '@go-go-golems/os-core/desktop-core';
+import { removeRuntimeSession } from '../features/runtimeSessions';
+import { DEFAULT_RUNTIME_SESSION_MANAGER, } from '../runtime-session-manager';
+import { shouldDisposeOnLastSurfaceWindowClose } from '../runtime-session-manager';
+function getClosedSurfaceSessionId(state, windowId) {
+    const window = state.windowing?.windows?.[windowId];
+    if (!window || window.content.kind !== 'surface') {
+        return null;
+    }
+    return window.content.surface?.surfaceSessionId ?? null;
+}
+function stillHasSurfaceWindow(state, sessionId) {
+    const windows = Object.values(state.windowing?.windows ?? {});
+    return windows.some((window) => window.content.kind === 'surface' &&
+        window.content.surface?.surfaceSessionId === sessionId);
+}
+export function createRuntimeSessionLifecycleMiddleware(options = {}) {
+    const listener = createListenerMiddleware();
+    const manager = options.manager ?? DEFAULT_RUNTIME_SESSION_MANAGER;
+    listener.startListening({
+        actionCreator: closeWindow,
+        effect: async (action, api) => {
+            const windowId = action.payload;
+            const sessionId = getClosedSurfaceSessionId(api.getOriginalState(), windowId);
+            if (!sessionId) {
+                return;
+            }
+            const nextState = api.getState();
+            if (stillHasSurfaceWindow(nextState, sessionId)) {
+                return;
+            }
+            const summary = manager.getSummary(sessionId);
+            if (!summary || !shouldDisposeOnLastSurfaceWindowClose(summary.ownership)) {
+                return;
+            }
+            manager.disposeSession(sessionId);
+            api.dispatch(removeRuntimeSession({ sessionId }));
+        },
+    });
+    return listener;
+}

package/features/runtimeSessions/capabilityPolicy.d.ts

@@ -0,0 +1,12 @@
+export type CapabilitySet = 'all' | string[];
+export interface CapabilityPolicy {
+    domain: CapabilitySet;
+    system: CapabilitySet;
+}
+export interface CapabilityDecision {
+    allowed: boolean;
+    reason: string | null;
+}
+export declare function resolveCapabilityPolicy(input?: Partial<CapabilityPolicy>): CapabilityPolicy;
+export declare function authorizeDomainIntent(policy: CapabilityPolicy, domain: string): CapabilityDecision;
+export declare function authorizeSystemIntent(policy: CapabilityPolicy, command: string): CapabilityDecision;

package/features/runtimeSessions/capabilityPolicy.js

@@ -0,0 +1,36 @@
+const DEFAULT_POLICY = {
+    domain: 'all',
+    system: 'all',
+};
+function normalizeCapabilitySet(value, fallback) {
+    if (value === 'all') {
+        return 'all';
+    }
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === 'string' && entry.length > 0);
+    }
+    return fallback;
+}
+export function resolveCapabilityPolicy(input) {
+    return {
+        domain: normalizeCapabilitySet(input?.domain, DEFAULT_POLICY.domain),
+        system: normalizeCapabilitySet(input?.system, DEFAULT_POLICY.system),
+    };
+}
+function includesCapability(set, value) {
+    return set === 'all' || set.includes(value);
+}
+export function authorizeDomainIntent(policy, domain) {
+    const allowed = includesCapability(policy.domain, domain);
+    return {
+        allowed,
+        reason: allowed ? null : `domain_not_allowed:${domain}`,
+    };
+}
+export function authorizeSystemIntent(policy, command) {
+    const allowed = includesCapability(policy.system, command);
+    return {
+        allowed,
+        reason: allowed ? null : `system_command_not_allowed:${command}`,
+    };
+}

package/features/runtimeSessions/index.d.ts

@@ -0,0 +1,3 @@
+export { authorizeDomainIntent, authorizeSystemIntent, resolveCapabilityPolicy, type CapabilityDecision, type CapabilityPolicy, type CapabilitySet, } from './capabilityPolicy';
+export { clearRuntimeTimeline, dequeuePendingDomainIntent, dequeuePendingNavIntent, dequeuePendingSystemIntent, ingestRuntimeAction, runtimeSessionsReducer, registerRuntimeSession, removeRuntimeSession, setRuntimeSessionStatus, type DispatchOutcome, type DomainIntentEnvelope, type RuntimeSessionsState, type RuntimeSessionsStateSlice, type RuntimeSessionRecord, type RuntimeSessionStatus, type RuntimeTimelineEntry, type SystemIntentEnvelope, } from './runtimeSessionsSlice';
+export { selectPendingDomainIntents, selectPendingNavIntents, selectPendingSystemIntents, selectRuntimeSessionsState, selectProjectedRuntimeDomains, selectRuntimeSurfaceState, selectRuntimeSession, selectRuntimeSessionState, selectRuntimeTimeline, } from './selectors';

package/features/runtimeSessions/index.js

@@ -0,0 +1,3 @@
+export { authorizeDomainIntent, authorizeSystemIntent, resolveCapabilityPolicy, } from './capabilityPolicy';
+export { clearRuntimeTimeline, dequeuePendingDomainIntent, dequeuePendingNavIntent, dequeuePendingSystemIntent, ingestRuntimeAction, runtimeSessionsReducer, registerRuntimeSession, removeRuntimeSession, setRuntimeSessionStatus, } from './runtimeSessionsSlice';
+export { selectPendingDomainIntents, selectPendingNavIntents, selectPendingSystemIntents, selectRuntimeSessionsState, selectProjectedRuntimeDomains, selectRuntimeSurfaceState, selectRuntimeSession, selectRuntimeSessionState, selectRuntimeTimeline, } from './selectors';

package/features/runtimeSessions/runtimeSessionsSlice.d.ts

@@ -0,0 +1,90 @@
+import type { RuntimeAction, RuntimeActionKind } from '../../plugin-runtime/contracts';
+import { type CapabilityPolicy } from './capabilityPolicy';
+export type DispatchOutcome = 'applied' | 'denied' | 'ignored';
+export type RuntimeSessionStatus = 'loading' | 'ready' | 'error';
+export interface RuntimeTimelineEntry {
+    id: string;
+    timestamp: string;
+    sessionId: string;
+    surfaceId: string;
+    kind: RuntimeActionKind;
+    actionType: string;
+    payload?: unknown;
+    outcome: DispatchOutcome;
+    reason: string | null;
+}
+export interface DomainIntentEnvelope {
+    id: string;
+    timestamp: string;
+    sessionId: string;
+    surfaceId: string;
+    domain: string;
+    type: string;
+    payload?: unknown;
+}
+export interface SystemIntentEnvelope {
+    id: string;
+    timestamp: string;
+    sessionId: string;
+    surfaceId: string;
+    type: string;
+    payload?: unknown;
+}
+export interface RuntimeSessionRecord {
+    bundleId: string;
+    status: RuntimeSessionStatus;
+    error: string | null;
+    sessionState: Record<string, unknown>;
+    surfaceState: Record<string, Record<string, unknown>>;
+    capabilities: CapabilityPolicy;
+}
+export interface RuntimeSessionsState {
+    sessions: Record<string, RuntimeSessionRecord>;
+    timeline: RuntimeTimelineEntry[];
+    pendingDomainIntents: DomainIntentEnvelope[];
+    pendingSystemIntents: SystemIntentEnvelope[];
+    pendingNavIntents: SystemIntentEnvelope[];
+}
+export interface RuntimeSessionsStateSlice {
+    runtimeSessions: RuntimeSessionsState;
+}
+interface RegisterSessionPayload {
+    sessionId: string;
+    bundleId: string;
+    initialSessionState?: Record<string, unknown>;
+    initialSurfaceState?: Record<string, Record<string, unknown>>;
+    capabilities?: Partial<CapabilityPolicy>;
+    status?: RuntimeSessionStatus;
+}
+interface RemoveSessionPayload {
+    sessionId: string;
+}
+interface SetSessionStatusPayload {
+    sessionId: string;
+    status: RuntimeSessionStatus;
+    error?: string | null;
+}
+interface IngestActionPayload {
+    id: string;
+    timestamp: string;
+    sessionId: string;
+    surfaceId: string;
+    action: RuntimeAction;
+}
+export declare const clearRuntimeTimeline: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"runtimeSessions/clearRuntimeTimeline">, dequeuePendingDomainIntent: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    id?: string;
+} | undefined, "runtimeSessions/dequeuePendingDomainIntent">, dequeuePendingNavIntent: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    id?: string;
+} | undefined, "runtimeSessions/dequeuePendingNavIntent">, dequeuePendingSystemIntent: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    id?: string;
+} | undefined, "runtimeSessions/dequeuePendingSystemIntent">, ingestRuntimeAction: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: Omit<IngestActionPayload, "id" | "timestamp"> & {
+    timestamp?: string;
+}], {
+    id: string;
+    timestamp: string;
+    sessionId: string;
+    surfaceId: string;
+    action: RuntimeAction;
+}, "runtimeSessions/ingestRuntimeAction", never, never>, registerRuntimeSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<RegisterSessionPayload, "runtimeSessions/registerRuntimeSession">, removeRuntimeSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<RemoveSessionPayload, "runtimeSessions/removeRuntimeSession">, setRuntimeSessionStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetSessionStatusPayload, "runtimeSessions/setRuntimeSessionStatus">;
+export declare const runtimeSessionsReducer: import("@reduxjs/toolkit").Reducer<RuntimeSessionsState>;
+export {};