@go-go-golems/os-scripting 0.1.0

package/runtime-host/pluginIntentRouting.js

@@ -0,0 +1,83 @@
+import { showToast } from '@go-go-golems/os-core';
+import { authorizeDomainIntent, authorizeSystemIntent } from '../features/runtimeSessions';
+import { ingestRuntimeAction } from '../features/runtimeSessions';
+import { closeWindow, sessionNavBack, sessionNavGo } from '@go-go-golems/os-core/desktop-core';
+import { getRuntimeActionDomain, getRuntimeActionKind } from '../plugin-runtime/contracts';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function toSystemAction(action, context) {
+    if (action.type === 'nav.back') {
+        return sessionNavBack({ sessionId: context.sessionId });
+    }
+    if (action.type === 'nav.go') {
+        if (!isRecord(action.payload)) {
+            return null;
+        }
+        const surface = action.payload.surfaceId;
+        if (typeof surface !== 'string' || surface.length === 0) {
+            return null;
+        }
+        const param = typeof action.payload.param === 'string' ? action.payload.param : undefined;
+        return sessionNavGo({ sessionId: context.sessionId, surface, param });
+    }
+    if (action.type === 'notify.show') {
+        if (!isRecord(action.payload)) {
+            return null;
+        }
+        const message = action.payload.message;
+        if (typeof message !== 'string' || message.length === 0) {
+            return null;
+        }
+        return showToast(message);
+    }
+    if (action.type === 'window.close') {
+        return closeWindow(context.windowId);
+    }
+    return null;
+}
+function toDomainAction(action, context) {
+    return {
+        type: action.type,
+        payload: action.payload,
+        meta: {
+            source: 'plugin-runtime',
+            sessionId: context.sessionId,
+            runtimeSessionId: context.sessionId,
+            surfaceId: context.surfaceId,
+            windowId: context.windowId,
+        },
+    };
+}
+export function dispatchRuntimeAction(action, context) {
+    context.dispatch(ingestRuntimeAction({
+        sessionId: context.sessionId,
+        surfaceId: context.surfaceId,
+        action,
+    }));
+    const runtimeSession = context.getState?.()?.runtimeSessions?.sessions?.[context.sessionId];
+    const kind = getRuntimeActionKind(action.type);
+    if (kind === 'domain' && runtimeSession?.capabilities) {
+        const domain = getRuntimeActionDomain(action.type);
+        const decision = authorizeDomainIntent(runtimeSession.capabilities, domain ?? '');
+        if (!decision.allowed) {
+            return;
+        }
+    }
+    if (kind === 'system' && runtimeSession?.capabilities) {
+        const decision = authorizeSystemIntent(runtimeSession.capabilities, action.type);
+        if (!decision.allowed) {
+            return;
+        }
+    }
+    if (kind === 'domain') {
+        context.dispatch(toDomainAction(action, context));
+        return;
+    }
+    if (kind === 'system') {
+        const routed = toSystemAction(action, context);
+        if (routed) {
+            context.dispatch(routed);
+        }
+    }
+}

package/runtime-packages/index.d.ts

@@ -0,0 +1 @@
+export * from './runtimePackageRegistry';

package/runtime-packages/index.js

@@ -0,0 +1 @@
+export * from './runtimePackageRegistry';

package/runtime-packages/runtimePackageRegistry.d.ts

@@ -0,0 +1,14 @@
+export interface RuntimePackageDefinition {
+    packageId: string;
+    version: string;
+    summary?: string;
+    docsMetadata?: Record<string, unknown>;
+    installPrelude: string;
+    surfaceTypes: string[];
+    dependencies?: string[];
+}
+export declare function registerRuntimePackage(definition: RuntimePackageDefinition): void;
+export declare function clearRuntimePackages(): void;
+export declare function getRuntimePackageOrThrow(packageId: string): RuntimePackageDefinition;
+export declare function listRuntimePackages(): string[];
+export declare function resolveRuntimePackageInstallOrder(packageIds: string[]): string[];

package/runtime-packages/runtimePackageRegistry.js

