@iota-uz/sdk 0.3.0 → 0.3.2

package/dist/index.d.cts

@@ -1,84 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-
-/**
- * TypeScript type definitions for IOTA SDK Applet Core
- * Matches Go backend types from pkg/applet/types.go
- */
-interface InitialContext {
-    user: UserContext;
-    tenant: TenantContext;
-    locale: LocaleContext;
-    config: AppConfig;
-    route: RouteContext;
-    session: SessionContext;
-    error: ErrorContext | null;
-    extensions?: Record<string, unknown>;
-}
-interface UserContext {
-    id: number;
-    email: string;
-    firstName: string;
-    lastName: string;
-    permissions: string[];
-}
-interface TenantContext {
-    id: string;
-    name: string;
-}
-interface LocaleContext {
-    language: string;
-    translations: Record<string, string>;
-}
-interface AppConfig {
-    graphQLEndpoint?: string;
-    streamEndpoint?: string;
-    restEndpoint?: string;
-}
-interface RouteContext {
-    path: string;
-    params: Record<string, string>;
-    query: Record<string, string>;
-}
-interface SessionContext {
-    expiresAt: number;
-    refreshURL: string;
-    csrfToken: string;
-}
-interface ErrorContext {
-    supportEmail?: string;
-    debugMode: boolean;
-    errorCodes?: Record<string, string>;
-    retryConfig?: RetryConfig;
-}
-interface RetryConfig {
-    maxAttempts: number;
-    backoffMs: number;
-}
-/**
- * Hook return types
- */
-interface TranslationHook {
-    t: (key: string, params?: Record<string, unknown>) => string;
-    language: string;
-}
-interface PermissionsHook {
-    hasPermission: (permission: string) => boolean;
-    hasAnyPermission: (...permissions: string[]) => boolean;
-    permissions: string[];
-}
-interface SessionHook {
-    isExpiringSoon: boolean;
-    refreshSession: () => Promise<void>;
-    csrfToken: string;
-    expiresAt: number;
-}
-interface StreamingHook {
-    isStreaming: boolean;
-    processStream: <T>(generator: AsyncGenerator<T>, onChunk: (chunk: T) => void, signal?: AbortSignal) => Promise<void>;
-    cancel: () => void;
-    reset: () => void;
-}
+import react__default, { ReactNode } from 'react';
+import { I as InitialContext, A as AppConfig, U as UserContext, P as PermissionsHook, T as TranslationHook, S as SessionHook, R as RouteContext, a as StreamingHook } from './index-B73-BCi-.cjs';
+export { L as LocaleContext, b as SessionContext, c as TenantContext } from './index-B73-BCi-.cjs';
 
 interface AppletProviderProps {
     children: ReactNode;
@@ -234,4 +157,76 @@ declare function useRoute(): RouteContext;
  */
 declare function useStreaming(): StreamingHook;
 
-export { type AppConfig, AppletProvider, ConfigProvider, type InitialContext, type LocaleContext, type PermissionsHook, type RouteContext, type SessionContext, type SessionHook, type StreamingHook, type TenantContext, type TranslationHook, type UserContext, useAppletContext$1 as useAppletContext, useAppletContext as useAppletContextDirect, useConfig, useConfigContext, usePermissions, useRoute, useSession, useStreaming, useTranslation, useUser };
+type ShellMode$1 = 'embedded' | 'standalone';
+interface AppletRuntime {
+    basePath: string;
+    assetsBasePath: string;
+    rpcEndpoint?: string;
+    shellMode?: ShellMode$1;
+}
+declare function useAppletRuntime(): AppletRuntime;
+
+type RouterMode$1 = 'url' | 'memory';
+type ShellMode = 'embedded' | 'standalone';
+interface AppletHostConfig {
+    basePath: string;
+    shellMode?: ShellMode;
+    routerMode: RouterMode$1;
+    attrs: Record<string, string>;
+}
+interface DefineReactAppletElementOptions {
+    tagName: string;
+    styles?: string | (() => string);
+    render: (host: AppletHostConfig) => react__default.ReactElement;
+    observedAttributes?: string[];
+    observeDarkMode?: boolean;
+}
+declare function defineReactAppletElement(options: DefineReactAppletElementOptions): void;
+
+interface AppletRPCError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+declare class AppletRPCException extends Error {
+    code: string;
+    details?: unknown;
+    cause?: unknown;
+    constructor(args: {
+        code: string;
+        message: string;
+        details?: unknown;
+        cause?: unknown;
+    });
+}
+type AppletRPCSchema = Record<string, {
+    params: unknown;
+    result: unknown;
+}>;
+interface CreateAppletRPCClientOptions {
+    endpoint: string;
+    fetcher?: typeof fetch;
+}
+declare function createAppletRPCClient(options: CreateAppletRPCClientOptions): {
+    call: <TParams, TResult>(method: string, params: TParams) => Promise<TResult>;
+    callTyped: <TRouter extends AppletRPCSchema, TMethod extends keyof TRouter & string>(method: TMethod, params: TRouter[TMethod]["params"]) => Promise<TRouter[TMethod]["result"]>;
+};
+
+type RouterMode = 'url' | 'memory';
+interface CreateAppletRouterOptions {
+    mode: RouterMode;
+    basePath?: string;
+    BrowserRouter: react__default.ComponentType<any>;
+    MemoryRouter: react__default.ComponentType<any>;
+}
+declare function createAppletRouter(options: CreateAppletRouterOptions): {
+    Router: react__default.FC<{
+        children?: react__default.ReactNode | undefined;
+    }>;
+};
+
+declare function shouldEnableAppletDevtools(): boolean;
+
+declare function AppletDevtoolsOverlay(): react_jsx_runtime.JSX.Element;
+
+export { AppConfig, AppletDevtoolsOverlay, AppletProvider, type AppletRPCError, AppletRPCException, type AppletRPCSchema, ConfigProvider, InitialContext, PermissionsHook, RouteContext, type RouterMode, SessionHook, StreamingHook, TranslationHook, UserContext, createAppletRPCClient, createAppletRouter, defineReactAppletElement, shouldEnableAppletDevtools, useAppletContext$1 as useAppletContext, useAppletContext as useAppletContextDirect, useAppletRuntime, useConfig, useConfigContext, usePermissions, useRoute, useSession, useStreaming, useTranslation, useUser };

package/dist/index.d.ts

@@ -1,84 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-
-/**
- * TypeScript type definitions for IOTA SDK Applet Core
- * Matches Go backend types from pkg/applet/types.go
- */
-interface InitialContext {
-    user: UserContext;
-    tenant: TenantContext;
-    locale: LocaleContext;
-    config: AppConfig;
-    route: RouteContext;
-    session: SessionContext;
-    error: ErrorContext | null;
-    extensions?: Record<string, unknown>;
-}
-interface UserContext {
-    id: number;
-    email: string;
-    firstName: string;
-    lastName: string;
-    permissions: string[];
-}
-interface TenantContext {
-    id: string;
-    name: string;
-}
-interface LocaleContext {
-    language: string;
-    translations: Record<string, string>;
-}
-interface AppConfig {
-    graphQLEndpoint?: string;
-    streamEndpoint?: string;
-    restEndpoint?: string;
-}
-interface RouteContext {
-    path: string;
-    params: Record<string, string>;
-    query: Record<string, string>;
-}
-interface SessionContext {
-    expiresAt: number;
-    refreshURL: string;
-    csrfToken: string;
-}
-interface ErrorContext {
-    supportEmail?: string;
-    debugMode: boolean;
-    errorCodes?: Record<string, string>;
-    retryConfig?: RetryConfig;
-}
-interface RetryConfig {
-    maxAttempts: number;
-    backoffMs: number;
-}
-/**
- * Hook return types
- */
-interface TranslationHook {
-    t: (key: string, params?: Record<string, unknown>) => string;
-    language: string;
-}
-interface PermissionsHook {
-    hasPermission: (permission: string) => boolean;
-    hasAnyPermission: (...permissions: string[]) => boolean;
-    permissions: string[];
-}
-interface SessionHook {
-    isExpiringSoon: boolean;
-    refreshSession: () => Promise<void>;
-    csrfToken: string;
-    expiresAt: number;
-}
-interface StreamingHook {
-    isStreaming: boolean;
-    processStream: <T>(generator: AsyncGenerator<T>, onChunk: (chunk: T) => void, signal?: AbortSignal) => Promise<void>;
-    cancel: () => void;
-    reset: () => void;
-}
+import react__default, { ReactNode } from 'react';
+import { I as InitialContext, A as AppConfig, U as UserContext, P as PermissionsHook, T as TranslationHook, S as SessionHook, R as RouteContext, a as StreamingHook } from './index-B73-BCi-.js';
+export { L as LocaleContext, b as SessionContext, c as TenantContext } from './index-B73-BCi-.js';
 
 interface AppletProviderProps {
     children: ReactNode;
@@ -234,4 +157,76 @@ declare function useRoute(): RouteContext;
  */
 declare function useStreaming(): StreamingHook;
 
-export { type AppConfig, AppletProvider, ConfigProvider, type InitialContext, type LocaleContext, type PermissionsHook, type RouteContext, type SessionContext, type SessionHook, type StreamingHook, type TenantContext, type TranslationHook, type UserContext, useAppletContext$1 as useAppletContext, useAppletContext as useAppletContextDirect, useConfig, useConfigContext, usePermissions, useRoute, useSession, useStreaming, useTranslation, useUser };
+type ShellMode$1 = 'embedded' | 'standalone';
+interface AppletRuntime {
+    basePath: string;
+    assetsBasePath: string;
+    rpcEndpoint?: string;
+    shellMode?: ShellMode$1;
+}
+declare function useAppletRuntime(): AppletRuntime;
+
+type RouterMode$1 = 'url' | 'memory';
+type ShellMode = 'embedded' | 'standalone';
+interface AppletHostConfig {
+    basePath: string;
+    shellMode?: ShellMode;
+    routerMode: RouterMode$1;
+    attrs: Record<string, string>;
+}
+interface DefineReactAppletElementOptions {
+    tagName: string;
+    styles?: string | (() => string);
+    render: (host: AppletHostConfig) => react__default.ReactElement;
+    observedAttributes?: string[];
+    observeDarkMode?: boolean;
+}
+declare function defineReactAppletElement(options: DefineReactAppletElementOptions): void;
+
+interface AppletRPCError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+declare class AppletRPCException extends Error {
+    code: string;
+    details?: unknown;
+    cause?: unknown;
+    constructor(args: {
+        code: string;
+        message: string;
+        details?: unknown;
+        cause?: unknown;
+    });
+}
+type AppletRPCSchema = Record<string, {
+    params: unknown;
+    result: unknown;
+}>;
+interface CreateAppletRPCClientOptions {
+    endpoint: string;
+    fetcher?: typeof fetch;
+}
+declare function createAppletRPCClient(options: CreateAppletRPCClientOptions): {
+    call: <TParams, TResult>(method: string, params: TParams) => Promise<TResult>;
+    callTyped: <TRouter extends AppletRPCSchema, TMethod extends keyof TRouter & string>(method: TMethod, params: TRouter[TMethod]["params"]) => Promise<TRouter[TMethod]["result"]>;
+};
+
+type RouterMode = 'url' | 'memory';
+interface CreateAppletRouterOptions {
+    mode: RouterMode;
+    basePath?: string;
+    BrowserRouter: react__default.ComponentType<any>;
+    MemoryRouter: react__default.ComponentType<any>;
+}
+declare function createAppletRouter(options: CreateAppletRouterOptions): {
+    Router: react__default.FC<{
+        children?: react__default.ReactNode | undefined;
+    }>;
+};
+
+declare function shouldEnableAppletDevtools(): boolean;
+
+declare function AppletDevtoolsOverlay(): react_jsx_runtime.JSX.Element;
+
+export { AppConfig, AppletDevtoolsOverlay, AppletProvider, type AppletRPCError, AppletRPCException, type AppletRPCSchema, ConfigProvider, InitialContext, PermissionsHook, RouteContext, type RouterMode, SessionHook, StreamingHook, TranslationHook, UserContext, createAppletRPCClient, createAppletRouter, defineReactAppletElement, shouldEnableAppletDevtools, useAppletContext$1 as useAppletContext, useAppletContext as useAppletContextDirect, useAppletRuntime, useConfig, useConfigContext, usePermissions, useRoute, useSession, useStreaming, useTranslation, useUser };

package/dist/index.mjs

@@ -1,5 +1,6 @@
-import { createContext, useContext, useMemo, useState, useRef, useCallback } from 'react';
-import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useMemo, useState, useRef, useCallback, useEffect } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { createRoot } from 'react-dom/client';
 
 // ui/src/applet-core/context/AppletContext.tsx
 var AppletContext = createContext(null);
@@ -173,6 +174,345 @@ function useStreaming() {
   };
 }
 
