akanjs 3.0.2 → 3.1.0-rc.0

package/types/ui/Portal.d.ts

@@ -2,6 +2,8 @@ import { type ReactNode } from "react";
 interface PortalProps {
     children: ReactNode;
     id: string;
+    /** Drawn in place until the target is found: on the server, and in the first client render that hydrates it. */
+    fallback?: ReactNode;
 }
-export declare const Portal: ({ children, id }: PortalProps) => import("react").ReactPortal | null;
+export declare const Portal: ({ children, id, fallback }: PortalProps) => string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
 export {};

package/types/ui/Reference/origin.d.ts

@@ -0,0 +1,12 @@
+export declare const ownerOf: (origin: string[] | undefined) => string | undefined;
+/**
+ * Owners in dependency order, the app first, from origin chains listed in registration order. A lib's modules
+ * register before those of whatever builds on it, so the order in which each owner first registers a module of its
+ * own, reversed, puts dependents ahead of dependencies; an owner that only extends others' modules comes first.
+ */
+export declare const ownerOrderOf: (origins: (string[] | undefined)[]) => string[];
+export declare const originText: (origin: string[]) => {
+    en: string;
+    ko: string;
+};
+export declare const groupByOwner: <Item>(items: Item[], originOf: (item: Item) => string[] | undefined, order: string[]) => [string, Item[]][];

package/types/ui/Signal/Doc.d.ts

@@ -1,31 +1,36 @@
 import { type FetchProxy } from "akanjs/fetch";
 import { type ReactNode } from "react";