@@ -0,0 +1,42 @@
+const runtimePackages = new Map();
+export function registerRuntimePackage(definition) {
+    runtimePackages.set(definition.packageId, definition);
+}
+export function clearRuntimePackages() {
+    runtimePackages.clear();
+}
+export function getRuntimePackageOrThrow(packageId) {
+    const runtimePackage = runtimePackages.get(packageId);
+    if (!runtimePackage) {
+        throw new Error(`Unknown runtime package: ${packageId}`);
+    }
+    return runtimePackage;
+}
+export function listRuntimePackages() {
+    return Array.from(runtimePackages.keys()).sort();
+}
+export function resolveRuntimePackageInstallOrder(packageIds) {
+    const ordered = [];
+    const visiting = new Set();
+    const visited = new Set();
+    function visit(packageId) {
+        if (visited.has(packageId)) {
+            return;
+        }
+        if (visiting.has(packageId)) {
+            throw new Error(`Runtime package dependency cycle detected at ${packageId}`);
+        }
+        visiting.add(packageId);
+        const runtimePackage = getRuntimePackageOrThrow(packageId);
+        for (const dependencyId of runtimePackage.dependencies ?? []) {
+            visit(dependencyId);
+        }
+        visiting.delete(packageId);
+        visited.add(packageId);
+        ordered.push(packageId);
+    }
+    for (const packageId of packageIds) {
+        visit(packageId);
+    }
+    return ordered;
+}

package/runtime-packages/ui.package.vm.js

@@ -0,0 +1,84 @@
+const __ui = {
+  text(content) {
+    return { kind: 'text', text: String(content) };
+  },
+  button(label, props = {}) {
+    return { kind: 'button', props: { label: String(label), ...props } };
+  },
+  input(value, props = {}) {
+    return { kind: 'input', props: { value: String(value ?? ''), ...props } };
+  },
+  row(children = []) {
+    return { kind: 'row', children: Array.isArray(children) ? children : [] };
+  },
+  column(children = []) {
+    return { kind: 'column', children: Array.isArray(children) ? children : [] };
+  },
+  panel(children = []) {
+    return { kind: 'panel', children: Array.isArray(children) ? children : [] };
+  },
+  badge(text) {
+    return { kind: 'badge', text: String(text) };
+  },
+  table(rows = [], props = {}) {
+    return {
+      kind: 'table',
+      props: {
+        headers: Array.isArray(props?.headers) ? props.headers : [],
+        rows: Array.isArray(rows) ? rows : [],
+      },
+    };
+  },
+  dropdown(options = [], props = {}) {
+    const selected = Number.isFinite(Number(props?.selected)) ? Number(props.selected) : 0;
+    return {
+      kind: 'dropdown',
+      props: {
+        options: Array.isArray(options) ? options.map((option) => String(option)) : [],
+        selected,
+        onSelect: props?.onSelect,
+        width: props?.width,
+      },
+    };
+  },
+  selectableTable(rows = [], props = {}) {
+    return {
+      kind: 'selectableTable',
+      props: {
+        headers: Array.isArray(props?.headers) ? props.headers.map((header) => String(header)) : [],
+        rows: Array.isArray(rows) ? rows : [],
+        selectedRowKeys: Array.isArray(props?.selectedRowKeys)
+          ? props.selectedRowKeys.map((key) => String(key))
+          : [],
+        mode: props?.mode,
+        rowKeyIndex: Number.isFinite(Number(props?.rowKeyIndex)) ? Number(props.rowKeyIndex) : 0,
+        searchable: props?.searchable === true,
+        searchText: typeof props?.searchText === 'string' ? props.searchText : '',
+        searchPlaceholder: typeof props?.searchPlaceholder === 'string' ? props.searchPlaceholder : undefined,
+        emptyMessage: typeof props?.emptyMessage === 'string' ? props.emptyMessage : undefined,
+        onSelectionChange: props?.onSelectionChange,
+        onSearchChange: props?.onSearchChange,
+        onRowClick: props?.onRowClick,
+      },
+    };
+  },
+  gridBoard(props = {}) {
+    return {
+      kind: 'gridBoard',
+      props: {
+        rows: Number.isFinite(Number(props?.rows)) ? Number(props.rows) : 1,
+        cols: Number.isFinite(Number(props?.cols)) ? Number(props.cols) : 1,
+        cells: Array.isArray(props?.cells) ? props.cells : [],
+        selectedIndex:
+          props?.selectedIndex === null || Number.isFinite(Number(props?.selectedIndex))
+            ? props.selectedIndex
+            : undefined,
+        cellSize: props?.cellSize,
+        disabled: props?.disabled === true,
+        onSelect: props?.onSelect,
+      },
+    };
+  },
+};
+
+globalThis.registerRuntimePackageApi('ui', { ui: __ui });

