@hosty-sdk/app 0.26.0 → 0.27.23

package/dist/ui-frame.d.ts

@@ -1,4 +1,5 @@
 import { type HostyResolvedTheme, type HostyThemePreference } from "./theme.js";
+import type { UiViewDescriptor } from "./ui-workspaces.js";
 import type { UiFrameSurface } from "./ui-types.js";
 export declare function parseFrameMcpReview(event: {
     source: unknown;
@@ -10,6 +11,7 @@ export declare function parseFrameMcpReview(event: {
 } | null;
 export declare function frameSandbox(policy: UiFrameSurface["framePolicy"]): string;
 export type HostyAppFrameProps = {
+    view?: UiViewDescriptor;
     surface: UiFrameSurface;
     title: string;
     src?: string;

package/dist/ui-frame.js

@@ -5,6 +5,8 @@ import { UiHostContext } from "./ui-context.js";
 import { appendThemeLaunchParams, parseActiveFrameAskAssistant, parseActiveFrameAttention, parseActiveFrameAuthRequired, parseActiveFramePermissionReview } from "./embedder.js";
 import { createShellThemeMessage } from "./theme.js";
 import { permissionReviewUrl } from "./permissions.js";
+import { withChromeHints } from "./ui-composition.js";
+import { createPresentationRequestId } from "./ui.js";
 export function parseFrameMcpReview(event, frame, src, appId) {
     if (!frame || event.source !== frame || !event.data || typeof event.data !== "object")
         return null;
@@ -24,7 +26,11 @@ export function frameSandbox(policy) {
 }
 /** Shared frame coordinator. No delegated-token responder and no authority inferred from messages. */
 export function HostyAppFrame(props) {
-    const { surface, title, className, standaloneHref, theme, themePreference } = props;
+    const { title, className, standaloneHref, theme, themePreference } = props;
+    const inputId = JSON.stringify([props.surface, props.src]);
+    const [destination, setDestination] = useState(null);
+    const surface = destination?.inputId === inputId ? destination.surface : props.surface;
+    const [defaultViewId] = useState(createPresentationRequestId);
     const host = useContext(UiHostContext);
     const ref = useRef(null);
     const callbacks = useRef(props);
@@ -47,20 +53,44 @@ export function HostyAppFrame(props) {
         return () => observer.disconnect();
     }, []);
     const resolvedTheme = theme ?? appearance.theme, preference = themePreference ?? appearance.preference;
-    const source = props.src ?? new URL(surface.route, surface.origin).href;
+    const source = destination?.inputId === inputId ? new URL(surface.route, surface.origin).href
+        : props.src ?? new URL(surface.route, surface.origin).href;
     // Theme changes are messages; they must not replace a document with an unsent draft.
-    const [launch] = useState(() => {
+    const [launch, setLaunch] = useState(() => {
         const url = new URL(source);
         url.searchParams.set("hosty_launch", "embedded");
-        return appendThemeLaunchParams(url.href, resolvedTheme, preference);
+        return appendThemeLaunchParams(withChromeHints(url.href, host?.getViewChrome?.(props.view?.viewId ?? defaultViewId)
+            ?? props.view?.chrome ?? { navigation: "hide", tools: { launcher: "hide" } }), resolvedTheme, preference);
     });
     const frameId = JSON.stringify([surface, source]);
     useLayoutEffect(() => {
         const frame = ref.current;
         if (!frame || !host)
             return;
-        return host.registerFrame(frame, surface, ready => setConnection(current => ({ ready, generation: current.generation + (ready ? 1 : 0) })));
-    }, [host, frameId]); // Caller keys the frame by this immutable surface.
+        const view = callbacks.current.view;
+        return host.registerFrame(frame, surface, ready => setConnection(current => ({ ready, generation: current.generation + (ready ? 1 : 0) })), { viewId: defaultViewId, workspaceId: "default", chrome: { navigation: "hide", tools: { launcher: "hide" } }, ...view,
+            navigate: next => {
+                const current = callbacks.current;
+                if (current.view?.navigate)
+                    return current.view.navigate(next);
+                // Replace the document through React so every message handler follows its verified origin.
+                const url = new URL(next.route, next.origin);
+                url.searchParams.set("hosty_launch", "embedded");
+                setLoaded(false);
+                setReview(null);
+                setDestination({ inputId: JSON.stringify([current.surface, current.src]), surface: { ...next, panelId: surface.panelId } });
+                setLaunch(appendThemeLaunchParams(withChromeHints(url.href, host.getViewChrome(current.view?.viewId ?? defaultViewId)
+                    ?? current.view?.chrome ?? { navigation: "hide", tools: { launcher: "hide" } }), resolvedTheme, preference));
+            } });
+    }, [host, frameId]);
+    const policy = JSON.stringify(props.view?.chrome ?? {});
+    const previousPolicy = useRef({ viewId: props.view?.viewId, policy });
+    useEffect(() => {
+        const previous = previousPolicy.current;
+        previousPolicy.current = { viewId: props.view?.viewId, policy };
+        if (host && props.view && ref.current && previous.viewId === props.view.viewId && previous.policy !== policy)
+            host.setViewChrome(props.view.viewId, JSON.parse(policy));
+    }, [host, props.view?.viewId, policy]);
     useEffect(() => {
         if (loaded)
             ref.current?.contentWindow?.postMessage(createShellThemeMessage(resolvedTheme, preference), surface.origin);
@@ -93,9 +123,15 @@ export function HostyAppFrame(props) {
         return () => window.removeEventListener("message", handle);
     }, [host, frameId, source, surface]);
     const outboundReady = host ? connection.ready : loaded;
+    const sent = useRef(null);
     useEffect(() => {
-        if (outboundReady && props.outbound)
+        if (outboundReady && props.outbound) {
+            const key = `${connection.generation}:${props.outbound.nonce}`;
+            if (sent.current === key)
+                return;
             ref.current?.contentWindow?.postMessage(props.outbound.message, surface.origin);
+            sent.current = key;
+        }
     }, [outboundReady, connection.generation, props.outbound?.nonce, surface.origin]);
     const insecure = typeof window !== "undefined" && window.location.protocol === "https:" && new URL(surface.origin).protocol === "http:";
     if (insecure)

package/dist/ui-host.d.ts

@@ -1,17 +1,20 @@
+import { UiCompositionModel } from "./ui-composition.js";
+import { type UiPresentation, type UiWorkspaceSnapshot, type UiWorkspaceRenderer, type UiViewDescriptor, type UiPlacementResolver } from "./ui-workspaces.js";
+export type { UiWorkspaceRenderer, UiViewDescriptor, UiPlacementResolver, UiPresentation } from "./ui-workspaces.js";
+import { type UiChromeOverrides, type UiActionOptions, type UiActionResult } from "./ui-types.js";
 import { type UiClient } from "./ui.js";
-import { type PanelRef, type PanelTarget, type PresentationOptions, type PresentationResult, type UiBootstrap, type UiEnvironment, type UiEvent, type UiFrameSurface, type UiPanel, type UiResolvedPanel, type SurfaceReadiness } from "./ui-types.js";
-export type UiTool = {
-    key: string;
-    target: PanelTarget;
-    resolved: UiResolvedPanel;
-    readiness: SurfaceReadiness;
-    attention: number;
+import { type PanelRef, type PanelTarget, type PresentationOptions, type PresentationResult, type UiBootstrap, type UiEnvironment, type UiEvent, type UiFrameSurface, type UiPanel } from "./ui-types.js";
+export type UiTool = UiPresentation & {
+    panelSurface: UiFrameSurface;
+    navigationRoot?: string;
 };
 export type UiHostSnapshot = {
     bootstrap: UiBootstrap | null;
     catalog: UiPanel[];
     tools: UiTool[];
     selected: PanelRef | null;
+    selectedPresentationId?: string | null;
+    workspaces?: UiWorkspaceSnapshot[];
     expanded: boolean;
     width: number;
     error: {
@@ -23,6 +26,7 @@ export type UiHostSnapshot = {
 export declare function createUiHost(options?: {
     uiPath?: string;
     active?: boolean;
+    chrome?: UiChromeOverrides;
 }): UiHost;
 export declare class UiHost implements UiClient {
     private readonly path;
@@ -33,48 +37,91 @@ export declare class UiHost implements UiClient {
     private readonly listeners;
     private readonly events;
     private readonly frames;
+    private readonly viewChrome;
     private readonly ledger;
     private readonly toolQueues;
-    private selectionGeneration;
+    private readonly moves;
+    private readonly rendererWork;
+    readonly composition: UiCompositionModel;
+    private readonly workspaces;
+    private placement?;
+    private readonly actions;
+    private focusSequence;
     private activityGeneration;
     private activityReady;
     private disposed;
-    private workspace;
     private refreshing;
     private readonly onMessage;
     private readonly onFocus;
-    constructor(path: string, active?: boolean);
+    constructor(path: string, active?: boolean, chrome?: UiChromeOverrides);
     getEnvironment: () => UiEnvironment;
+    getChrome: () => import("./ui-types").UiChromeSnapshot;
+    subscribeChrome: (listener: () => void) => () => void;
+    getNavigation: () => Readonly<{
+        status: "loading" | "ready" | "unavailable";
+        catalog: import("./ui-types").UiNavigationCatalog | null;
+        entries: readonly import("./ui-types").UiNavigationEntry[];
+        activeKey: string | null;
+        code?: string;
+    }>;
+    subscribeNavigation: (listener: () => void) => () => void;
     setActive(active: boolean): void;
     private checkActivity;
     claimWorkspace: (owner: object) => () => void;
+    registerWorkspace: ({ workspaceId, renderer }: {
+        workspaceId: string;
+        renderer: UiWorkspaceRenderer;
+    }) => () => void;
+    private publishWorkspaces;
+    setPlacementResolver: (resolver?: UiPlacementResolver) => void;
+    getViewChrome: (viewId: string) => UiChromeOverrides | undefined;
+    setViewChrome: (viewId: string, overrides: UiChromeOverrides) => void;
+    private publishPolicy;
+    private requireTools;
+    focusPresentation: (id: string) => boolean;
+    collapseWorkspace: (id: string) => void;
+    closePresentation: (id: string) => void;
+    private releasePresentation;
+    private resetPresentations;
+    movePresentation: (id: string, workspaceId: string) => Promise<boolean>;
     getSnapshot: () => UiHostSnapshot;
     subscribeSnapshot: (listener: () => void) => () => void;
     subscribe: (listener: (event: UiEvent) => void) => () => void;
     private emit;
     private update;
+    private invalidateRendererWork;
+    private runRenderer;
     private setEnvironment;
     private bootstrap;
     refresh: () => Promise<void>;
     openSurface: (target: PanelTarget, options: PresentationOptions) => Promise<PresentationResult>;
     private open;
+    private pendingCount;
+    private trimLedger;
+    private peerResult;
+    private action;
+    navigate: (entryKey: string, options: UiActionOptions) => Promise<UiActionResult>;
+    openToolPicker: (options: UiActionOptions) => Promise<UiActionResult>;
+    private pickTools;
+    private navigateFrame;
     getPresentation: (id: string, options?: {
         signal?: AbortSignal;
     }) => Promise<PresentationResult>;
     private status;
-    selectPanel: (ref: PanelRef) => Promise<PresentationResult>;
-    setExpanded: (expanded: boolean) => void;
-    setWidth: (width: number) => void;
-    setAttention: (panel: PanelRef, attention: number) => void;
+    selectPanel: (ref: PanelRef, workspaceId?: string) => Promise<PresentationResult>;
+    setExpanded: (expanded: boolean, workspaceId?: string) => void;
+    setWidth: (width: number, workspaceId?: string) => void;
+    setAttention: (panel: PanelRef | string, attention: number) => void;
     reportSurfaceState: (_state: {
         route: string;
         state: "ready" | "blocked";
         code?: string;
     }) => void;
     private forgetFrameRequests;
-    registerFrame: (element: HTMLIFrameElement, surface: UiFrameSurface, onConnection?: (connected: boolean) => void) => (() => void);
+    registerFrame: (element: HTMLIFrameElement, surface: UiFrameSurface, onConnection?: (connected: boolean) => void, view?: UiViewDescriptor) => (() => void);
     private post;
     private reportFrame;
+    private reportRoute;
     private receive;
     dispose: () => void;
 }