@aotui/mobile-ai-native 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/demo/inbox/actions.d.ts

@@ -6,10 +6,10 @@ declare const inboxMessageSchema: z.ZodObject<{
     opened: z.ZodBoolean;
 }, z.core.$strip>;
 export declare function createInboxActions(): {
-    openMessage: import("../../core/action/defineAction").ActionDefinition<InboxState, InboxEvent, {
+    openMessage: import("../..").ViewTypeToolActionDefinition<InboxState, InboxEvent, {
         message: z.infer<typeof inboxMessageSchema>;
     }>;
-    searchMessages: import("../../core/action/defineAction").ActionDefinition<InboxState, InboxEvent, {
+    searchMessages: import("../..").ViewTypeToolActionDefinition<InboxState, InboxEvent, {
         query: string;
     }>;
 };

package/dist/demo/inbox/actions.js

@@ -1,17 +1,22 @@
 import { z } from "zod";
-import { defineAction } from "../../core/action/defineAction";
+import { defineViewTypeTool } from "../../core/action/defineViewTypeTool";
+import { isInboxSearchActive, isInboxSearchRelevant } from "./state";
 const inboxMessageSchema = z.object({
     id: z.string(),
     subject: z.string(),
     opened: z.boolean(),
 });
 export function createInboxActions() {
-    const openMessage = defineAction({
+    const openMessage = defineViewTypeTool({
         name: "openMessage",
         description: "Open a message from the inbox.",
         schema: z.object({
             message: inboxMessageSchema,
         }),
+        viewType: "Inbox",
+        meta: {
+            supportsRefs: true,
+        },
         visibility(state) {
             return state.shell.currentTab === "inbox";
         },
@@ -23,18 +28,22 @@ export function createInboxActions() {
             });
             return {
                 success: true,
+                mutated: true,
+                message: `Opened message ${input.message.subject}`,
                 data: { openedMessageId: input.message.id },
             };
         },
     });
-    const searchMessages = defineAction({
+    const searchMessages = defineViewTypeTool({
         name: "searchMessages",
         description: "Search inbox messages.",
         schema: z.object({
             query: z.string().min(1),
         }),
+        viewType: "Inbox",
         visibility(state) {
-            return state.shell.currentTab === "inbox";
+            return (state.shell.currentTab === "inbox" &&
+                (isInboxSearchRelevant(state) || isInboxSearchActive(state)));
         },
         async handler(ctx, input) {
             ctx.emit({ type: "SearchStarted", query: input.query });
@@ -42,9 +51,11 @@ export function createInboxActions() {
                 type: "TraceUpdated",
                 summary: `Started search for ${input.query}`,
             });
+            ctx.trace.update(`Started search for ${input.query}`);
             await ctx.runEffect("searchMessages", input);
             return {
                 success: true,
+                mutated: true,
                 message: `Started search for ${input.query}`,
             };
         },

package/dist/demo/inbox/createInboxApp.d.ts

@@ -4,11 +4,8 @@ export declare function createInboxApp(config: {
 }): {
     store: import("../../core/types").Store<import("./state").InboxState, import("./state").InboxEvent>;
     bridge: {
-        listTools(): {
-            name: string;
-            description: string;
-        }[];
-        getSnapshotBundle(): import("../../core/types").SnapshotBundle;
+        listTools(): import("../..").ToolDefinition[];
+        getSnapshotBundle(): import("../..").SnapshotBundle;
         executeTool(name: string, input: Record<string, unknown>, snapshotId: string): Promise<import("../../core/types").ActionResult>;
     };
     gui: {

package/dist/demo/inbox/createInboxApp.js

@@ -3,14 +3,13 @@ import { jsx as _jsx } from "preact/jsx-runtime";
 import renderToString from "preact-render-to-string";
 import { createActionRuntime } from "../../core/action/createActionRuntime";
 import { createStore } from "../../core/state/createStore";
-import { renderTUI } from "../../projection/tui/renderTUI";
 import { AppProvider } from "../../projection/gui/AppProvider";
 import { createToolBridge } from "../../tool/createToolBridge";
 import { createInboxActions } from "./actions";
 import { createInboxEffects } from "./effects";
 import { InboxGUI } from "./InboxGUI";
-import { InboxTUI } from "./InboxTUI";
-import { createInitialInboxState, reduceInboxState, } from "./state";
+import { createInboxSnapshotBundle, } from "./InboxTUI";
+import { createInitialInboxState, getInboxRelevantViewTypes, reduceInboxState, } from "./state";
 export function createInboxApp(config) {
     const store = createStore({
         initialState: createInitialInboxState(config.initialMessages),
@@ -21,11 +20,12 @@ export function createInboxApp(config) {
         store,
         actions: [actions.openMessage, actions.searchMessages],
         effects: createInboxEffects(config.initialMessages),
+        getRelevantViewTypes: () => getInboxRelevantViewTypes(store.getState()),
     });
     const bridge = createToolBridge({
         actionRuntime,
         renderCurrentSnapshot() {
-            return renderTUI(_jsx(AppProvider, { store: store, actionRuntime: actionRuntime, children: _jsx(InboxTUI, {}) }), { visibleTools: actionRuntime.listVisibleTools() });
+            return createInboxSnapshotBundle(store.getState(), actionRuntime.listVisibleTools());
         },
     });
     function renderGUI() {

package/dist/demo/inbox/effects.d.ts

@@ -1,9 +1,7 @@
 import type { InboxEvent, InboxMessage, InboxState } from "./state";
+import type { EffectContext, EffectResult } from "../../core/effect/types";
 export declare function createInboxEffects(allMessages: InboxMessage[]): {
-    searchMessages(ctx: {
-        getState(): InboxState;
-        emit(event: InboxEvent): void;
-    }, input: {
+    searchMessages(ctx: EffectContext<InboxState, InboxEvent>, input: {
         query: string;
-    }): Promise<void>;
+    }): Promise<EffectResult>;
 };

package/dist/demo/inbox/effects.js

@@ -1,12 +1,17 @@
 export function createInboxEffects(allMessages) {
     return {
         async searchMessages(ctx, input) {
+            ctx.trace.update(`Searching ${input.query}`);
             const items = allMessages.filter((item) => item.subject.toLowerCase().includes(input.query.toLowerCase()));
             ctx.emit({
                 type: "SearchSucceeded",
                 query: input.query,
                 items,
             });
+            ctx.trace.update(`Found ${items.length} matching messages`);
+            return {
+                success: true,
+            };
         },
     };
 }

package/dist/demo/inbox/state.d.ts

@@ -31,3 +31,6 @@ export type InboxEvent = {
 };
 export declare function createInitialInboxState(messages: InboxMessage[]): InboxState;
 export declare function reduceInboxState(state: InboxState, event: InboxEvent): InboxState;
+export declare function isInboxSearchRelevant(state: InboxState): boolean;
+export declare function isInboxSearchActive(state: InboxState): boolean;
+export declare function getInboxRelevantViewTypes(state: InboxState): string[];

package/dist/demo/inbox/state.js

@@ -54,3 +54,19 @@ export function reduceInboxState(state, event) {
             return state;
     }
 }
+export function isInboxSearchRelevant(state) {
+    return state.inbox.items.length > 1;
+}
+export function isInboxSearchActive(state) {
+    return state.inbox.isLoading || state.inbox.query.trim().length > 0;
+}
+export function getInboxRelevantViewTypes(state) {
+    const viewTypes = ["Root", "Inbox"];
+    if (isInboxSearchActive(state)) {
+        viewTypes.push("InboxSearch");
+    }
+    if (state.inbox.openedMessageId) {
+        viewTypes.push("MessageDetail");
+    }
+    return viewTypes;
+}

package/dist/index.d.ts

@@ -1,10 +1,25 @@
-export declare const VERSION = "0.0.0";
+import { createSnapshotBundle } from "./core/snapshot/createSnapshotBundle";
+import { VERSION } from "./version";
+export { VERSION };
 export { createStore } from "./core/state/createStore";
-export { createSnapshotBundle } from "./core/snapshot/createSnapshotBundle";
+export { createSnapshotBundle };
+export type { RefIndexEntry, MountedViewDescriptor, SnapshotBundle, TraceState, ToolDefinition, StaticViewCatalogEntry, SnapshotAssemblerInput, ViewFragment, } from "./core/types";
+export type { EffectContext, EffectFailure, EffectHandler, EffectMap, EffectResult, EffectSuccess, EffectTrace, } from "./core/effect/types";
+export type { ActionContext, ActionDefinition, } from "./core/action/defineAction";
+export type { ViewTypeToolActionDefinition, } from "./core/action/defineViewTypeTool";
 export { defineAction } from "./core/action/defineAction";
+export { defineViewTypeTool } from "./core/action/defineViewTypeTool";
 export { createActionRuntime } from "./core/action/createActionRuntime";
 export { createToolBridge } from "./tool/createToolBridge";
 export { useDataRef } from "./ref/useDataRef";
 export { useArrayRef } from "./ref/useArrayRef";
+export { View } from "./projection/tui/View";
+export { createSnapshotAssembler } from "./projection/tui/createSnapshotAssembler";
 export { renderTUI } from "./projection/tui/renderTUI";
+export { createReactAppRuntime } from "./projection/react/createReactAppRuntime";
+export type { ReactAppDefinition, ReactAppRuntime, RuntimeTrace, } from "./projection/react/createReactAppRuntime";
+export { AppRuntimeProvider } from "./projection/react/AppRuntimeProvider";
+export { useAppRuntime, useRuntimeActions, useRuntimeState, useRuntimeTrace } from "./projection/react/hooks";
+export { AppProvider } from "./projection/gui/AppProvider";
+export { useAppState, useActions } from "./projection/gui/hooks";
 export { createInboxApp } from "./demo/inbox/createInboxApp";

package/dist/index.js

@@ -1,10 +1,20 @@
-export const VERSION = "0.0.0";
+import { createSnapshotBundle } from "./core/snapshot/createSnapshotBundle";
+import { VERSION } from "./version";
+export { VERSION };
 export { createStore } from "./core/state/createStore";
-export { createSnapshotBundle } from "./core/snapshot/createSnapshotBundle";
+export { createSnapshotBundle };
 export { defineAction } from "./core/action/defineAction";
+export { defineViewTypeTool } from "./core/action/defineViewTypeTool";
 export { createActionRuntime } from "./core/action/createActionRuntime";
 export { createToolBridge } from "./tool/createToolBridge";
 export { useDataRef } from "./ref/useDataRef";
 export { useArrayRef } from "./ref/useArrayRef";
+export { View } from "./projection/tui/View";
+export { createSnapshotAssembler } from "./projection/tui/createSnapshotAssembler";
 export { renderTUI } from "./projection/tui/renderTUI";
+export { createReactAppRuntime } from "./projection/react/createReactAppRuntime";
+export { AppRuntimeProvider } from "./projection/react/AppRuntimeProvider";
+export { useAppRuntime, useRuntimeActions, useRuntimeState, useRuntimeTrace } from "./projection/react/hooks";
+export { AppProvider } from "./projection/gui/AppProvider";
+export { useAppState, useActions } from "./projection/gui/hooks";
 export { createInboxApp } from "./demo/inbox/createInboxApp";

package/dist/projection/gui/AppProvider.d.ts

@@ -1,20 +1,16 @@
 import type { ComponentChildren } from "preact";
-type AppContextValue = {
-    store: {
-        getState(): unknown;
-    };
+import type { ActionResult, Store, ToolDefinition } from "../../core/types";
+type LegacyAppContextValue = {
+    store: Store<unknown, unknown>;
     actionRuntime: {
-        executeAction(name: string, input: Record<string, unknown>): Promise<unknown>;
-        listVisibleTools(): Array<{
-            name: string;
-            description: string;
-        }>;
+        executeAction(name: string, input: Record<string, unknown>): Promise<ActionResult>;
+        listVisibleTools(): ToolDefinition[];
     };
 };
 export declare function AppProvider(props: {
-    store: AppContextValue["store"];
-    actionRuntime: AppContextValue["actionRuntime"];
+    store: LegacyAppContextValue["store"];
+    actionRuntime: LegacyAppContextValue["actionRuntime"];
     children: ComponentChildren;
 }): import("preact").JSX.Element;
-export declare function useAppContext(): AppContextValue;
+export declare function useAppContext(): LegacyAppContextValue;
 export {};

package/dist/projection/gui/AppProvider.js

@@ -1,10 +1,85 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
 /** @jsxImportSource preact */
 import { createContext } from "preact";
-import { useContext } from "preact/hooks";
+import { useContext, useMemo } from "preact/hooks";
+import { AppRuntimeProvider } from "../react/AppRuntimeProvider";
 const AppContext = createContext(null);
+function createCompatibilityRuntime(value) {
+    let nextTraceId = 1;
+    return {
+        store: value.store,
+        actionRuntime: value.actionRuntime,
+        traceStore: {
+            getState() {
+                return {
+                    entries: [],
+                    recent: null,
+                };
+            },
+            subscribe() {
+                return () => { };
+            },
+            record(entry) {
+                return {
+                    id: `compat_trace_${nextTraceId++}`,
+                    actionName: entry.actionName,
+                    status: entry.status,
+                    summary: entry.summary,
+                    recordedAt: Date.now(),
+                };
+            },
+        },
+        trace: {
+            getState() {
+                return {
+                    entries: [],
+                    recent: null,
+                };
+            },
+            getEntries() {
+                return [];
+            },
+            getRecent() {
+                return undefined;
+            },
+            subscribe() {
+                return () => { };
+            },
+        },
+        snapshotRegistry: {
+            create(snapshot) {
+                return snapshot;
+            },
+            lookup() {
+                return undefined;
+            },
+            markStale() { },
+        },
+        toolBridge: {
+            listTools() {
+                return value.actionRuntime.listVisibleTools();
+            },
+            getSnapshotBundle() {
+                throw new Error("Snapshot rendering is not available through AppProvider");
+            },
+            executeTool(_name, _input, _snapshotId) {
+                return Promise.reject(new Error("Snapshot-scoped tool execution is not available through AppProvider"));
+            },
+        },
+        actions: {
+            callAction(name, input) {
+                return value.actionRuntime.executeAction(name, input);
+            },
+            getVisibleTools() {
+                return value.actionRuntime.listVisibleTools();
+            },
+        },
+    };
+}
 export function AppProvider(props) {
-    return (_jsx(AppContext.Provider, { value: { store: props.store, actionRuntime: props.actionRuntime }, children: props.children }));
+    const value = useMemo(() => ({ store: props.store, actionRuntime: props.actionRuntime }), [props.store, props.actionRuntime]);
+    const runtime = useMemo(() => createCompatibilityRuntime(value), [value]);
+    return (_jsx(AppContext.Provider, { value: value, children: _jsx(AppRuntimeProvider, { runtime: runtime, children: props.children }) }));
 }
 export function useAppContext() {
     const context = useContext(AppContext);

package/dist/projection/gui/hooks.d.ts

@@ -2,9 +2,6 @@ export declare function useAppState<State>(): {
     state: State;
 };
 export declare function useActions(): {
-    callAction(name: string, input: Record<string, unknown>): Promise<unknown>;
-    getVisibleTools(): {
-        name: string;
-        description: string;
-    }[];
+    callAction(name: string, input: Record<string, unknown>): Promise<import("../../core/types").ActionResult>;
+    getVisibleTools(): import("../..").ToolDefinition[];
 };

package/dist/projection/gui/hooks.js

@@ -1,18 +1,9 @@
-import { useAppContext } from "./AppProvider";
+import { useRuntimeActions, useRuntimeState } from "../react/hooks";
 export function useAppState() {
-    const { store } = useAppContext();
     return {
-        state: store.getState(),
+        state: useRuntimeState((state) => state),
     };
 }
 export function useActions() {
-    const { actionRuntime } = useAppContext();
-    return {
-        callAction(name, input) {
-            return actionRuntime.executeAction(name, input);
-        },
-        getVisibleTools() {
-            return actionRuntime.listVisibleTools();
-        },
-    };
+    return useRuntimeActions();
 }

package/dist/projection/react/AppRuntimeProvider.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from "preact";
+import type { ReactAppRuntime, RuntimeTrace } from "./createReactAppRuntime";
+export type AppRuntime<State = unknown, Event = unknown> = ReactAppRuntime<State, Event> & {
+    trace: RuntimeTrace;
+};
+export declare function AppRuntimeProvider(props: {
+    runtime: AppRuntime;
+    children: ComponentChildren;
+}): import("preact").JSX.Element;
+export declare function useAppRuntimeContext(): AppRuntime<unknown, unknown>;

package/dist/projection/react/AppRuntimeProvider.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+/** @jsxImportSource preact */
+import { createContext } from "preact";
+import { useContext } from "preact/hooks";
+const AppRuntimeContext = createContext(null);
+export function AppRuntimeProvider(props) {
+    return (_jsx(AppRuntimeContext.Provider, { value: props.runtime, children: props.children }));
+}
+export function useAppRuntimeContext() {
+    const runtime = useContext(AppRuntimeContext);
+    if (!runtime) {
+        throw new Error("AppRuntimeProvider is missing from the component tree");
+    }
+    return runtime;
+}

package/dist/projection/react/createReactAppRuntime.d.ts

@@ -0,0 +1,35 @@
+import { createActionRuntime } from "../../core/action/createActionRuntime";
+import type { ActionDefinition } from "../../core/action/defineAction";
+import type { EffectMap } from "../../core/effect/types";
+import type { ActionResult, SnapshotBundle, SnapshotRegistry, StateReducer, Store, ToolDefinition, TraceRecord, TraceState, TraceStore } from "../../core/types";
+import { createToolBridge } from "../../tool/createToolBridge";
+export type ReactAppDefinition<State, Event> = {
+    initialState: State;
+    reduce: StateReducer<State, Event>;
+    actions: Array<ActionDefinition<State, Event, any>>;
+    effects?: EffectMap<State, Event>;
+    getRelevantViewTypes?: (state: State) => readonly string[];
+    renderCurrentSnapshot?: (context: {
+        state: State;
+        visibleTools: readonly ToolDefinition[];
+    }) => SnapshotBundle;
+};
+export type ReactAppRuntime<State, Event> = {
+    store: Store<State, Event>;
+    actionRuntime: ReturnType<typeof createActionRuntime<State, Event>>;
+    traceStore: TraceStore;
+    trace: RuntimeTrace;
+    snapshotRegistry: SnapshotRegistry;
+    toolBridge: ReturnType<typeof createToolBridge>;
+    actions: {
+        callAction(name: string, input: Record<string, unknown>): Promise<ActionResult>;
+        getVisibleTools(): ToolDefinition[];
+    };
+};
+export type RuntimeTrace = {
+    getState(): TraceState;
+    getEntries(): TraceRecord[];
+    getRecent(): TraceRecord | undefined;
+    subscribe(listener: () => void): () => void;
+};
+export declare function createReactAppRuntime<State, Event>(app: ReactAppDefinition<State, Event>): ReactAppRuntime<State, Event>;

package/dist/projection/react/createReactAppRuntime.js

@@ -0,0 +1,80 @@
+import { createActionRuntime } from "../../core/action/createActionRuntime";
+import { createSnapshotRegistry } from "../../core/snapshot/createSnapshotRegistry";
+import { createStore } from "../../core/state/createStore";
+import { createTraceStore } from "../../core/trace/createTraceStore";
+import { createSnapshotAssembler } from "../tui/createSnapshotAssembler";
+import { renderViewFragment } from "../tui/renderViewFragment";
+import { createToolBridge } from "../../tool/createToolBridge";
+export function createReactAppRuntime(app) {
+    const store = createStore({
+        initialState: app.initialState,
+        reduce: app.reduce,
+    });
+    const traceStore = createTraceStore();
+    const getRelevantViewTypes = app.getRelevantViewTypes;
+    const actionRuntime = createActionRuntime({
+        store,
+        actions: app.actions,
+        traceStore,
+        effects: app.effects,
+        getRelevantViewTypes: getRelevantViewTypes
+            ? () => getRelevantViewTypes(store.getState())
+            : undefined,
+    });
+    const snapshotRegistry = createSnapshotRegistry({ maxEntries: 2 });
+    const renderCurrentSnapshot = app.renderCurrentSnapshot ??
+        (() => createSnapshotAssembler({
+            rootView: renderViewFragment({
+                id: "root",
+                type: "Root",
+                name: "Navigation",
+                children: "No custom snapshot renderer configured.",
+            }),
+            mountedViews: [],
+            refIndex: {},
+            visibleTools: actionRuntime.listVisibleTools(),
+        }));
+    const toolBridge = createToolBridge({
+        actionRuntime,
+        snapshotRegistry,
+        renderCurrentSnapshot() {
+            return renderCurrentSnapshot({
+                state: store.getState(),
+                visibleTools: actionRuntime.listVisibleTools(),
+            });
+        },
+    });
+    return {
+        store,
+        actionRuntime,
+        traceStore,
+        trace: {
+            getState() {
+                return traceStore.getState();
+            },
+            getEntries() {
+                return traceStore.getState().entries;
+            },
+            getRecent() {
+                return traceStore.getState().recent ?? undefined;
+            },
+            subscribe(listener) {
+                return traceStore.subscribe(listener);
+            },
+        },
+        snapshotRegistry,
+        toolBridge,
+        actions: {
+            async callAction(name, input) {
+                const result = await actionRuntime.executeAction(name, input);
+                if (result.mutated) {
+                    snapshotRegistry.markAllStale?.();
+                }
+                return result;
+            },
+            getVisibleTools() {
+                return actionRuntime.listVisibleTools();
+            },
+        },
+    };
+}

package/dist/projection/react/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { TraceState } from "../../core/types";
+export declare function useAppRuntime(): import("./AppRuntimeProvider").AppRuntime<unknown, unknown>;
+export declare function useRuntimeState<State, Selected>(selector: (state: State) => Selected): Selected;
+export declare function useRuntimeActions(): {
+    callAction(name: string, input: Record<string, unknown>): Promise<import("../../core/types").ActionResult>;
+    getVisibleTools(): import("../..").ToolDefinition[];
+};
+export declare function useRuntimeTrace<Selected>(selector: (trace: TraceState) => Selected): Selected;

package/dist/projection/react/hooks.js

@@ -0,0 +1,18 @@
+import { useSyncExternalStore } from "preact/compat";
+import { useAppRuntimeContext } from "./AppRuntimeProvider";
+export function useAppRuntime() {
+    return useAppRuntimeContext();
+}
+export function useRuntimeState(selector) {
+    const runtime = useAppRuntimeContext();
+    const getSnapshot = () => selector(runtime.store.getState());
+    return useSyncExternalStore(runtime.store.subscribe, getSnapshot);
+}
+export function useRuntimeActions() {
+    return useAppRuntimeContext().actions;
+}
+export function useRuntimeTrace(selector) {
+    const runtime = useAppRuntimeContext();
+    const getSnapshot = () => selector(runtime.traceStore.getState());
+    return useSyncExternalStore(runtime.traceStore.subscribe, getSnapshot);
+}

package/dist/projection/tui/View.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentChildren, JSX } from "preact";
+export type ViewProps = {
+    readonly id: string;
+    readonly type: string;
+    readonly name: string;
+    readonly children?: ComponentChildren;
+} & JSX.HTMLAttributes<HTMLElement>;
+export declare function View(props: ViewProps): JSX.Element;

package/dist/projection/tui/View.js

@@ -0,0 +1,5 @@
+import { h } from "preact";
+export function View(props) {
+    const { children, ...rest } = props;
+    return h("View", rest, children);
+}

package/dist/projection/tui/createSnapshotAssembler.d.ts

@@ -0,0 +1,2 @@
+import type { SnapshotAssemblerInput, SnapshotBundle } from "../../core/types";
+export declare function createSnapshotAssembler<State>(input: SnapshotAssemblerInput<State>): SnapshotBundle;

package/dist/projection/tui/createSnapshotAssembler.js

@@ -0,0 +1,14 @@
+import { createSnapshotBundle } from "../../core/snapshot/createSnapshotBundle";
+import { renderSnapshotDocument } from "./renderSnapshotDocument";
+export function createSnapshotAssembler(input) {
+    const views = [input.rootView, ...input.mountedViews];
+    const markup = renderSnapshotDocument(views);
+    const bundleInput = {
+        markup,
+        views,
+        refIndex: input.refIndex,
+        visibleTools: input.visibleTools,
+        ...(input.tui === undefined ? {} : { tui: input.tui }),
+    };
+    return createSnapshotBundle(bundleInput);
+}

package/dist/projection/tui/renderSnapshotDocument.d.ts

@@ -0,0 +1,2 @@
+import type { ViewFragment } from "../../core/types";
+export declare function renderSnapshotDocument(views: readonly ViewFragment[]): string;

package/dist/projection/tui/renderSnapshotDocument.js

@@ -0,0 +1,3 @@
+export function renderSnapshotDocument(views) {
+    return views.map((view) => view.markup).join("");
+}

package/dist/projection/tui/renderTUI.d.ts

@@ -3,4 +3,4 @@ import type { ComponentChild } from "preact";
 import type { ToolDefinition } from "../../core/types";
 export declare function renderTUI(node: ComponentChild, options: {
     visibleTools: ToolDefinition[];
-}): import("../../core/types").SnapshotBundle;
+}): import("../..").SnapshotBundle;

package/dist/projection/tui/renderTUI.js

@@ -1,13 +1,22 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
 import renderToString from "preact-render-to-string";
 import { createRefCollector } from "../../core/ref/ref-index";
-import { createSnapshotBundle } from "../../core/snapshot/createSnapshotBundle";
 import { RefProvider } from "../../ref/RefContext";
+import { renderViewFragment } from "./renderViewFragment";
+import { createSnapshotAssembler } from "./createSnapshotAssembler";
 export function renderTUI(node, options) {
     const collector = createRefCollector();
-    const tui = renderToString(_jsx(RefProvider, { registry: collector, children: node }));
-    return createSnapshotBundle({
-        tui,
+    const renderedNode = _jsx(RefProvider, { registry: collector, children: node });
+    const markup = renderToString(renderedNode);
+    const rootView = renderViewFragment({
+        id: "root",
+        type: "Root",
+        name: "Root",
+        markup,
+    });
+    return createSnapshotAssembler({
+        rootView,
+        mountedViews: [],
         refIndex: collector.snapshot(),
         visibleTools: options.visibleTools,
     });