-declare function Doc(): import("react").JSX.Element;
-declare namespace Doc {
-    var Setting: ({ fetch, search, onSearch }: DocSettingProps) => import("react").JSX.Element;
-    var AuthModal: ({ children }: DocAuthModalProps) => import("react").JSX.Element;
-    var DocSignals: ({ fetch }: DocSignalsProps) => import("react").JSX.Element;
-    var DocSignal: ({ refName, fetch }: DocSignalProps) => import("react").JSX.Element;
-    var Zone: ({ refName, fetch, openAll }: ZoneProps) => import("react").JSX.Element;
-}
-export default Doc;
-interface DocSettingProps {
-    fetch: FetchProxy;
+import { type SignalScope } from "./endpointEntries.d.ts";
+export interface DocSettingProps {
+    fetch?: FetchProxy;
     search?: string;
     onSearch?: (search: string) => void;
 }
-interface DocAuthModalProps {
+export declare const DocSetting: ({ fetch, search, onSearch }: DocSettingProps) => import("react").JSX.Element;
+export interface DocAuthModalProps {
     children: ReactNode;
 }
-interface DocSignalsProps {
-    fetch: FetchProxy;
+export declare const DocAuthModal: ({ children }: DocAuthModalProps) => import("react").JSX.Element;
+export interface DocSignalsProps extends SignalScope {
+    fetch?: FetchProxy;
 }
-interface DocSignalProps {
+export declare const DocSignals: ({ fetch, include, exclude, libs }: DocSignalsProps) => import("react").JSX.Element;
+export interface DocSignalProps {
     refName: string;
-    fetch: FetchProxy;
+    fetch?: FetchProxy;
 }
-interface ZoneProps {
+export declare const DocSignal: ({ refName, fetch }: DocSignalProps) => import("react").JSX.Element;
+export interface ZoneProps {
     refName: string;
-    fetch: FetchProxy;
+    fetch?: FetchProxy;
+    openAll?: boolean;
+}
+export declare const Zone: ({ refName, fetch, openAll }: ZoneProps) => import("react").JSX.Element;
+export interface ExplorerProps extends SignalScope {
+    className?: string;
+    fetch?: FetchProxy;
+    defaultRefName?: string;
     openAll?: boolean;
+    groupBy?: "lib";
 }
+export declare const Explorer: ({ className, fetch, include, exclude, libs, defaultRefName, openAll, groupBy, }: ExplorerProps) => import("react").JSX.Element;

package/types/ui/Signal/Listener.d.ts

@@ -1,9 +1,5 @@
-declare function Listener(): import("react").JSX.Element;
-declare namespace Listener {
-    var Result: ({ status, data }: ListenerResultProps) => import("react").JSX.Element;
-}
-export default Listener;
-interface ListenerResultProps {
+export interface ListenerResultProps {
     status: "ready" | "loading" | "error" | "listening";
     data: unknown;
 }
+export declare const ListenerResult: ({ status, data }: ListenerResultProps) => import("react").JSX.Element;

package/types/ui/Signal/Object.d.ts

@@ -1,21 +1,17 @@
 import { type Cls } from "akanjs/base";
 import { type ConstantCls } from "akanjs/constant";
-declare function Object(): import("react").JSX.Element;
-declare namespace Object {
-    var Type: ({ objRef, arrDepth, nullable }: ObjectTypeProps) => import("react").JSX.Element;
-    var Detail: ({ className, objRef }: ObjectDetailProps) => import("react").JSX.Element;
-    var Schema: ({ objRef }: ObjectSchemaProps) => import("react").JSX.Element;
-}
-export default Object;
-interface ObjectTypeProps {
+export interface ObjectTypeProps {
     objRef: Cls;
     arrDepth: number;
     nullable?: boolean;
 }
-interface ObjectDetailProps {
+export declare const ObjectType: ({ objRef, arrDepth, nullable }: ObjectTypeProps) => import("react").JSX.Element;
+export interface ObjectDetailProps {
     className?: string;
     objRef: ConstantCls;
 }
-interface ObjectSchemaProps {
+export declare const ObjectDetail: ({ className, objRef }: ObjectDetailProps) => import("react").JSX.Element;
+export interface ObjectSchemaProps {
     objRef: Cls;
 }
+export declare const ObjectSchema: ({ objRef }: ObjectSchemaProps) => import("react").JSX.Element;

package/types/ui/Signal/Response.d.ts

@@ -1,14 +1,11 @@
 import type { SerializedEndpoint } from "akanjs/signal";
-declare function Response(): import("react").JSX.Element;
-declare namespace Response {
-    var Example: ({ endpoint }: ResponseExampleProps) => import("react").JSX.Element;
-    var Result: ({ status, data }: ResponseResultProps) => import("react").JSX.Element;
-}
-export default Response;
 interface ResponseExampleProps {
     endpoint: SerializedEndpoint;
 }
+export declare const ResponseExample: ({ endpoint }: ResponseExampleProps) => import("react").JSX.Element;
 interface ResponseResultProps {
     status: "idle" | "loading" | "success" | "error";
     data: unknown;
 }
+export declare const ResponseResult: ({ status, data }: ResponseResultProps) => import("react").JSX.Element;
+export {};

package/types/ui/Signal/RestApi.d.ts

@@ -1,41 +1,37 @@
 import { type FetchProxy } from "akanjs/fetch";
 import type { SerializedEndpoint } from "akanjs/signal";
-declare function RestApi(): import("react").JSX.Element;
-declare namespace RestApi {
-    var Endpoints: ({ refName, fetch, prefix, endpoints, openAll, httpUri, search }: RestApiEndpointsProps) => import("react").JSX.Element;
-    var Endpoint: ({ refName, fetch, signalPrefix, endpointKey, endpoint, open, httpUri, }: RestApiEndpointProps) => import("react").JSX.Element;
-    var Interface: ({ refName, endpointKey, endpoint }: RestApiInterfaceProps) => import("react").JSX.Element;
-    var Try: ({ signalPrefix, refName, endpointKey, endpoint, fetch, httpUri }: RestApiTryProps) => import("react").JSX.Element;
-}
-export default RestApi;
-interface RestApiEndpointsProps {
+export interface RestApiEndpointsProps {
     refName: string;
-    fetch: FetchProxy;
+    fetch?: FetchProxy;
     prefix?: string;
     endpoints?: string[];
     openAll?: boolean;
     httpUri?: string;
     search?: string;
 }
-interface RestApiEndpointProps {
+export declare const RestApiEndpoints: ({ refName, fetch, prefix, endpoints, openAll, httpUri, search, }: RestApiEndpointsProps) => import("react").JSX.Element;
+export interface RestApiEndpointProps {
     refName: string;
-    fetch: FetchProxy;
+    fetch?: FetchProxy;
     signalPrefix?: string;
     endpointKey: string;
     endpoint: SerializedEndpoint;
     open?: boolean;
     httpUri?: string;
 }
-interface RestApiInterfaceProps {
+export declare const RestApiEndpoint: ({ refName, fetch, signalPrefix, endpointKey, endpoint, open, httpUri, }: RestApiEndpointProps) => import("react").JSX.Element;
+export interface RestApiInterfaceProps {
     refName: string;
     endpointKey: string;
     endpoint: SerializedEndpoint;
 }
-interface RestApiTryProps {
+export declare const RestApiInterface: ({ refName, endpointKey, endpoint }: RestApiInterfaceProps) => import("react").JSX.Element;
+export interface RestApiTryProps {
     signalPrefix?: string;
     refName: string;
     endpointKey: string;
     endpoint: SerializedEndpoint;
-    fetch: FetchProxy;
+    fetch?: FetchProxy;
     httpUri?: string;
 }
+export declare const RestApiTry: ({ signalPrefix, refName, endpointKey, endpoint, fetch, httpUri, }: RestApiTryProps) => import("react").JSX.Element;

package/types/ui/Signal/WebSocket.d.ts

@@ -1,35 +1,25 @@
 import type { FetchProxy } from "akanjs/fetch";
 import type { SerializedEndpoint } from "akanjs/signal";
 import { type WsEndpointProps } from "./Endpoint.d.ts";
-declare function WebSocket(): import("react").JSX.Element;
-declare namespace WebSocket {
-    var Endpoints: ({ refName, fetch, openAll, search }: WebSocketEndpointsProps) => import("react").JSX.Element;
-}
-export default WebSocket;
-export declare function Message(): import("react").JSX.Element;
-export declare namespace Message {
-    var Endpoint: ({ refName, endpointKey, endpoint, open }: WsEndpointProps) => import("react").JSX.Element;
-    var Interface: ({ refName, endpointKey, endpoint }: WsInterfaceProps) => import("react").JSX.Element;
-    var Try: ({ endpointKey, endpoint }: MessageTryProps) => import("react").JSX.Element;
-}
-export declare function PubSub(): import("react").JSX.Element;
-export declare namespace PubSub {
-    var Endpoint: ({ refName, endpointKey, endpoint, open }: WsEndpointProps) => import("react").JSX.Element;
-    var Interface: ({ refName, endpointKey, endpoint }: WsInterfaceProps) => import("react").JSX.Element;
-    var Try: ({ refName, endpointKey, endpoint }: WsInterfaceProps) => import("react").JSX.Element;
-}
-interface WebSocketEndpointsProps {
+export interface WebSocketEndpointsProps {
     refName: string;
-    fetch: FetchProxy;
+    fetch?: FetchProxy;
     openAll?: boolean;
     search?: string;
 }
-interface WsInterfaceProps {
+export declare const WebSocketEndpoints: ({ refName, fetch: docFetch, openAll, search, }: WebSocketEndpointsProps) => import("react").JSX.Element;
+export declare const MessageEndpoint: ({ refName, endpointKey, endpoint, open }: WsEndpointProps) => import("react").JSX.Element;
+export interface WsInterfaceProps {
     refName: string;
     endpointKey: string;
     endpoint: SerializedEndpoint;
 }
-interface MessageTryProps {
+export declare const MessageInterface: ({ refName, endpointKey, endpoint }: WsInterfaceProps) => import("react").JSX.Element;
+export interface MessageTryProps {
     endpointKey: string;
     endpoint: SerializedEndpoint;
 }
+export declare const MessageTry: ({ endpointKey, endpoint }: MessageTryProps) => import("react").JSX.Element;
+export declare const PubSubEndpoint: ({ refName, endpointKey, endpoint, open }: WsEndpointProps) => import("react").JSX.Element;
+export declare const PubSubInterface: ({ refName, endpointKey, endpoint }: WsInterfaceProps) => import("react").JSX.Element;
+export declare const PubSubTry: ({ endpointKey, endpoint }: WsInterfaceProps) => import("react").JSX.Element;

package/types/ui/Signal/endpointEntries.d.ts

@@ -1,5 +1,13 @@
 import { type FetchProxy } from "akanjs/fetch";
 import type { SerializedEndpoint } from "akanjs/signal";
+export declare const runtimeFetch: FetchProxy;
+export interface SignalScope {
+    include?: string[];
+    exclude?: string[];
+    libs?: string[];
+}
+export declare const signalRefNamesOf: (fetch: FetchProxy, { include, exclude, libs }?: SignalScope) => string[];
+export declare const signalOwnerOrderOf: (fetch: FetchProxy) => string[];
 export interface EndpointEntry {
     key: string;
     endpoint: SerializedEndpoint;

package/types/ui/Signal/index.d.ts

@@ -1,16 +1,39 @@
 import Arg from "./Arg.d.ts";
-import Doc from "./Doc.d.ts";
-import Listener from "./Listener.d.ts";
-import Object from "./Object.d.ts";
-import RestApi from "./RestApi.d.ts";
-import WebSocket, { Message, PubSub } from "./WebSocket.d.ts";
 export declare const Signal: {
-    Doc: typeof Doc;
-    Object: typeof Object;
-    RestApi: typeof RestApi;
+    Doc: {
+        Zone: ({ refName, fetch, openAll }: import("./Doc.d.ts").ZoneProps) => import("react").JSX.Element;
+        Explorer: ({ className, fetch, include, exclude, libs, defaultRefName, openAll, groupBy, }: import("./Doc.d.ts").ExplorerProps) => import("react").JSX.Element;
+        Setting: ({ fetch, search, onSearch }: import("./Doc.d.ts").DocSettingProps) => import("react").JSX.Element;
+        AuthModal: ({ children }: import("./Doc.d.ts").DocAuthModalProps) => import("react").JSX.Element;
+        DocSignals: ({ fetch, include, exclude, libs }: import("./Doc.d.ts").DocSignalsProps) => import("react").JSX.Element;
+        DocSignal: ({ refName, fetch }: import("./Doc.d.ts").DocSignalProps) => import("react").JSX.Element;
+    };
+    Object: {
+        Type: ({ objRef, arrDepth, nullable }: import("./Object.d.ts").ObjectTypeProps) => import("react").JSX.Element;
+        Detail: ({ className, objRef }: import("./Object.d.ts").ObjectDetailProps) => import("react").JSX.Element;
+        Schema: ({ objRef }: import("./Object.d.ts").ObjectSchemaProps) => import("react").JSX.Element;
+    };
+    RestApi: {
+        Endpoints: ({ refName, fetch, prefix, endpoints, openAll, httpUri, search, }: import("./RestApi.d.ts").RestApiEndpointsProps) => import("react").JSX.Element;
+        Endpoint: ({ refName, fetch, signalPrefix, endpointKey, endpoint, open, httpUri, }: import("./RestApi.d.ts").RestApiEndpointProps) => import("react").JSX.Element;
+        Interface: ({ refName, endpointKey, endpoint }: import("./RestApi.d.ts").RestApiInterfaceProps) => import("react").JSX.Element;
+        Try: ({ signalPrefix, refName, endpointKey, endpoint, fetch, httpUri, }: import("./RestApi.d.ts").RestApiTryProps) => import("react").JSX.Element;
+    };
     Arg: typeof Arg;
-    Listener: typeof Listener;
-    WebSocket: typeof WebSocket;
-    PubSub: typeof PubSub;
-    Message: typeof Message;
+    Listener: {
+        Result: ({ status, data }: import("./Listener.d.ts").ListenerResultProps) => import("react").JSX.Element;
+    };
+    WebSocket: {
+        Endpoints: ({ refName, fetch: docFetch, openAll, search, }: import("./WebSocket.d.ts").WebSocketEndpointsProps) => import("react").JSX.Element;
+    };
+    PubSub: {
+        Endpoint: ({ refName, endpointKey, endpoint, open }: import("./Endpoint.d.ts").WsEndpointProps) => import("react").JSX.Element;
+        Interface: ({ refName, endpointKey, endpoint }: import("./WebSocket.d.ts").WsInterfaceProps) => import("react").JSX.Element;
+        Try: ({ endpointKey, endpoint }: import("./WebSocket.d.ts").WsInterfaceProps) => import("react").JSX.Element;
+    };
+    Message: {
+        Endpoint: ({ refName, endpointKey, endpoint, open }: import("./Endpoint.d.ts").WsEndpointProps) => import("react").JSX.Element;
+        Interface: ({ refName, endpointKey, endpoint }: import("./WebSocket.d.ts").WsInterfaceProps) => import("react").JSX.Element;
+        Try: ({ endpointKey, endpoint }: import("./WebSocket.d.ts").MessageTryProps) => import("react").JSX.Element;
+    };
 };

package/types/ui/Signal/signalText.d.ts

@@ -0,0 +1,178 @@
+export declare const signalText: {
+    readonly signal: {
+        readonly en: "Signal";
+        readonly ko: "시그널";
+    };
+    readonly endpoints: {
+        readonly en: "Endpoints";
+        readonly ko: "엔드포인트";
+    };
+    readonly restApi: {
+        readonly en: "REST API";
+        readonly ko: "REST API";
+    };
+    readonly webSocket: {
+        readonly en: "Web Socket";
+        readonly ko: "웹소켓";
+    };
+    readonly mcpTools: {
+        readonly en: "MCP Tools";
+        readonly ko: "MCP 도구";
+    };
+    readonly baseUrl: {
+        readonly en: "Base URL";
+        readonly ko: "기본 URL";
+    };
+    readonly guards: {
+        readonly en: "Guards";
+        readonly ko: "가드";
+    };
+    readonly allGuards: {
+        readonly en: "All guards";
+        readonly ko: "모든 가드";
+    };
+    readonly auth: {
+        readonly en: "Auth";
+        readonly ko: "인증";
+    };
+    readonly authorized: {
+        readonly en: "Authorized";
+        readonly ko: "인증됨";
+    };
+    readonly anonymous: {
+        readonly en: "Anonymous";
+        readonly ko: "익명";
+    };
+    readonly searchEndpoints: {
+        readonly en: "Search endpoints";
+        readonly ko: "엔드포인트 검색";
+    };
+    readonly setJwtTitle: {
+        readonly en: "Set JWT for Authorization";
+        readonly ko: "인증용 JWT 설정";
+    };
+    readonly setAuthorization: {
+        readonly en: "Set Authorization";
+        readonly ko: "인증 설정";
+    };
+    readonly bearerToken: {
+        readonly en: "Bearer token";
+        readonly ko: "Bearer 토큰";
+    };
+    readonly accountDecoded: {
+        readonly en: "Account decoded";
+        readonly ko: "디코딩된 계정";
+    };
+    readonly reference: {
+        readonly en: "Reference";
+        readonly ko: "명세";
+    };
+    readonly tryIt: {
+        readonly en: "Try it";
+        readonly ko: "실행해 보기";
+    };
+    readonly formData: {
+        readonly en: "Form data";
+        readonly ko: "폼 데이터";
+    };
+    readonly pathParameters: {
+        readonly en: "Path parameters";
+        readonly ko: "경로 파라미터";
+    };
+    readonly query: {
+        readonly en: "Query";
+        readonly ko: "쿼리";
+    };
+    readonly body: {
+        readonly en: "Body";
+        readonly ko: "본문";
+    };
+    readonly variables: {
+        readonly en: "Variables";
+        readonly ko: "변수";
+    };
+    readonly returns: {
+        readonly en: "Returns";
+        readonly ko: "반환";
+    };
+    readonly publishes: {
+        readonly en: "Publishes";
+        readonly ko: "발행";
+    };
+    readonly example: {
+        readonly en: "Example";
+        readonly ko: "예시";
+    };
+    readonly response: {
+        readonly en: "Response";
+        readonly ko: "응답";
+    };
+    readonly responsePlaceholder: {
+        readonly en: "Send the request to see the response.";
+        readonly ko: "요청을 보내면 응답이 여기에 표시됩니다.";
+    };
+    readonly stream: {
+        readonly en: "Stream";
+        readonly ko: "스트림";
+    };
+    readonly nothingReceived: {
+        readonly en: "Nothing received yet.";
+        readonly ko: "아직 받은 메시지가 없습니다.";
+    };
+    readonly sendRequest: {
+        readonly en: "Send Request";
+        readonly ko: "요청 보내기";
+    };
+    readonly listen: {
+        readonly en: "Listen";
+        readonly ko: "수신";
+    };
+    readonly send: {
+        readonly en: "Send";
+        readonly ko: "보내기";
+    };
+    readonly stop: {
+        readonly en: "Stop";
+        readonly ko: "중지";
+    };
+    readonly subscribe: {
+        readonly en: "Subscribe";
+        readonly ko: "구독";
+    };
+    readonly unsubscribe: {
+        readonly en: "Unsubscribe";
+        readonly ko: "구독 해제";
+    };
+    readonly noGuardMatch: {
+        readonly en: "No endpoint is gated by the selected guards.";
+        readonly ko: "선택한 가드가 걸린 엔드포인트가 없습니다.";
+    };
+    readonly noWsGuardMatch: {
+        readonly en: "No websocket endpoint is gated by the selected guards.";
+        readonly ko: "선택한 가드가 걸린 웹소켓 엔드포인트가 없습니다.";
+    };
+    readonly noWsEndpoint: {
+        readonly en: "This signal declares no websocket endpoint.";
+        readonly ko: "이 시그널에는 웹소켓 엔드포인트가 없습니다.";
+    };
+    readonly noSignal: {
+        readonly en: "No signal is registered.";
+        readonly ko: "등록된 시그널이 없습니다.";
+    };
+    readonly unknownOrigin: {
+        readonly en: "Unknown library";
+        readonly ko: "출처 미상";
+    };
+};
+export declare const guardCountText: (count: number) => {
+    en: string;
+    ko: string;
+};
+export declare const noSignalText: (refName: string) => {
+    en: string;
+    ko: string;
+};
+export declare const noSearchMatchText: (search: string) => {
+    en: string;
+    ko: string;
+};

package/types/ui/System/CSR.d.ts

@@ -5,7 +5,7 @@ export declare const CSR: {
     ({ children }: {
         children: ReactNode;
     }): import("react").JSX.Element;
-    Provider: ({ className, appName, params, head, manifest, env, theme, prefix, children, fonts, layoutStyle, reconnect, wsConnect, of, }: CSRProviderProps) => import("react").JSX.Element;
+    Provider: ({ className, appName, params, head, manifest, env, theme, viewport, prefix, children, fonts, layoutStyle, reconnect, wsConnect, of, }: CSRProviderProps) => import("react").JSX.Element;
     Wrapper: ({ children, lang, head, manifest, fonts, appName, className, prefix, layoutStyle, }: CSRWrapperProps) => import("react").JSX.Element;
     Inner: () => import("react").JSX.Element;
     Bridge: ({ lang, prefix }: CSRBridgeProps) => null;
@@ -13,7 +13,7 @@ export declare const CSR: {
 export type CSRProviderProps = ProviderProps & {
     fonts: ReactFont[];
 };
-declare const CSRProvider: ({ className, appName, params, head, manifest, env, theme, prefix, children, fonts, layoutStyle, reconnect, wsConnect, of, }: CSRProviderProps) => import("react").JSX.Element;
+declare const CSRProvider: ({ className, appName, params, head, manifest, env, theme, viewport, prefix, children, fonts, layoutStyle, reconnect, wsConnect, of, }: CSRProviderProps) => import("react").JSX.Element;
 interface CSRWrapperProps {
     className?: string;
     appName: string;

package/types/ui/System/Client.d.ts

@@ -1,11 +1,11 @@
-import { type CsrPageType, type Location, type PageActivity, type PageState, type TransitionStyle } from "akanjs/client";
+import { type CsrPageType, type Location, type PageActivity, type PageState, type RouteViewport, type TransitionStyle } from "akanjs/client";
 import type { AkanTheme } from "akanjs/fetch";
 import type { SerializedSignal } from "akanjs/signal";
 import { type HTMLAttributes, type ReactNode, type RefObject } from "react";
 export declare const Client: {
     (): import("react").JSX.Element;
     Wrapper: ({ children, theme, lang, path, dictionary, signals, reconnect, }: ClientWrapperProps) => import("react").JSX.Element;
-    Bridge: ({ env, lang, theme, prefix, wsConnect }: ClientBridgeProps) => null;
+    Bridge: ({ env, lang, theme, viewport, prefix, wsConnect }: ClientBridgeProps) => null;
     Inner: () => import("react").JSX.Element;
     SsrBridge: ({ lang, prefix, initialPageState }: ClientSsrBridgeProps) => null;
 };
@@ -44,10 +44,11 @@ interface ClientBridgeProps {
     env?: object;
     lang?: string;
     theme?: AkanTheme;
+    viewport?: RouteViewport;
     prefix?: string;
     wsConnect?: boolean;
 }
-export declare const ClientBridge: ({ env, lang, theme, prefix, wsConnect }: ClientBridgeProps) => null;
+export declare const ClientBridge: ({ env, lang, theme, viewport, prefix, wsConnect }: ClientBridgeProps) => null;
 export declare const ClientInner: () => import("react").JSX.Element;
 interface ClientSsrBridgeProps {
     lang: string;

package/types/ui/System/Common.d.ts

@@ -1,5 +1,5 @@
 import "dayjs/locale/ko";
-import type { PageState, RootLayoutProps, WebAppManifest } from "akanjs/client";
+import { type InsetBreakpoint, type PageState, type RootLayoutProps, type RouteViewport, toManifestJson, type WebAppManifest } from "akanjs/client";
 import type { AkanTheme } from "akanjs/fetch";
 import type { CSSProperties, ReactNode } from "react";
 export interface ProviderProps {
@@ -12,6 +12,7 @@ export interface ProviderProps {
     /** App-specific public client config (`env/env.client.ts`) merged over the framework's own `getEnv()`. */
     env?: object;
     theme?: AkanTheme;
+    viewport?: RouteViewport;
     prefix?: string;
     children: ReactNode | ReactNode[];
     layoutStyle?: "mobile" | "web";
@@ -27,11 +28,31 @@ export interface ProviderProps {
     of: (props: unknown) => ReactNode | null;
 }
 export declare const Common: () => null;
-export declare function ManifestLink({ manifest }: {
+export { toManifestJson };
+/** An SSR document links the URL its server answers, where `start_url`, `scope` and icons resolve; a CSR bundle,
+ *  which no server serves in a native shell, carries the manifest inline. */
+export declare function ManifestLink({ manifest, basePath }: {
     manifest?: WebAppManifest;
+    basePath?: string | null;
 }): import("react").JSX.Element | null;
 export declare function createManifestDataUrl(manifest: WebAppManifest): string;
-export declare function toManifestJson(value: unknown): unknown;
-export type AkanFrameCssVarName = "--akan-top-safe-area" | "--akan-bottom-safe-area" | "--akan-top-inset" | "--akan-bottom-inset" | "--akan-page-padding-top" | "--akan-page-padding-bottom";
-export type AkanFrameCssVars = CSSProperties & Record<AkanFrameCssVarName, string>;
-export declare function getFrameCssVars(pageState: PageState): AkanFrameCssVars;
+export type AkanFrameCssVarName = "--akan-top-safe-area" | "--akan-bottom-safe-area" | "--akan-top-inset" | "--akan-bottom-inset" | "--akan-page-padding-top" | "--akan-page-padding-bottom" | "--akan-content-height" | `--akan-${"top" | "bottom"}-inset-visibility` | `--akan-${"top" | "bottom"}-inset-${InsetBreakpoint}` | `--akan-${"top" | "bottom"}-inset-visibility-${InsetBreakpoint}`;
+export type AkanFrameCssVars = CSSProperties & {
+    [name in AkanFrameCssVarName]?: string;
+};
+/** Whether a frame's insets are left to the stylesheet's media rules, which key on `data-akan-frame-responsive`. */
+export declare const isResponsiveFrame: (pageState: PageState, { cssResolved }: {
+    cssResolved: boolean;
+}) => boolean;
+/**
+ * `cssResolved` is the SSR document, whose width and safe area only CSS knows: insets per breakpoint and the web's
+ * `env()` safe area. A CSR frame lays pages out from the same numbers in script, so it gets those numbers.
+ */
+export declare function getFrameCssVars(pageState: PageState, { cssResolved }: {
+    cssResolved: boolean;
+}): AkanFrameCssVars;
+/** Copies the current page's frame onto `<html>`, so a layer portalled to `<body>` (the agent launcher) can read it. */
+export declare class FrameRootVars {
+    #private;
+    static mirror(vars: AkanFrameCssVars, responsive: boolean): void;
+}

package/types/ui/System/SSR.d.ts

@@ -1,22 +1,22 @@
-import { type PageState, type ReactFont, type WebAppManifest } from "akanjs/client";
+import { type PageState, type ReactFont } from "akanjs/client";
+import * as React from "react";
 import { type ReactNode } from "react";
 import { type ProviderProps } from "./Common.d.ts";
 export declare const SSR: {
-    (): import("react").JSX.Element;
-    Provider: ({ className, appName, params, head, manifest, env, children, theme, prefix, fonts, layoutStyle, reconnect, wsConnect, dictionary, allDictionary, of, }: SSRProviderProps) => import("react").JSX.Element;
-    Wrapper: ({ children, head, manifest, fonts, className, lang, path, prefix, layoutStyle, pageState, }: SSRWrapperProps) => import("react").JSX.Element;
+    (): React.JSX.Element;
+    Provider: ({ className, appName, params, head, env, children, theme, viewport, prefix, fonts, layoutStyle, reconnect, wsConnect, dictionary, allDictionary, of, }: SSRProviderProps) => React.JSX.Element;
+    Wrapper: ({ children, head, fonts, className, lang, path, prefix, layoutStyle, pageState, }: SSRWrapperProps) => React.JSX.Element;
 };
 export type SSRProviderProps = ProviderProps & {
     fonts?: ReactFont[];
 };
-declare const SSRProvider: ({ className, appName, params, head, manifest, env, children, theme, prefix, fonts, layoutStyle, reconnect, wsConnect, dictionary, allDictionary, of, }: SSRProviderProps) => import("react").JSX.Element;
+declare const SSRProvider: ({ className, appName, params, head, env, children, theme, viewport, prefix, fonts, layoutStyle, reconnect, wsConnect, dictionary, allDictionary, of, }: SSRProviderProps) => React.JSX.Element;
 interface SSRWrapperProps {
     className?: string;
     appName: string;
     lang: "en" | "ko" | (string & {});
     path: string;
     head?: ReactNode;
-    manifest?: WebAppManifest;
     fonts?: ReactFont[];
     children: ReactNode;
     prefix?: string;

package/types/ui/Tooltip.d.ts

@@ -1,9 +1,11 @@
-import type { ReactNode } from "react";
+import { type ReactNode } from "react";
+import { type OverlaySide } from "./overlayPosition.d.ts";
 export interface TooltipProps {
     /** Empty renders the trigger alone. */
     content?: ReactNode;
     children: ReactNode;
-    side?: "top" | "right" | "bottom" | "left";
+    /** The preferred side; the bubble flips to the opposite one when that has more room. */
+    side?: OverlaySide;
     className?: string;
     variant?: "default" | "primary" | "info";
 }

package/types/ui/index.d.ts

@@ -30,12 +30,13 @@ export { BottomSheet, type BottomSheetRef } from "./BottomSheet.d.ts";
 export { Button } from "./Button.d.ts";
 export { ClientSide } from "./ClientSide.d.ts";
 export { Clipboard } from "./Clipboard.d.ts";
-export { Constant } from "./Constant.d.ts";
+export { Constant, type ConstantSchemaDoc, type ConstantSchemaOptions, type DatabaseSchema, type EnumSchema, getConstantSchemaDoc, type RelationSchema, type ScalarSchema, } from "./Constant.d.ts";
 export { Copy } from "./Copy.d.ts";
 export { CsrImage } from "./CsrImage.d.ts";
 export { Data } from "./Data.d.ts";
 export { DatePicker } from "./DatePicker.d.ts";
 export { Dialog } from "./Dialog.d.ts";
+export type { ModalPlacement, ModalPresentation } from "./Dialog/modalSurface.d.ts";
 export { DragAction } from "./DragAction.d.ts";
 export { DraggableList } from "./DraggableList.d.ts";
 export { DROPDOWN_KEEP_OPEN_ATTR, Dropdown } from "./Dropdown.d.ts";