package/runtime-packs/index.d.ts

@@ -0,0 +1 @@
+export * from './runtimeSurfaceTypeRegistry';

package/runtime-packs/index.js

@@ -0,0 +1 @@
+export * from './runtimeSurfaceTypeRegistry';

package/runtime-packs/runtimeSurfaceTypeRegistry.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+export declare const UI_CARD_V1_RUNTIME_SURFACE_TYPE_ID: "ui.card.v1";
+export type RuntimeSurfaceTypeId = typeof UI_CARD_V1_RUNTIME_SURFACE_TYPE_ID | string;
+export type RuntimeSurfaceTree = unknown;
+export interface RuntimeSurfaceTypeRendererProps<TTree> {
+    tree: TTree;
+    onEvent: (handler: string, args?: unknown) => void;
+}
+export interface RuntimeSurfaceTypeDefinition<TTree> {
+    packId: RuntimeSurfaceTypeId;
+    validateTree: (value: unknown) => TTree;
+    render: (props: RuntimeSurfaceTypeRendererProps<TTree>) => ReactNode;
+}
+export declare function registerRuntimeSurfaceType<TTree>(definition: RuntimeSurfaceTypeDefinition<TTree>): void;
+export declare function clearRuntimeSurfaceTypes(): void;
+export declare function normalizeRuntimeSurfaceTypeId(packId?: string | null): string;
+export declare function getRuntimeSurfaceTypeOrThrow(packId?: string | null): RuntimeSurfaceTypeDefinition<unknown>;
+export declare function listRuntimeSurfaceTypes(): string[];
+export declare function validateRuntimeSurfaceTree<TTree = RuntimeSurfaceTree>(packId: string | undefined, value: unknown): TTree;
+export declare function renderRuntimeSurfaceTree(packId: string | undefined, value: unknown, onEvent: (handler: string, args?: unknown) => void): ReactNode;

package/runtime-packs/runtimeSurfaceTypeRegistry.js

@@ -0,0 +1,37 @@
+export const UI_CARD_V1_RUNTIME_SURFACE_TYPE_ID = 'ui.card.v1';
+const runtimeSurfaceTypes = new Map();
+export function registerRuntimeSurfaceType(definition) {
+    runtimeSurfaceTypes.set(definition.packId, definition);
+}
+export function clearRuntimeSurfaceTypes() {
+    runtimeSurfaceTypes.clear();
+}
+export function normalizeRuntimeSurfaceTypeId(packId) {
+    if (typeof packId !== 'string') {
+        throw new Error('Runtime surface type id is required');
+    }
+    const trimmed = packId.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Runtime surface type id is required');
+    }
+    return trimmed;
+}
+export function getRuntimeSurfaceTypeOrThrow(packId) {
+    const normalized = normalizeRuntimeSurfaceTypeId(packId);
+    const surfaceType = runtimeSurfaceTypes.get(normalized);
+    if (!surfaceType) {
+        throw new Error(`Unknown runtime surface type: ${normalized}`);
+    }
+    return surfaceType;
+}
+export function listRuntimeSurfaceTypes() {
+    return Array.from(runtimeSurfaceTypes.keys()).sort();
+}
+export function validateRuntimeSurfaceTree(packId, value) {
+    return getRuntimeSurfaceTypeOrThrow(packId).validateTree(value);
+}
+export function renderRuntimeSurfaceTree(packId, value, onEvent) {
+    const surfaceType = getRuntimeSurfaceTypeOrThrow(packId);
+    const tree = surfaceType.validateTree(value);
+    return surfaceType.render({ tree, onEvent });
+}

package/runtime-session-manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from './runtimeSessionManager';
+export * from './runtimeOwnership';

package/runtime-session-manager/index.js

@@ -0,0 +1,2 @@
+export * from './runtimeSessionManager';
+export * from './runtimeOwnership';

package/runtime-session-manager/runtimeOwnership.d.ts

@@ -0,0 +1,10 @@
+export type RuntimeSessionOwnershipKind = 'window-owned' | 'broker-owned' | 'attached-read-only' | 'attached-writable';
+export interface RuntimeSessionOwnership {
+    kind: RuntimeSessionOwnershipKind;
+    writable: boolean;
+}
+export declare const WINDOW_OWNED_RUNTIME_SESSION: RuntimeSessionOwnership;
+export declare const BROKER_OWNED_RUNTIME_SESSION: RuntimeSessionOwnership;
+export declare const ATTACHED_READ_ONLY_RUNTIME_SESSION: RuntimeSessionOwnership;
+export declare const ATTACHED_WRITABLE_RUNTIME_SESSION: RuntimeSessionOwnership;
+export declare function shouldDisposeOnLastSurfaceWindowClose(ownership: RuntimeSessionOwnership): boolean;

