@pancake-apps/web 0.0.0-snapshot-20260125200133

package/dist/index.js

@@ -0,0 +1,685 @@
+import { updateModelContext, setupAutoSizeReporting, sendFollowUpMessage, say, requestDisplayMode, readResource, ping, openExternal, onTeardown, notifySizeChanged, navigateToView, logWarning, logInfo, logError, logDebug, log, isSupported, data, callTool, action } from './chunk-7HJ5PKKT.js';
+export { action, callTool, data, isSupported, log, logDebug, logError, logInfo, logWarning, navigateToView, notifySizeChanged, onTeardown, openExternal, ping, readResource, requestDisplayMode, say, sendFollowUpMessage, setupAutoSizeReporting, updateModelContext } from './chunk-7HJ5PKKT.js';
+import { useView, useSystemColorScheme, useHostVariables, useHostTheme, useHostStyles, useHostFontsHook, useDocumentThemeState, useDocumentTheme, observeDocumentTheme, getSafeAreaInsets, getDocumentTheme, getComputedStyleVariables, createView, clearHostStyles, applySafeAreaInsets, applyHostStyleVariables, applyHostFonts, applyHostContext, applyDocumentTheme, View } from './chunk-TLBYYZHP.js';
+export { View, applyDocumentTheme, applyHostContext, applyHostFonts, applyHostStyleVariables, applySafeAreaInsets, clearHostStyles, createView, getComputedStyleVariables, getDocumentTheme, getSafeAreaInsets, observeDocumentTheme, useDocumentTheme, useDocumentThemeState, useHostFontsHook, useHostStyles, useHostTheme, useHostVariables, useSystemColorScheme, useView } from './chunk-TLBYYZHP.js';
+import { resetAdaptor, isMcpAppsAvailable, isAppsSdkAvailable, getPlatform, getAdaptor, SSR_DEFAULTS } from './chunk-ZYBPDIEG.js';
+export { getAdaptor, getPlatform, isAppsSdkAvailable, isMcpAppsAvailable, resetAdaptor } from './chunk-ZYBPDIEG.js';
+import { apps_sdk_exports } from './chunk-5NYJ2IVD.js';
+export { apps_sdk_exports as appsSdk } from './chunk-5NYJ2IVD.js';
+import { mcp_apps_exports } from './chunk-YGGRUIUG.js';
+export { mcp_apps_exports as mcpApps } from './chunk-YGGRUIUG.js';
+import { __export } from './chunk-PZ5AY32C.js';
+import { useSyncExternalStore, useState, useCallback, useRef, useEffect, useMemo, createContext, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/unified/index.ts
+var unified_exports = {};
+__export(unified_exports, {
+  DEBUG: () => DEBUG,
+  IS_STORYBOOK: () => IS_STORYBOOK,
+  IS_TEST: () => IS_TEST,
+  PancakeProvider: () => PancakeProvider,
+  View: () => View,
+  action: () => action,
+  applyDocumentTheme: () => applyDocumentTheme,
+  applyHostContext: () => applyHostContext,
+  applyHostFonts: () => applyHostFonts,
+  applyHostStyleVariables: () => applyHostStyleVariables,
+  applySafeAreaInsets: () => applySafeAreaInsets,
+  callTool: () => callTool,
+  clearHostStyles: () => clearHostStyles,
+  createView: () => createView,
+  data: () => data,
+  debugAssert: () => debugAssert,
+  debugLog: () => debugLog,
+  debugTime: () => debugTime,
+  debugTimeAsync: () => debugTimeAsync,
+  debugWarn: () => debugWarn,
+  getAdaptor: () => getAdaptor,
+  getComputedStyleVariables: () => getComputedStyleVariables,
+  getDocumentTheme: () => getDocumentTheme,
+  getPlatform: () => getPlatform,
+  getSafeAreaInsets: () => getSafeAreaInsets,
+  isAppsSdkAvailable: () => isAppsSdkAvailable,
+  isMcpAppsAvailable: () => isMcpAppsAvailable,
+  isSupported: () => isSupported,
+  log: () => log,
+  logDebug: () => logDebug,
+  logError: () => logError,
+  logInfo: () => logInfo,
+  logWarning: () => logWarning,
+  navigateToView: () => navigateToView,
+  notifySizeChanged: () => notifySizeChanged,
+  observeDocumentTheme: () => observeDocumentTheme,
+  onTeardown: () => onTeardown,
+  openExternal: () => openExternal,
+  ping: () => ping,
+  readResource: () => readResource,
+  requestDisplayMode: () => requestDisplayMode,
+  resetAdaptor: () => resetAdaptor,
+  say: () => say,
+  sendFollowUpMessage: () => sendFollowUpMessage,
+  setupAutoSizeReporting: () => setupAutoSizeReporting,
+  updateModelContext: () => updateModelContext,
+  useAction: () => useAction,
+  useCallTool: () => useCallTool,
+  useContainerSize: () => useContainerSize,
+  useData: () => useData,
+  useDeviceType: () => useDeviceType,
+  useDisplayMode: () => useDisplayMode,
+  useDisplayModeControl: () => useDisplayModeControl,
+  useDocumentTheme: () => useDocumentTheme,
+  useDocumentThemeState: () => useDocumentThemeState,
+  useHostEnvironment: () => useHostEnvironment,
+  useHostFontsHook: () => useHostFontsHook,
+  useHostStyles: () => useHostStyles,
+  useHostTheme: () => useHostTheme,
+  useHostVariables: () => useHostVariables,
+  useInputCapabilities: () => useInputCapabilities,
+  useIsDarkMode: () => useIsDarkMode,
+  useIsFullscreen: () => useIsFullscreen,
+  useIsMobile: () => useIsMobile,
+  useLocale: () => useLocale,
+  useMaxHeight: () => useMaxHeight,
+  usePancakeContext: () => usePancakeContext,
+  usePlatform: () => usePlatform,
+  useSafeArea: () => useSafeArea,
+  useSystemColorScheme: () => useSystemColorScheme,
+  useTheme: () => useTheme,
+  useToolInput: () => useToolInput,
+  useToolOutput: () => useToolOutput,
+  useToolResponseMetadata: () => useToolResponseMetadata,
+  useView: () => useView,
+  useViewData: () => useViewData,
+  useViewParams: () => useViewParams,
+  useViewState: () => useViewState
+});
+function useToolInput() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("toolInput");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+}
+function useToolInputPartial() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("toolInputPartial");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+}
+function useToolOutput() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("toolOutput");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+}
+function useToolResponseMetadata() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("toolResponseMetadata");
+  return useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getServerSnapshot
+  );
+}
+
+// src/unified/hooks/semantic/use-view-data.ts
+function useViewData() {
+  const input = useToolInput();
+  const output = useToolOutput();
+  const metadata = useToolResponseMetadata();
+  const inputPartial = useToolInputPartial();
+  let status;
+  let error;
+  if (!input && !inputPartial) {
+    status = "idle";
+  } else if (inputPartial && !input) {
+    status = "streaming";
+  } else if (input && !output) {
+    status = "pending";
+  } else if (output) {
+    status = "ready";
+  } else {
+    status = "idle";
+  }
+  if (metadata && metadata.isError) {
+    status = "error";
+    error = new Error(
+      metadata.errorMessage ?? "Unknown error"
+    );
+  }
+  return {
+    status,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isStreaming: status === "streaming",
+    isReady: status === "ready",
+    isError: status === "error",
+    input,
+    inputPartial,
+    output,
+    metadata,
+    error
+  };
+}
+function useAction(toolName) {
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(void 0);
+  const executeAsync = useCallback(
+    async (input) => {
+      setStatus("pending");
+      setError(void 0);
+      try {
+        await action(toolName, input);
+        setStatus("success");
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        setStatus("error");
+        throw errorObj;
+      }
+    },
+    [toolName]
+  );
+  const execute = useCallback(
+    (input, callbacks) => {
+      executeAsync(input).then(() => {
+        callbacks?.onSuccess?.();
+        callbacks?.onSettled?.();
+      }).catch((err) => {
+        callbacks?.onError?.(err);
+        callbacks?.onSettled?.();
+      });
+    },
+    [executeAsync]
+  );
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(void 0);
+  }, []);
+  return {
+    status,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    isError: status === "error",
+    error,
+    execute,
+    executeAsync,
+    reset
+  };
+}
+var cache = /* @__PURE__ */ new Map();
+function getCacheKey(toolName, input) {
+  return `${toolName}:${JSON.stringify(input ?? null)}`;
+}
+var DEFAULT_OPTIONS = {
+  staleTime: 0,
+  cacheTime: 5 * 60 * 1e3,
+  // 5 minutes
+  refetchOnWindowFocus: false
+};
+function useData(toolName, defaultInput, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const [status, setStatus] = useState("idle");
+  const [fetchedData, setFetchedData] = useState(opts.initialData);
+  const [error, setError] = useState(void 0);
+  const [isFetching, setIsFetching] = useState(false);
+  const [isStale, setIsStale] = useState(false);
+  const lastInputRef = useRef(defaultInput);
+  const refetchIntervalRef = useRef(null);
+  const checkStale = useCallback(
+    (cacheKey) => {
+      const entry = cache.get(cacheKey);
+      if (!entry) return true;
+      const age = Date.now() - entry.timestamp;
+      return age > opts.staleTime;
+    },
+    [opts.staleTime]
+  );
+  const cleanupCache = useCallback(() => {
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+      if (now - entry.timestamp > opts.cacheTime) {
+        cache.delete(key);
+      }
+    }
+  }, [opts.cacheTime]);
+  const fetchAsync = useCallback(
+    async (input) => {
+      const actualInput = input ?? lastInputRef.current;
+      lastInputRef.current = actualInput;
+      const cacheKey = getCacheKey(toolName, actualInput);
+      const cachedEntry = cache.get(cacheKey);
+      const isCacheStale = checkStale(cacheKey);
+      if (cachedEntry && !isCacheStale) {
+        setFetchedData(cachedEntry.data);
+        setStatus("success");
+        setIsStale(false);
+        return cachedEntry.data;
+      }
+      if (cachedEntry && isCacheStale) {
+        setFetchedData(cachedEntry.data);
+        setStatus("stale");
+        setIsStale(true);
+      } else {
+        setStatus("pending");
+      }
+      setIsFetching(true);
+      setError(void 0);
+      try {
+        const result = await data(toolName, actualInput);
+        cache.set(cacheKey, {
+          data: result,
+          timestamp: Date.now(),
+          input: actualInput
+        });
+        setFetchedData(result);
+        setStatus("success");
+        setIsStale(false);
+        opts.onSuccess?.(result);
+        cleanupCache();
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        setStatus("error");
+        opts.onError?.(errorObj);
+        throw errorObj;
+      } finally {
+        setIsFetching(false);
+      }
+    },
+    [toolName, checkStale, cleanupCache, opts]
+  );
+  const fetch = useCallback(
+    (input) => {
+      fetchAsync(input).catch(() => {
+      });
+    },
+    [fetchAsync]
+  );
+  const refetch = useCallback(() => {
+    fetch(lastInputRef.current);
+  }, [fetch]);
+  const invalidate = useCallback(() => {
+    const cacheKey = getCacheKey(toolName, lastInputRef.current);
+    cache.delete(cacheKey);
+    setIsStale(true);
+    setStatus((prev) => prev === "success" ? "stale" : prev);
+  }, [toolName]);
+  useEffect(() => {
+    if (!opts.refetchOnWindowFocus) return;
+    const handleFocus = () => {
+      if (fetchedData !== void 0) {
+        refetch();
+      }
+    };
+    window.addEventListener("focus", handleFocus);
+    return () => window.removeEventListener("focus", handleFocus);
+  }, [opts.refetchOnWindowFocus, fetchedData, refetch]);
+  useEffect(() => {
+    if (!opts.refetchInterval) return;
+    refetchIntervalRef.current = setInterval(() => {
+      if (fetchedData !== void 0) {
+        refetch();
+      }
+    }, opts.refetchInterval);
+    return () => {
+      if (refetchIntervalRef.current) {
+        clearInterval(refetchIntervalRef.current);
+      }
+    };
+  }, [opts.refetchInterval, fetchedData, refetch]);
+  return {
+    status,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    isError: status === "error",
+    isStale: status === "stale" || isStale,
+    isFetching,
+    data: fetchedData,
+    error,
+    fetch,
+    fetchAsync,
+    refetch,
+    invalidate
+  };
+}
+function useTheme() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("theme");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.theme;
+}
+function useLocale() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("locale");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? "en-US";
+}
+function useDeviceType() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("deviceType");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.deviceType;
+}
+function usePlatform() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("platform");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.platform;
+}
+function useSafeArea() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("safeArea");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.safeArea;
+}
+function useMaxHeight() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("maxHeight");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.maxHeight;
+}
+function useDisplayMode() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("displayMode");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.displayMode;
+}
+function useContainerSize() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("containerSize");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.containerSize;
+}
+function useInputCapabilities() {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("inputCapabilities");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot) ?? SSR_DEFAULTS.inputCapabilities;
+}
+function useCallTool(toolName) {
+  const [status, setStatus] = useState("idle");
+  const [data2, setData] = useState(void 0);
+  const [error, setError] = useState(void 0);
+  const callToolAsync = useCallback(
+    async (args) => {
+      const adaptor = getAdaptor();
+      setStatus("pending");
+      setError(void 0);
+      try {
+        const result = await adaptor.callTool(toolName, args);
+        setData(result);
+        setStatus("success");
+        return result;
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        setStatus("error");
+        throw errorObj;
+      }
+    },
+    [toolName]
+  );
+  const callTool2 = useCallback(
+    (args, callbacks) => {
+      callToolAsync(args).then((result) => {
+        callbacks?.onSuccess?.(result);
+        callbacks?.onSettled?.();
+      }).catch((err) => {
+        callbacks?.onError?.(err);
+        callbacks?.onSettled?.();
+      });
+    },
+    [callToolAsync]
+  );
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setData(void 0);
+    setError(void 0);
+  }, []);
+  return {
+    status,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    isError: status === "error",
+    data: data2,
+    error,
+    callTool: callTool2,
+    callToolAsync,
+    reset
+  };
+}
+
+// src/unified/hooks/rich/use-view-params.ts
+function useViewParams() {
+  const input = useToolInput();
+  const output = useToolOutput();
+  const metadata = useToolResponseMetadata();
+  let status;
+  if (!input) {
+    status = "idle";
+  } else if (!output) {
+    status = "pending";
+  } else {
+    status = "success";
+  }
+  return {
+    status,
+    isIdle: status === "idle",
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    input,
+    output,
+    metadata
+  };
+}
+function useViewState(initialState) {
+  const adaptor = getAdaptor();
+  const store = adaptor.getExternalStore("viewState");
+  const initialRef = useRef(initialState);
+  const persistedState = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getServerSnapshot
+  );
+  const state = persistedState ?? initialState;
+  const setState = useCallback((newState) => {
+    const current = adaptor.getViewState() ?? initialRef.current;
+    const nextState = typeof newState === "function" ? newState(current) : newState;
+    adaptor.setViewState(nextState);
+  }, [adaptor]);
+  const resetState = useCallback(() => {
+    adaptor.setViewState(initialRef.current);
+  }, [adaptor]);
+  const isDirty = persistedState !== void 0 && JSON.stringify(persistedState) !== JSON.stringify(initialRef.current);
+  return useMemo(() => {
+    const result = [state, setState];
+    result.state = state;
+    result.setState = setState;
+    result.resetState = resetState;
+    result.isDirty = isDirty;
+    return result;
+  }, [state, setState, resetState, isDirty]);
+}
+function useHostEnvironment() {
+  const theme = useTheme();
+  const locale = useLocale();
+  const deviceType = useDeviceType();
+  const platform = usePlatform();
+  const safeArea = useSafeArea();
+  const displayMode = useDisplayMode();
+  const containerSize = useContainerSize();
+  const inputCapabilities = useInputCapabilities();
+  return useMemo(
+    () => ({
+      theme,
+      locale,
+      deviceType,
+      platform,
+      safeArea,
+      displayMode,
+      containerSize,
+      inputCapabilities
+    }),
+    [theme, locale, deviceType, platform, safeArea, displayMode, containerSize, inputCapabilities]
+  );
+}
+function useDisplayModeControl() {
+  const displayMode = useDisplayMode();
+  const adaptor = getAdaptor();
+  const requestDisplayMode2 = useCallback(
+    async (mode) => {
+      await adaptor.requestDisplayMode(mode);
+    },
+    [adaptor]
+  );
+  const requestFullscreen = useCallback(async () => {
+    await requestDisplayMode2("fullscreen");
+  }, [requestDisplayMode2]);
+  const requestInline = useCallback(async () => {
+    await requestDisplayMode2("inline");
+  }, [requestDisplayMode2]);
+  const requestPip = useCallback(async () => {
+    await requestDisplayMode2("pip");
+  }, [requestDisplayMode2]);
+  return useMemo(
+    () => ({
+      displayMode,
+      requestFullscreen,
+      requestInline,
+      requestPip,
+      requestDisplayMode: requestDisplayMode2,
+      isFullscreen: displayMode === "fullscreen",
+      isInline: displayMode === "inline",
+      isPip: displayMode === "pip"
+    }),
+    [displayMode, requestFullscreen, requestInline, requestPip, requestDisplayMode2]
+  );
+}
+
+// src/unified/hooks/convenience/use-is-mobile.ts
+function useIsMobile() {
+  const deviceType = useDeviceType();
+  return deviceType === "mobile" || deviceType === "tablet";
+}
+
+// src/unified/hooks/convenience/use-is-fullscreen.ts
+function useIsFullscreen() {
+  const displayMode = useDisplayMode();
+  return displayMode === "fullscreen";
+}
+
+// src/unified/hooks/convenience/use-is-dark-mode.ts
+function useIsDarkMode() {
+  const theme = useTheme();
+  return theme === "dark";
+}
+var PancakeContext = createContext(null);
+function PancakeProvider({
+  children,
+  onError,
+  debug = false,
+  fallback = null,
+  immediate = false
+}) {
+  const [isReady, setIsReady] = useState(false);
+  const [error, setError] = useState(void 0);
+  const isMcp = isMcpAppsAvailable();
+  const platform = isMcp ? "mcp-apps" : "apps-sdk";
+  useEffect(() => {
+    const adaptor = getAdaptor();
+    if (debug) {
+      console.log("[Pancake] Initializing on platform:", platform);
+    }
+    adaptor.ensureReady().then(() => {
+      if (debug) {
+        console.log("[Pancake] Initialization complete");
+      }
+      setIsReady(true);
+    }).catch((err) => {
+      if (debug) {
+        console.error("[Pancake] Initialization failed:", err);
+      }
+      setError(err);
+      onError?.(err);
+    });
+  }, [debug, onError, platform]);
+  const contextValue = {
+    isReady,
+    error,
+    platform
+  };
+  const shouldRender = isReady || immediate || !isMcp && !error;
+  return /* @__PURE__ */ jsx(PancakeContext.Provider, { value: contextValue, children: shouldRender ? children : fallback });
+}
+function usePancakeContext() {
+  const context = useContext(PancakeContext);
+  if (!context) {
+    throw new Error("usePancakeContext must be used within a PancakeProvider");
+  }
+  return context;
+}
+
+// src/unified/debug.ts
+var DEBUG = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+var IS_TEST = typeof process !== "undefined" && process.env?.NODE_ENV === "test";
+var IS_STORYBOOK = typeof window !== "undefined" && Boolean(window.__STORYBOOK_CLIENT_API__);
+function debugLog(message, data2) {
+  if (DEBUG) {
+    if (data2 !== void 0) {
+      console.log(`[Pancake Debug] ${message}`, data2);
+    } else {
+      console.log(`[Pancake Debug] ${message}`);
+    }
+  }
+}
+function debugWarn(message, data2) {
+  if (DEBUG) {
+    if (data2 !== void 0) {
+      console.warn(`[Pancake Debug] ${message}`, data2);
+    } else {
+      console.warn(`[Pancake Debug] ${message}`);
+    }
+  }
+}
+function debugAssert(condition, message) {
+  if (DEBUG && !condition) {
+    console.error(`[Pancake Assert] ${message}`);
+  }
+}
+function debugTime(label, fn) {
+  if (DEBUG) {
+    console.time(`[Pancake] ${label}`);
+    const result = fn();
+    console.timeEnd(`[Pancake] ${label}`);
+    return result;
+  }
+  return fn();
+}
+async function debugTimeAsync(label, fn) {
+  if (DEBUG) {
+    console.time(`[Pancake] ${label}`);
+    const result = await fn();
+    console.timeEnd(`[Pancake] ${label}`);
+    return result;
+  }
+  return fn();
+}
+
+// src/index.ts
+function initPancake() {
+  const pancake = {
+    platform: getPlatform(),
+    adaptor: getAdaptor(),
+    appsSdk: apps_sdk_exports,
+    mcpApps: mcp_apps_exports,
+    unified: unified_exports
+  };
+  if (typeof window !== "undefined") {
+    window.pancake = pancake;
+  }
+  return pancake;
+}
+if (typeof window !== "undefined") {
+  setTimeout(() => {
+    if (!window.pancake) {
+      initPancake();
+    }
+  }, 0);
+}
+
+export { DEBUG, IS_STORYBOOK, IS_TEST, PancakeProvider, debugAssert, debugLog, debugTime, debugTimeAsync, debugWarn, initPancake, useAction, useCallTool, useContainerSize, useData, useDeviceType, useDisplayMode, useDisplayModeControl, useHostEnvironment, useInputCapabilities, useIsDarkMode, useIsFullscreen, useIsMobile, useLocale, useMaxHeight, usePancakeContext, usePlatform, useSafeArea, useTheme, useToolInput, useToolOutput, useToolResponseMetadata, useViewData, useViewParams, useViewState };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map