-export { AppletProvider, ConfigProvider, useAppletContext, useAppletContext2 as useAppletContextDirect, useConfig, useConfigContext, usePermissions, useRoute, useSession, useStreaming, useTranslation, useUser };
+// ui/src/applet-core/hooks/useAppletRuntime.ts
+function useAppletRuntime() {
+  const config = useConfig();
+  const basePath = config.basePath ?? "";
+  const normalizedBasePath = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  const assetsBasePath = config.assetsBasePath ?? `${normalizedBasePath || ""}/assets`;
+  const rpcEndpoint = config.rpcUIEndpoint;
+  const shellMode = config.shellMode;
+  return { basePath: normalizedBasePath, assetsBasePath, rpcEndpoint, shellMode };
+}
+function defineReactAppletElement(options) {
+  const tagName = options.tagName.toLowerCase();
+  const registry = getRegistry();
+  const existing = registry.get(tagName);
+  if (existing) {
+    existing.options = options;
+    for (const a of options.observedAttributes ?? []) existing.observed.add(a);
+  } else {
+    const observed = /* @__PURE__ */ new Set(["base-path", "shell-mode", "router-mode"]);
+    for (const a of options.observedAttributes ?? []) observed.add(a);
+    registry.set(tagName, { options, observed });
+  }
+  if (customElements.get(tagName)) {
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("iota:applet-host-update", { detail: { tagName } }));
+    }
+    return;
+  }
+  function getEntry() {
+    const entry = getRegistry().get(tagName);
+    if (!entry) throw new Error(`[${tagName}] applet host registry entry missing`);
+    return entry;
+  }
+  class ReactAppletElement extends HTMLElement {
+    constructor() {
+      super(...arguments);
+      this.reactRoot = null;
+      this.container = null;
+      this.darkModeObserver = null;
+      this.styleEl = null;
+      this.updateListener = null;
+    }
+    static get observedAttributes() {
+      return Array.from(getEntry().observed);
+    }
+    connectedCallback() {
+      const shadowRoot = this.shadowRoot ?? this.attachShadow({ mode: "open" });
+      if (!this.container) {
+        this.container = document.createElement("div");
+        this.container.id = "react-root";
+        this.container.style.display = "flex";
+        this.container.style.flexDirection = "column";
+        this.container.style.flex = "1";
+        this.container.style.minHeight = "0";
+        this.container.style.height = "100%";
+        this.container.style.width = "100%";
+      }
+      const existingContainer = shadowRoot.querySelector("#react-root");
+      if (!existingContainer) {
+        if (this.styleEl) shadowRoot.appendChild(this.styleEl);
+        shadowRoot.appendChild(this.container);
+      } else if (existingContainer !== this.container) {
+        this.container = existingContainer;
+      }
+      this.syncFromRegistry();
+      this.updateListener ?? (this.updateListener = (e) => {
+        if (!(e instanceof CustomEvent)) return;
+        const detail = e.detail;
+        if (!detail || detail.tagName !== tagName) return;
+        this.syncFromRegistry();
+        this.renderReact();
+      });
+      window.addEventListener("iota:applet-host-update", this.updateListener);
+      this.renderReact();
+    }
+    disconnectedCallback() {
+      if (this.updateListener) {
+        window.removeEventListener("iota:applet-host-update", this.updateListener);
+      }
+      this.darkModeObserver?.disconnect();
+      this.darkModeObserver = null;
+      this.reactRoot?.unmount();
+      this.reactRoot = null;
+    }
+    attributeChangedCallback(_name, oldValue, newValue) {
+      if (oldValue === newValue) return;
+      if (this.container) this.renderReact();
+    }
+    getHostConfig() {
+      const attrs = {};
+      for (const { name, value } of Array.from(this.attributes)) {
+        attrs[name] = value;
+      }
+      const basePath = this.getAttribute("base-path") ?? "";
+      const shellMode = this.getAttribute("shell-mode") ?? void 0;
+      const routerMode = this.getAttribute("router-mode") ?? "url";
+      return { basePath, shellMode, routerMode, attrs };
+    }
+    renderReact() {
+      if (!this.container) return;
+      if (!this.reactRoot) {
+        this.reactRoot = createRoot(this.container);
+      }
+      try {
+        this.reactRoot.render(getEntry().options.render(this.getHostConfig()));
+      } catch (err) {
+        console.error(`[${tagName}] failed to mount React app:`, err);
+      }
+    }
+    syncFromRegistry() {
+      const entry = getEntry();
+      const styles = typeof entry.options.styles === "function" ? entry.options.styles() : entry.options.styles;
+      if (styles) {
+        this.styleEl ?? (this.styleEl = document.createElement("style"));
+        this.styleEl.textContent = styles;
+        if (this.shadowRoot && !this.shadowRoot.contains(this.styleEl)) {
+          this.shadowRoot.insertBefore(this.styleEl, this.shadowRoot.firstChild);
+        }
+      } else if (this.styleEl) {
+        this.styleEl.remove();
+        this.styleEl = null;
+      }
+      if (entry.options.observeDarkMode !== false) {
+        this.darkModeObserver ?? (this.darkModeObserver = this.syncDarkMode());
+      } else if (this.darkModeObserver) {
+        this.darkModeObserver.disconnect();
+        this.darkModeObserver = null;
+      }
+    }
+    syncDarkMode() {
+      const root = this.container;
+      if (!root) throw new Error("react root container not found");
+      const apply = () => {
+        if (document.documentElement.classList.contains("dark")) root.classList.add("dark");
+        else root.classList.remove("dark");
+      };
+      apply();
+      const observer = new MutationObserver(apply);
+      observer.observe(document.documentElement, { attributes: true, attributeFilter: ["class"] });
+      return observer;
+    }
+  }
+  customElements.define(tagName, ReactAppletElement);
+}
+function getRegistry() {
+  const anyGlobal = globalThis;
+  anyGlobal.__IOTA_REACT_APPLET_HOST_REGISTRY__ ?? (anyGlobal.__IOTA_REACT_APPLET_HOST_REGISTRY__ = /* @__PURE__ */ new Map());
+  return anyGlobal.__IOTA_REACT_APPLET_HOST_REGISTRY__;
+}
+
+// ui/src/applet-devtools/enabled.ts
+function shouldEnableAppletDevtools() {
+  if (typeof window === "undefined") return false;
+  const url = new URL(window.location.href);
+  if (url.searchParams.get("appletDebug") === "1") return true;
+  try {
+    return window.localStorage.getItem("iotaAppletDevtools") === "1";
+  } catch {
+    return false;
+  }
+}
+
+// ui/src/applet-host/rpc.ts
+var AppletRPCException = class extends Error {
+  constructor(args) {
+    super(args.message);
+    this.name = "AppletRPCException";
+    this.code = args.code;
+    this.details = args.details;
+    this.cause = args.cause;
+  }
+};
+function createAppletRPCClient(options) {
+  const fetcher = options.fetcher ?? fetch;
+  async function call(method, params) {
+    const req = { id: crypto.randomUUID(), method, params };
+    const startedAt = typeof performance !== "undefined" ? performance.now() : Date.now();
+    maybeDispatchRPCEvent({
+      id: req.id,
+      method: req.method,
+      status: "start"
+    });
+    try {
+      const resp = await fetcher(options.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(req)
+      });
+      if (!resp.ok) {
+        throw new AppletRPCException({
+          code: "http_error",
+          message: `HTTP ${resp.status}`,
+          details: { status: resp.status }
+        });
+      }
+      const json = await resp.json();
+      if (json.error) {
+        throw new AppletRPCException({
+          code: json.error.code,
+          message: json.error.message,
+          details: json.error.details
+        });
+      }
+      if (json.result === void 0) {
+        throw new AppletRPCException({
+          code: "invalid_response",
+          message: "Missing result in successful response"
+        });
+      }
+      maybeDispatchRPCEvent({
+        id: req.id,
+        method: req.method,
+        status: "success",
+        durationMs: elapsedMs(startedAt)
+      });
+      return json.result;
+    } catch (err) {
+      maybeDispatchRPCEvent({
+        id: req.id,
+        method: req.method,
+        status: "error",
+        durationMs: elapsedMs(startedAt),
+        error: err
+      });
+      throw err;
+    }
+  }
+  async function callTyped(method, params) {
+    return call(method, params);
+  }
+  return { call, callTyped };
+}
+function maybeDispatchRPCEvent(detail) {
+  if (typeof window === "undefined") return;
+  if (!shouldEnableAppletDevtools()) return;
+  window.dispatchEvent(new CustomEvent("iota:applet-rpc", { detail }));
+}
+function elapsedMs(startedAt) {
+  const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+  return Math.max(0, Math.round(now - startedAt));
+}
+function createAppletRouter(options) {
+  const basePath = options.basePath ?? "";
+  const Router = ({ children }) => {
+    if (options.mode === "memory") {
+      const MemoryRouter = options.MemoryRouter;
+      return /* @__PURE__ */ jsx(MemoryRouter, { children });
+    }
+    const BrowserRouter = options.BrowserRouter;
+    return /* @__PURE__ */ jsx(BrowserRouter, { basename: basePath, children });
+  };
+  return { Router };
+}
+function AppletDevtoolsOverlay() {
+  const ctx = useAppletContext();
+  const runtime = useAppletRuntime();
+  const [rpcEvents, setRPCEvents] = useState([]);
+  useEffect(() => {
+    const onEvent = (e) => {
+      if (!(e instanceof CustomEvent)) return;
+      const detail = e.detail;
+      if (!detail) return;
+      setRPCEvents((prev) => [detail, ...prev].slice(0, 50));
+    };
+    window.addEventListener("iota:applet-rpc", onEvent);
+    return () => window.removeEventListener("iota:applet-rpc", onEvent);
+  }, []);
+  const summary = useMemo(() => {
+    return {
+      basePath: runtime.basePath,
+      assetsBasePath: runtime.assetsBasePath,
+      rpcEndpoint: runtime.rpcEndpoint,
+      shellMode: runtime.shellMode,
+      route: ctx.route,
+      user: { id: ctx.user.id, email: ctx.user.email },
+      tenant: ctx.tenant
+    };
+  }, [ctx.route, ctx.tenant, ctx.user.email, ctx.user.id, runtime.assetsBasePath, runtime.basePath, runtime.rpcEndpoint, runtime.shellMode]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        right: 12,
+        bottom: 12,
+        width: 420,
+        maxHeight: "60vh",
+        overflow: "auto",
+        background: "rgba(17, 24, 39, 0.92)",
+        color: "#E5E7EB",
+        border: "1px solid rgba(255,255,255,0.12)",
+        borderRadius: 10,
+        padding: 12,
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+        fontSize: 12,
+        zIndex: 2147483647
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: 8 }, children: [
+          /* @__PURE__ */ jsx("div", { style: { fontWeight: 700 }, children: "Applet Devtools" }),
+          /* @__PURE__ */ jsx("div", { style: { opacity: 0.7 }, children: runtime.shellMode ?? "unknown" })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: { marginBottom: 10 }, children: [
+          /* @__PURE__ */ jsx("div", { style: { opacity: 0.85, marginBottom: 4 }, children: "Context" }),
+          /* @__PURE__ */ jsx("pre", { style: { margin: 0, whiteSpace: "pre-wrap", wordBreak: "break-word" }, children: JSON.stringify(summary, null, 2) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("div", { style: { opacity: 0.85, marginBottom: 4 }, children: "RPC" }),
+          rpcEvents.length === 0 ? /* @__PURE__ */ jsx("div", { style: { opacity: 0.7 }, children: "No calls yet" }) : /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: rpcEvents.map((ev) => /* @__PURE__ */ jsxs("div", { style: { padding: 8, border: "1px solid rgba(255,255,255,0.08)", borderRadius: 8 }, children: [
+            /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+              /* @__PURE__ */ jsx("div", { children: ev.method }),
+              /* @__PURE__ */ jsxs("div", { style: { opacity: 0.8 }, children: [
+                ev.status,
+                typeof ev.durationMs === "number" ? ` (${ev.durationMs}ms)` : ""
+              ] })
+            ] }),
+            ev.status === "error" ? /* @__PURE__ */ jsx("pre", { style: { margin: "6px 0 0", opacity: 0.8, whiteSpace: "pre-wrap", wordBreak: "break-word" }, children: JSON.stringify(serializeError(ev.error) ?? {}, null, 2) }) : null
+          ] }, `${ev.id}:${ev.status}`)) })
+        ] })
+      ]
+    }
+  );
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    const anyErr = err;
+    const out = {
+      name: err.name,
+      message: err.message
+    };
+    if (err.stack) out.stack = err.stack;
+    if (typeof anyErr.code === "string") out.code = anyErr.code;
+    if (anyErr.details !== void 0) out.details = anyErr.details;
+    if (anyErr.cause !== void 0) out.cause = anyErr.cause;
+    return out;
+  }
+  return err;
+}
+
+export { AppletDevtoolsOverlay, AppletProvider, AppletRPCException, ConfigProvider, createAppletRPCClient, createAppletRouter, defineReactAppletElement, shouldEnableAppletDevtools, useAppletContext, useAppletContext2 as useAppletContextDirect, useAppletRuntime, useConfig, useConfigContext, usePermissions, useRoute, useSession, useStreaming, useTranslation, useUser };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map