package/runtime-session-manager/runtimeOwnership.js

@@ -0,0 +1,19 @@
+export const WINDOW_OWNED_RUNTIME_SESSION = {
+    kind: 'window-owned',
+    writable: true,
+};
+export const BROKER_OWNED_RUNTIME_SESSION = {
+    kind: 'broker-owned',
+    writable: true,
+};
+export const ATTACHED_READ_ONLY_RUNTIME_SESSION = {
+    kind: 'attached-read-only',
+    writable: false,
+};
+export const ATTACHED_WRITABLE_RUNTIME_SESSION = {
+    kind: 'attached-writable',
+    writable: true,
+};
+export function shouldDisposeOnLastSurfaceWindowClose(ownership) {
+    return ownership.kind === 'window-owned';
+}

package/runtime-session-manager/runtimeSessionManager.d.ts

@@ -0,0 +1,47 @@
+import type { RuntimeAction, RuntimeBundleMeta, RuntimeSurfaceId, SessionId, StackId } from '../plugin-runtime/contracts';
+import { QuickJSRuntimeService, type QuickJSRuntimeServiceOptions } from '../plugin-runtime/runtimeService';
+import { type RuntimeSessionOwnership } from './runtimeOwnership';
+export interface EnsureRuntimeSessionRequest {
+    bundleId: StackId;
+    sessionId: SessionId;
+    packageIds: string[];
+    bundleCode: string;
+}
+export interface RuntimeSessionManagerSummary {
+    sessionId: SessionId;
+    bundleId: StackId;
+    packageIds: string[];
+    surfaces: string[];
+    surfaceTypes?: Record<string, string>;
+    title: string;
+    description?: string;
+    status: 'loading' | 'ready' | 'error';
+    error?: string;
+    attachedViewIds: string[];
+    ownership: RuntimeSessionOwnership;
+}
+export interface RuntimeSessionManagerHandle {
+    readonly sessionId: SessionId;
+    readonly bundleId: StackId;
+    getBundleMeta(): RuntimeBundleMeta;
+    evaluateSessionJs(code: string): ReturnType<QuickJSRuntimeService['evaluateSessionJs']>;
+    getSessionGlobalNames(): string[];
+    renderSurface(surfaceId: RuntimeSurfaceId, state: unknown): unknown;
+    eventSurface(surfaceId: RuntimeSurfaceId, handler: string, args: unknown, state: unknown): RuntimeAction[];
+    defineSurface(surfaceId: RuntimeSurfaceId, code: string, packId: string): RuntimeBundleMeta;
+    defineSurfaceRender(surfaceId: RuntimeSurfaceId, code: string): RuntimeBundleMeta;
+    defineSurfaceHandler(surfaceId: RuntimeSurfaceId, handler: string, code: string): RuntimeBundleMeta;
+    attachView(viewId: string): () => void;
+    dispose(): boolean;
+}
+export interface RuntimeSessionManager {
+    ensureSession(request: EnsureRuntimeSessionRequest): Promise<RuntimeSessionManagerHandle>;
+    getSession(sessionId: SessionId): RuntimeSessionManagerHandle | null;
+    getSummary(sessionId: SessionId): RuntimeSessionManagerSummary | null;
+    listSessions(): RuntimeSessionManagerSummary[];
+    disposeSession(sessionId: SessionId): boolean;
+    clear(): void;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createRuntimeSessionManager(options?: QuickJSRuntimeServiceOptions): RuntimeSessionManager;
+export declare const DEFAULT_RUNTIME_SESSION_MANAGER: RuntimeSessionManager;

package/runtime-session-manager/runtimeSessionManager.js

@@ -0,0 +1,214 @@
+import { QuickJSRuntimeService } from '../plugin-runtime/runtimeService';
+import { WINDOW_OWNED_RUNTIME_SESSION, } from './runtimeOwnership';
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameRequest(left, right) {
+    return (left.bundleId === right.bundleId &&
+        left.sessionId === right.sessionId &&
+        left.bundleCode === right.bundleCode &&
+        arraysEqual(left.packageIds, right.packageIds));
+}
+function cloneBundleMeta(bundle) {
+    return {
+        ...bundle,
+        packageIds: [...bundle.packageIds],
+        surfaces: [...bundle.surfaces],
+        surfaceTypes: bundle.surfaceTypes ? { ...bundle.surfaceTypes } : undefined,
+    };
+}
+function toSummary(record) {
+    return {
+        sessionId: record.request.sessionId,
+        bundleId: record.request.bundleId,
+        packageIds: record.bundle?.packageIds ? [...record.bundle.packageIds] : [...record.request.packageIds],
+        surfaces: record.bundle?.surfaces ? [...record.bundle.surfaces] : [],
+        surfaceTypes: record.bundle?.surfaceTypes ? { ...record.bundle.surfaceTypes } : undefined,
+        title: record.bundle?.title ?? record.request.bundleId,
+        description: record.bundle?.description,
+        status: record.status,
+        error: record.error,
+        attachedViewIds: Array.from(record.attachedViewIds).sort(),
+        ownership: WINDOW_OWNED_RUNTIME_SESSION,
+    };
+}
+export function createRuntimeSessionManager(options = {}) {
+    const runtimeService = new QuickJSRuntimeService(options);
+    const records = new Map();
+    const listeners = new Set();
+    function emit() {
+        listeners.forEach((listener) => listener());
+    }
+    function getRecordOrThrow(sessionId) {
+        const record = records.get(sessionId);
+        if (!record) {
+            throw new Error(`Unknown runtime session: ${sessionId}`);
+        }
+        return record;
+    }
+    function updateBundle(sessionId, bundle) {
+        const record = getRecordOrThrow(sessionId);
+        record.bundle = bundle;
+        record.status = 'ready';
+        record.error = undefined;
+        emit();
+        return bundle;
+    }
+    function attachView(sessionId, viewId) {
+        const record = getRecordOrThrow(sessionId);
+        let released = false;
+        record.attachedViewIds.add(viewId);
+        emit();
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            const current = records.get(sessionId);
+            if (!current) {
+                return;
+            }
+            if (current.attachedViewIds.delete(viewId)) {
+                emit();
+            }
+        };
+    }
+    function createHandle(sessionId) {
+        return {
+            sessionId,
+            get bundleId() {
+                return getRecordOrThrow(sessionId).request.bundleId;
+            },
+            getBundleMeta() {
+                const record = getRecordOrThrow(sessionId);
+                if (!record.bundle) {
+                    throw new Error(`Runtime session is not ready: ${sessionId}`);
+                }
+                return cloneBundleMeta(record.bundle);
+            },
+            evaluateSessionJs(code) {
+                return runtimeService.evaluateSessionJs(sessionId, code);
+            },
+            getSessionGlobalNames() {
+                return runtimeService.getSessionGlobalNames(sessionId);
+            },
+            renderSurface(surfaceId, state) {
+                return runtimeService.renderRuntimeSurface(sessionId, surfaceId, state);
+            },
+            eventSurface(surfaceId, handler, args, state) {
+                return runtimeService.eventRuntimeSurface(sessionId, surfaceId, handler, args, state);
+            },
+            defineSurface(surfaceId, code, packId) {
+                return updateBundle(sessionId, runtimeService.defineRuntimeSurface(sessionId, surfaceId, code, packId));
+            },
+            defineSurfaceRender(surfaceId, code) {
+                return updateBundle(sessionId, runtimeService.defineRuntimeSurfaceRender(sessionId, surfaceId, code));
+            },
+            defineSurfaceHandler(surfaceId, handler, code) {
+                return updateBundle(sessionId, runtimeService.defineRuntimeSurfaceHandler(sessionId, surfaceId, handler, code));
+            },
+            attachView(viewId) {
+                return attachView(sessionId, viewId);
+            },
+            dispose() {
+                return manager.disposeSession(sessionId);
+            },
+        };
+    }
+    const manager = {
+        async ensureSession(request) {
+            const existing = records.get(request.sessionId);
+            if (existing) {
+                if (!sameRequest(existing.request, request)) {
+                    throw new Error(`Runtime session already exists with different configuration: ${request.sessionId}`);
+                }
+                if (existing.pendingLoad) {
+                    await existing.pendingLoad;
+                }
+                if (existing.status === 'error') {
+                    throw new Error(existing.error ?? `Runtime session failed to load: ${request.sessionId}`);
+                }
+                return createHandle(request.sessionId);
+            }
+            const record = {
+                request: {
+                    ...request,
+                    packageIds: [...request.packageIds],
+                },
+                status: 'loading',
+                bundle: null,
+                attachedViewIds: new Set(),
+                pendingLoad: null,
+            };
+            records.set(request.sessionId, record);
+            emit();
+            record.pendingLoad = runtimeService
+                .loadRuntimeBundle(request.bundleId, request.sessionId, request.packageIds, request.bundleCode)
+                .then((bundle) => {
+                if (records.get(request.sessionId) !== record) {
+                    runtimeService.disposeSession(request.sessionId);
+                    return bundle;
+                }
+                record.bundle = bundle;
+                record.status = 'ready';
+                record.error = undefined;
+                record.pendingLoad = null;
+                emit();
+                return bundle;
+            })
+                .catch((error) => {
+                if (records.get(request.sessionId) !== record) {
+                    return Promise.reject(error);
+                }
+                record.status = 'error';
+                record.error = error instanceof Error ? error.message : String(error);
+                record.pendingLoad = null;
+                emit();
+                throw error;
+            });
+            await record.pendingLoad;
+            return createHandle(request.sessionId);
+        },
+        getSession(sessionId) {
+            const record = records.get(sessionId);
+            if (!record || record.status !== 'ready') {
+                return null;
+            }
+            return createHandle(sessionId);
+        },
+        getSummary(sessionId) {
+            const record = records.get(sessionId);
+            return record ? toSummary(record) : null;
+        },
+        listSessions() {
+            return Array.from(records.values())
+                .map((record) => toSummary(record))
+                .sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+        },
+        disposeSession(sessionId) {
+            const record = records.get(sessionId);
+            if (!record) {
+                return false;
+            }
+            records.delete(sessionId);
+            const disposed = runtimeService.disposeSession(sessionId);
+            emit();
+            return disposed;
+        },
+        clear() {
+            for (const sessionId of Array.from(records.keys())) {
+                runtimeService.disposeSession(sessionId);
+            }
+            records.clear();
+            emit();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+    return manager;
+}
+export const DEFAULT_RUNTIME_SESSION_MANAGER = createRuntimeSessionManager();

package/testRuntimeUi.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimePackageDefinition } from './runtime-packages';
+import type { RuntimeSurfaceTypeDefinition } from './runtime-packs';
+export declare const TEST_UI_RUNTIME_PACKAGE: RuntimePackageDefinition;
+export declare const TEST_UI_CARD_V1_RUNTIME_SURFACE_TYPE: RuntimeSurfaceTypeDefinition<unknown>;

package/testRuntimeUi.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+export const TEST_UI_RUNTIME_PACKAGE = {
+    packageId: 'ui',
+    version: 'test',
+    installPrelude: `
+const __ui = {
+  text(content) { return { kind: 'text', text: String(content) }; },
+  button(label, props = {}) { return { kind: 'button', props: { label: String(label), ...props } }; },
+  column(children = []) { return { kind: 'column', children: Array.isArray(children) ? children : [] }; },
+  panel(children = []) { return { kind: 'panel', children: Array.isArray(children) ? children : [] }; },
+};
+globalThis.registerRuntimePackageApi('ui', { ui: __ui });
+`.trim(),
+    surfaceTypes: ['ui.card.v1'],
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function renderTestNode(node, keyHint) {
+    if (!isRecord(node) || typeof node.kind !== 'string') {
+        return null;
+    }
+    if (node.kind === 'panel' || node.kind === 'column') {
+        const children = Array.isArray(node.children) ? node.children : [];
+        return (_jsx("div", { children: children.map((child, index) => renderTestNode(child, `${keyHint}:${index}`)) }, keyHint));
+    }
+    if (node.kind === 'text' && typeof node.text === 'string') {
+        return _jsx("span", { children: node.text }, keyHint);
+    }
+    if (node.kind === 'button' && isRecord(node.props) && typeof node.props.label === 'string') {
+        return _jsx("button", { children: node.props.label }, keyHint);
+    }
+    return null;
+}
+export const TEST_UI_CARD_V1_RUNTIME_SURFACE_TYPE = {
+    packId: 'ui.card.v1',
+    validateTree: (value) => value,
+    render: ({ tree }) => _jsx(_Fragment, { children: renderTestNode(tree, 'test-ui-root') }),
+};