@sampleapp.ai/sdk 1.0.44 → 1.0.45

package/dist/components/sandbox/Sandbox.js

@@ -79,7 +79,7 @@ function SandboxInner({ configWithContent, apiKey, env, themeColor, theme, confi
     return (React.createElement(GuardianProvider, null,
         React.createElement(VmProvider, null,
             React.createElement("div", { className: "h-screen w-screen bg-white dark:bg-black" },
-                React.createElement(GuardianPlayground, { sandboxConfig: currentConfig, sections: sections, onSelect: selectOption, useCase: firstUseCase.id, framework: firstFramework, isFrame: isFrame, apiKey: apiKey, env: env, chatUid: currentConfig.chatUid, theme: theme, hasNetworkView: config === null || config === void 0 ? void 0 : config.hasNetworkView, stationaryPublishedUrl: config === null || config === void 0 ? void 0 : config.stationaryPublishedUrl })))));
+                React.createElement(GuardianPlayground, { sandboxConfig: currentConfig, sections: sections, onSelect: selectOption, useCase: firstUseCase.id, framework: firstFramework, isFrame: isFrame, apiKey: apiKey, env: env, chatUid: currentConfig.chatUid, theme: theme, hasNetworkView: config === null || config === void 0 ? void 0 : config.hasNetworkView })))));
 }
 /**
  * Sandbox component - simplified API for embedding sandboxes
@@ -108,15 +108,6 @@ function SandboxInner({ configWithContent, apiKey, env, themeColor, theme, confi
  * />
  * ```
  */
-/**
- *
- * Configurations for the config param
- * {
- *  isFrame: boolean;
- * }
- *
- *
- */
 export default function Sandbox({ apiKey, sandboxId, env, themeColor, theme = "dark", config }) {
     // Validate apiKey immediately
     if (!apiKey || apiKey.trim() === "") {

package/dist/components/sandbox/guardian/app-layout-no-sidebar.js

@@ -1,10 +1,10 @@
 import React from "react";
 import { cn } from "../../../lib/utils";
-export default function AppLayoutNoSidebar({ header, hasBodyPadding = true, children, textColorStyle, }) {
+export default function AppLayoutNoSidebar({ header, hasBodyPadding = true, children, textColorStyle }) {
     return (React.createElement("div", { className: "flex flex-col h-full" },
         header && (React.createElement("header", { className: "flex h-20 shrink-0 items-center gap-2 transition-[width,height] ease-linear group-has-[[data-collapsible=icon]]/sidebar-wrapper:h-12 w-full" },
             React.createElement("div", { className: "flex items-center w-full" }, header))),
-        React.createElement("div", { className: cn("flex flex-1 flex-col pt-0 min-h-0 pr-6 pb-6", hasBodyPadding && "gap-4 p-4", 
+        React.createElement("div", { className: cn("flex flex-1 flex-col pt-0 min-h-0 md:pr-6 pb-6", hasBodyPadding && "gap-4 p-4", 
             // Use CSS variable with Tailwind arbitrary value
             textColorStyle &&
                 "text-[var(--guardian-text-color)] dark:text-[var(--guardian-text-color-dark)]"), style: textColorStyle }, children)));

package/dist/components/sandbox/guardian/demo/guardian-demo.js

@@ -1,10 +1,14 @@
 "use client";
 import React, { useEffect, useState, useCallback } from "react";
+import { Panel, PanelGroup, PanelResizeHandle } from "react-resizable-panels";
 import ConsoleWithApp from "../ui/console-with-app";
 import { useGuardianContext } from "../context/guardian-context";
 import ConsoleWithGuide from "./left-view";
 import RightView from "../right-view/right-view";
-export default function GuardianDemo({ CustomConsole, GuideView, browserUrl, playgroundUid, useVm, codeZipFile, completeCodeZipFile, variant, themeColor, hasPreview, isFrame = false, isGuardian = false, gitUrl, isBrowserUrlReady = false, sandboxId, apiKey, sandboxError, hasNetworkView = false, }) {
+import RightTopDownView from "../right-view/right-top-down-view";
+import { cn } from "../../../../lib/utils";
+import { BookOpen, Monitor } from "lucide-react";
+export default function GuardianDemo({ CustomConsole, GuideView, browserUrl, playgroundUid, useVm, codeZipFile, completeCodeZipFile, variant, themeColor, hasPreview, isFrame = false, isGuardian = false, gitUrl, isBrowserUrlReady = false, sandboxId, apiKey, sandboxError, hasNetworkView = false }) {
     const { isBrowserMaximized } = useGuardianContext();
     const { setCurrentView } = useGuardianContext();
     const [reloadCounter, setReloadCounter] = useState(0);
@@ -19,6 +23,7 @@ export default function GuardianDemo({ CustomConsole, GuideView, browserUrl, pla
             setTimeout(() => setOverlayStage("hidden"), 3000);
         }
     }, []);
+    const [mobileTab, setMobileTab] = useState("guide");
     useEffect(() => {
         setCurrentView("preview");
     }, [setCurrentView]);
@@ -31,5 +36,48 @@ export default function GuardianDemo({ CustomConsole, GuideView, browserUrl, pla
         return (React.createElement("div", { className: "w-full h-full rounded-2xl overflow-hidden" },
             React.createElement(RightView, { reloadCounter: reloadCounter, overlayStage: overlayStage, browserUrl: browserUrl, useVm: useVm, codeZipFile: codeZipFile, hasPreview: hasPreview, variant: variant, themeColor: themeColor, completeCodeZipFile: completeCodeZipFile, isGuardian: isGuardian, isBrowserMaximized: true, isBrowserUrlReady: isBrowserUrlReady, isFrame: isFrame, sandboxId: sandboxId, apiKey: apiKey, sandboxError: sandboxError, hasNetworkView: hasNetworkView })));
     }
-    return (React.createElement(ConsoleWithApp, { containerClassName: "", console: React.createElement(ConsoleWithGuide, { CustomConsole: CustomConsole, GuideView: GuideView, playgroundUid: playgroundUid, onReloadPreview: handleReloadPreview, onStageChange: handleStageChange, codeZipFile: codeZipFile, themeColor: themeColor, browserUrl: browserUrl, gitUrl: gitUrl, sandboxId: sandboxId, apiKey: apiKey }), app: React.createElement(RightView, { reloadCounter: reloadCounter, overlayStage: overlayStage, browserUrl: browserUrl, useVm: useVm, codeZipFile: codeZipFile, hasPreview: hasPreview, variant: variant, themeColor: themeColor, completeCodeZipFile: completeCodeZipFile, isGuardian: isGuardian, isBrowserMaximized: isBrowserMaximized, isBrowserUrlReady: isBrowserUrlReady, isFrame: isFrame, sandboxId: sandboxId, apiKey: apiKey, sandboxError: sandboxError, hasNetworkView: hasNetworkView }) }));
+    const rightViewProps = {
+        reloadCounter,
+        overlayStage,
+        browserUrl,
+        useVm,
+        codeZipFile,
+        hasPreview,
+        variant,
+        themeColor,
+        completeCodeZipFile,
+        isGuardian,
+        isBrowserMaximized,
+        isBrowserUrlReady: isBrowserUrlReady !== null && isBrowserUrlReady !== void 0 ? isBrowserUrlReady : false,
+        isFrame,
+        sandboxId,
+        apiKey,
+        sandboxError,
+        hasNetworkView
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "md:hidden h-full flex flex-col min-h-0" },
+            React.createElement("div", { className: "flex-1 min-h-0 overflow-hidden flex flex-col" }, mobileTab === "guide" ? (React.createElement(PanelGroup, { direction: "vertical", className: "flex-1 min-h-0" },
+                React.createElement(Panel, { defaultSize: 50, minSize: 25, maxSize: 75, order: 1 },
+                    React.createElement("div", { className: "h-full w-full overflow-y-auto overflow-x-hidden" },
+                        React.createElement(ConsoleWithGuide, { CustomConsole: CustomConsole, GuideView: GuideView, playgroundUid: playgroundUid, onReloadPreview: handleReloadPreview, onStageChange: handleStageChange, codeZipFile: codeZipFile, themeColor: themeColor, browserUrl: browserUrl, gitUrl: gitUrl, sandboxId: sandboxId, apiKey: apiKey }))),
+                React.createElement(PanelResizeHandle, { className: "h-2 relative group flex-shrink-0 bg-zinc-900 dark:bg-zinc-950" },
+                    React.createElement("div", { className: "absolute inset-x-0 top-1/2 -translate-y-1/2 h-1 -mt-0.5 group-active:bg-blue-400/30 transition-colors flex justify-center items-center" },
+                        React.createElement("div", { className: "h-full w-12 rounded-full bg-zinc-600 dark:bg-zinc-500" }))),
+                React.createElement(Panel, { defaultSize: 50, minSize: 25, maxSize: 75, order: 2 },
+                    React.createElement("div", { className: "h-full w-full min-h-0" },
+                        React.createElement(RightTopDownView, Object.assign({}, rightViewProps, { hasPreview: false, codeOnly: true })))))) : (React.createElement("div", { className: "flex-1 min-h-0" },
+                React.createElement(RightView, Object.assign({}, rightViewProps, { previewOnly: true }))))),
+            React.createElement("div", { className: "flex-shrink-0 border-t border-zinc-800 dark:border-zinc-700 bg-zinc-900/95 dark:bg-zinc-950/95 backdrop-blur-sm px-3 py-2 flex items-center justify-center gap-1" },
+                React.createElement("button", { type: "button", onClick: () => setMobileTab("guide"), className: cn("flex items-center gap-2 px-4 py-2 rounded-full text-sm font-medium transition-colors", mobileTab === "guide"
+                        ? "bg-zinc-700 dark:bg-zinc-600 text-white"
+                        : "text-zinc-500 hover:text-zinc-300") },
+                    React.createElement(BookOpen, { className: "w-4 h-4" }),
+                    "Guide"),
+                React.createElement("button", { type: "button", onClick: () => setMobileTab("preview"), className: cn("flex items-center gap-2 px-4 py-2 rounded-full text-sm font-medium transition-colors", mobileTab === "preview"
+                        ? "bg-zinc-700 dark:bg-zinc-600 text-white"
+                        : "text-zinc-500 hover:text-zinc-300") },
+                    React.createElement(Monitor, { className: "w-4 h-4" }),
+                    "Preview"))),
+        React.createElement(ConsoleWithApp, { containerClassName: "hidden md:block", console: React.createElement(ConsoleWithGuide, { CustomConsole: CustomConsole, GuideView: GuideView, playgroundUid: playgroundUid, onReloadPreview: handleReloadPreview, onStageChange: handleStageChange, codeZipFile: codeZipFile, themeColor: themeColor, browserUrl: browserUrl, gitUrl: gitUrl, sandboxId: sandboxId, apiKey: apiKey }), app: React.createElement(RightView, { reloadCounter: reloadCounter, overlayStage: overlayStage, browserUrl: browserUrl, useVm: useVm, codeZipFile: codeZipFile, hasPreview: hasPreview, variant: variant, themeColor: themeColor, completeCodeZipFile: completeCodeZipFile, isGuardian: isGuardian, isBrowserMaximized: isBrowserMaximized, isBrowserUrlReady: isBrowserUrlReady, isFrame: isFrame, sandboxId: sandboxId, apiKey: apiKey, sandboxError: sandboxError, hasNetworkView: hasNetworkView }) })));
 }

package/dist/components/sandbox/guardian/guardian-component.js

@@ -9,7 +9,7 @@ import { useFrameMessages } from "./hooks/use-frame-messages";
 import { useVmContext } from "./context/vm-context";
 import { cn } from "../../../lib/utils";
 export default function GuardianComponent({ sections, onSelect, currentFramework, currentUseCase, CustomConsole, GuideView, playgroundLogo, playgroundUid, browserUrl, useVm, sandboxUid, codeZipFile, completeCodeZipFile, variant, themeColor, hasPreview = true, isFrame = false, apiKey, env, chatUid, hideHeader = false, // Hardcoded to true by default, not exposed in Sandbox.tsx
-gitUrl, hasNetworkView = false, stationaryPublishedUrl }) {
+gitUrl, hasNetworkView = false }) {
     const { previewUrl, setPreviewUrl } = useGuardianContext();
     const { vmResolution } = useVmContext();
     const [sandboxError, setSandboxError] = React.useState(null);
@@ -28,20 +28,9 @@ gitUrl, hasNetworkView = false, stationaryPublishedUrl }) {
     useFrameMessages();
     // Track which main sandbox we've loaded to prevent duplicates
     const loadedSandboxRef = useRef("");
-    // Track initial URLs per use case for stationaryPublishedUrl feature
-    const initialUrlsByUseCaseRef = useRef(new Map());
     useEffect(() => {
         // Create a key for this sandbox load
         const sandboxKey = `${sandboxUid}-${browserUrl}-${useVm}`;
-        const useCaseKey = currentUseCase || "default";
-        // If stationaryPublishedUrl is enabled and we already have a URL for this use case,
-        // use the stored URL and skip loading a new one
-        if (stationaryPublishedUrl &&
-            initialUrlsByUseCaseRef.current.has(useCaseKey)) {
-            const storedUrl = initialUrlsByUseCaseRef.current.get(useCaseKey);
-            setPreviewUrl(storedUrl);
-            return;
-        }
         // Check if we've already initiated a load for this exact sandbox config
         if (loadedSandboxRef.current === sandboxKey) {
             return;
@@ -52,11 +41,6 @@ gitUrl, hasNetworkView = false, stationaryPublishedUrl }) {
             // Found cached URL for this exact combination, use it immediately
             setPreviewUrl(existingUrl);
             loadedSandboxRef.current = sandboxKey;
-            // Store as initial URL for this use case if stationaryPublishedUrl is enabled
-            if (stationaryPublishedUrl &&
-                !initialUrlsByUseCaseRef.current.has(useCaseKey)) {
-                initialUrlsByUseCaseRef.current.set(useCaseKey, existingUrl);
-            }
             return;
         }
         // If useVm is true, wait for resolution from context before loading
@@ -80,11 +64,6 @@ gitUrl, hasNetworkView = false, stationaryPublishedUrl }) {
             apiKey
         })
             .then((url) => {
-            // Store as initial URL for this use case if stationaryPublishedUrl is enabled
-            if (stationaryPublishedUrl &&
-                !initialUrlsByUseCaseRef.current.has(useCaseKey)) {
-                initialUrlsByUseCaseRef.current.set(useCaseKey, url);
-            }
             setPreviewUrl(url);
             setSandboxError(null); // Clear error on success
         })
@@ -97,15 +76,7 @@ gitUrl, hasNetworkView = false, stationaryPublishedUrl }) {
         });
         // Re-run when sandbox parameters change OR when resolution becomes available
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        sandboxUid,
-        browserUrl,
-        useVm,
-        vmResolution,
-        apiKey,
-        currentUseCase,
-        stationaryPublishedUrl
-    ]);
+    }, [sandboxUid, browserUrl, useVm, vmResolution, apiKey]);
     // If isFrame, just render GuardianDemo without the header/layout wrapper
     if (isFrame) {
         return (React.createElement("div", { className: "h-[100vh]" },

package/dist/components/sandbox/guardian/guardian-playground.js

@@ -12,7 +12,7 @@ import { buildGuardianConfig } from "./utils";
  * are now handled in Sandbox.tsx via the tree selector sync mechanism.
  * This component receives the already-resolved framework from the tree selector.
  */
-export default function GuardianPlayground({ sandboxConfig, sections, onSelect, useCase, framework, isFrame = false, apiKey, env, chatUid, theme = "dark", hasNetworkView = false, stationaryPublishedUrl }) {
+export default function GuardianPlayground({ sandboxConfig, sections, onSelect, useCase, framework, isFrame = false, apiKey, env, chatUid, theme = "dark", hasNetworkView = false }) {
     var _a;
     // Get frame params for iframeUrl override only
     const frameParams = useFrameParams();
@@ -40,5 +40,5 @@ export default function GuardianPlayground({ sandboxConfig, sections, onSelect,
                 "\"")));
     }
     return (React.createElement(GuardianStyleWrapper, { themeColor: frameworkConfig.themeColor, theme: theme },
-        React.createElement(GuardianComponent, { sections: sections, onSelect: onSelect, currentFramework: frameworkConfig.currentFramework, CustomConsole: frameworkConfig.CustomConsole, GuideView: frameworkConfig.GuideView, playgroundUid: frameworkConfig.playgroundUid, browserUrl: (_a = frameParams.iframeUrl) !== null && _a !== void 0 ? _a : frameworkConfig.browserUrl, useVm: frameworkConfig.useVm, playgroundLogo: frameworkConfig.playgroundLogo, sandboxUid: frameworkConfig.sandboxUid, name: frameworkConfig.name, description: frameworkConfig.description, codeZipFile: frameworkConfig.codeZipFile, completeCodeZipFile: frameworkConfig.completeCodeZipFile, variant: frameworkConfig.variant, themeColor: frameworkConfig.themeColor, hasPreview: frameworkConfig.hasPreview, currentUseCase: useCase, isFrame: isFrame, apiKey: apiKey, env: env, chatUid: chatUid, gitUrl: frameworkConfig.gitUrl, hideHeader: false, hasNetworkView: hasNetworkView, stationaryPublishedUrl: stationaryPublishedUrl })));
+        React.createElement(GuardianComponent, { sections: sections, onSelect: onSelect, currentFramework: frameworkConfig.currentFramework, CustomConsole: frameworkConfig.CustomConsole, GuideView: frameworkConfig.GuideView, playgroundUid: frameworkConfig.playgroundUid, browserUrl: (_a = frameParams.iframeUrl) !== null && _a !== void 0 ? _a : frameworkConfig.browserUrl, useVm: frameworkConfig.useVm, playgroundLogo: frameworkConfig.playgroundLogo, sandboxUid: frameworkConfig.sandboxUid, name: frameworkConfig.name, description: frameworkConfig.description, codeZipFile: frameworkConfig.codeZipFile, completeCodeZipFile: frameworkConfig.completeCodeZipFile, variant: frameworkConfig.variant, themeColor: frameworkConfig.themeColor, hasPreview: frameworkConfig.hasPreview, currentUseCase: useCase, isFrame: isFrame, apiKey: apiKey, env: env, chatUid: chatUid, gitUrl: frameworkConfig.gitUrl, hideHeader: false, hasNetworkView: hasNetworkView })));
 }

package/dist/components/sandbox/guardian/right-view/right-top-down-view.js

@@ -15,7 +15,7 @@ import { useFrameParams } from "../hooks/use-frame-params";
 import { cn } from "../../../../lib/utils";
 import { handleSandboxDownload } from "../utils";
 import NetworkRequestsView from "./right-top-down-view/network-requests-view";
-export default function RightView({ reloadCounter, overlayStage, browserUrl, useVm, codeZipFile, themeColor, completeCodeZipFile, hasPreview, isPreviewMinimized = false, isGuardian = false, isBrowserMaximized = false, isBrowserUrlReady = false, sandboxId, apiKey, sandboxError, hasNetworkView = false }) {
+export default function RightView({ reloadCounter, overlayStage, browserUrl, useVm, codeZipFile, themeColor, completeCodeZipFile, hasPreview, isPreviewMinimized = false, isGuardian = false, isBrowserMaximized = false, isBrowserUrlReady = false, sandboxId, apiKey, sandboxError, hasNetworkView = false, codeOnly = false }) {
     const { setFileTree, setGeneratedCode } = useGuardianContext();
     const { setVmResolution } = useVmContext();
     const frameParams = useFrameParams();
@@ -194,7 +194,7 @@ export default function RightView({ reloadCounter, overlayStage, browserUrl, use
     }
     return (React.createElement("div", { className: "h-full w-full flex flex-col" },
         React.createElement(PanelGroup, { direction: "vertical", className: "relative h-full" },
-            hasPreview && !isPreviewMinimized && (React.createElement(React.Fragment, null,
+            hasPreview && !isPreviewMinimized && !codeOnly && (React.createElement(React.Fragment, null,
                 React.createElement(Panel, { defaultSize: 68, minSize: 20, maxSize: 80, order: 1 },
                     React.createElement("div", { ref: previewContainerRef, className: "h-full w-full relative" }, showLoader ? (React.createElement("div", { className: "h-full w-full relative overflow-hidden" },
                         React.createElement(AiLoader, { text: "Booting up...", fullScreen: false, themeColor: effectiveThemeColor }))) : (React.createElement(Browser, { previewUrl: browserUrl || "", setPreviewUrl: () => { }, containerEndpoint: browserUrl, outerContainerClassName: "h-full w-full border", reloadSignal: reloadCounter, useVm: useVm, isGuardian: isGuardian, sandboxError: sandboxError }, overlayStage !== "hidden" && (React.createElement("div", { className: "absolute inset-0 z-20 flex items-center justify-center" },
@@ -213,7 +213,7 @@ export default function RightView({ reloadCounter, overlayStage, browserUrl, use
                 React.createElement(PanelResizeHandle, { className: "h-0 relative group flex-shrink-0" },
                     React.createElement("div", { className: "absolute inset-x-0 top-1/2 -translate-y-1/2 h-2 -mt-0.5 group-hover:bg-blue-400/20 transition-colors flex justify-center items-center" },
                         React.createElement("div", { className: "h-full w-px group-hover:bg-blue-400 transition-colors" }))))),
-            React.createElement(Panel, { defaultSize: hasPreview ? 32 : 100, minSize: 20, maxSize: hasPreview ? 80 : 100, order: 2 },
+            React.createElement(Panel, { defaultSize: codeOnly || !hasPreview ? 100 : 32, minSize: 20, maxSize: codeOnly || !hasPreview ? 100 : 80, order: 2 },
                 React.createElement("div", { className: "h-full w-full flex flex-col" },
                     hasNetworkView && (React.createElement("div", { className: "flex items-center justify-between border-b border-zinc-800 dark:border-zinc-700 bg-zinc-900 dark:bg-zinc-950 flex-shrink-0" },
                         React.createElement("div", { className: "flex" },
@@ -222,7 +222,7 @@ export default function RightView({ reloadCounter, overlayStage, browserUrl, use
                                     : "border-transparent text-zinc-500 hover:text-zinc-300"), style: activeTab === "network"
                                     ? {
                                         borderColor: effectiveThemeColor,
-                                        color: effectiveThemeColor,
+                                        color: effectiveThemeColor
                                     }
                                     : undefined },
                                 React.createElement(Globe, { className: "w-3.5 h-3.5" }),
@@ -233,7 +233,7 @@ export default function RightView({ reloadCounter, overlayStage, browserUrl, use
                                     : "border-transparent text-zinc-500 hover:text-zinc-300"), style: activeTab === "code"
                                     ? {
                                         borderColor: effectiveThemeColor,
-                                        color: effectiveThemeColor,
+                                        color: effectiveThemeColor
                                     }
                                     : undefined },
                                 React.createElement(Code2, { className: "w-3.5 h-3.5" }),

package/dist/components/sandbox/guardian/right-view/right-view.js

@@ -3,7 +3,7 @@ import React, { useState, useEffect } from "react";
 import RightPanelView from "./right-panel-view";
 import RightTopDownView from "./right-top-down-view";
 import PreviewControlBar from "./preview-control-bar";
-export default function RightView({ reloadCounter, overlayStage, browserUrl, useVm, codeZipFile, completeCodeZipFile, variant = "top-down", themeColor, hasPreview, isGuardian = false, isBrowserMaximized = false, isBrowserUrlReady = false, isFrame = false, sandboxId, apiKey, sandboxError, hasNetworkView = false, }) {
+export default function RightView({ reloadCounter, overlayStage, browserUrl, useVm, codeZipFile, completeCodeZipFile, variant = "top-down", themeColor, hasPreview, isGuardian = false, isBrowserMaximized = false, isBrowserUrlReady = false, isFrame = false, sandboxId, apiKey, sandboxError, hasNetworkView = false, previewOnly = false, }) {
     const [isPreviewMinimized, setIsPreviewMinimized] = useState(false);
     const [reloadCounterState, setReloadCounterState] = useState(reloadCounter);
     // Sync with external reloadCounter changes
@@ -18,9 +18,9 @@ export default function RightView({ reloadCounter, overlayStage, browserUrl, use
     }
     else if (variant === "top-down") {
         return (React.createElement("div", { className: "h-full w-full flex flex-col" },
-            hasPreview && (React.createElement(PreviewControlBar, { isMinimized: isPreviewMinimized, onToggle: () => setIsPreviewMinimized(!isPreviewMinimized), onRefresh: handleRefresh, themeColor: themeColor, externalUrl: browserUrl, isFrame: isFrame })),
+            hasPreview && !previewOnly && (React.createElement(PreviewControlBar, { isMinimized: isPreviewMinimized, onToggle: () => setIsPreviewMinimized(!isPreviewMinimized), onRefresh: handleRefresh, themeColor: themeColor, externalUrl: browserUrl, isFrame: isFrame })),
             React.createElement("div", { className: "flex-1 min-h-0" },
-                React.createElement(RightTopDownView, { reloadCounter: reloadCounterState, overlayStage: overlayStage, browserUrl: browserUrl, useVm: useVm, codeZipFile: codeZipFile, themeColor: themeColor, completeCodeZipFile: completeCodeZipFile, hasPreview: hasPreview, isPreviewMinimized: isPreviewMinimized, isGuardian: isGuardian, isBrowserMaximized: isBrowserMaximized, isBrowserUrlReady: isBrowserUrlReady, sandboxId: sandboxId, apiKey: apiKey, sandboxError: sandboxError, hasNetworkView: hasNetworkView }))));
+                React.createElement(RightTopDownView, { reloadCounter: reloadCounterState, overlayStage: overlayStage, browserUrl: browserUrl, useVm: useVm, codeZipFile: codeZipFile, themeColor: themeColor, completeCodeZipFile: completeCodeZipFile, hasPreview: hasPreview, isPreviewMinimized: isPreviewMinimized, isGuardian: isGuardian, isBrowserMaximized: previewOnly || isBrowserMaximized, isBrowserUrlReady: isBrowserUrlReady, sandboxId: sandboxId, apiKey: apiKey, sandboxError: sandboxError, hasNetworkView: hasNetworkView }))));
     }
     else {
         return null;

package/dist/index.d.ts

@@ -397,7 +397,7 @@ export declare const getTheme: (themeName?: ThemeName) => ThemeColors;
 export declare function getUniqueFieldValues(allContent: SandboxContent[], field: keyof Pick<SandboxContent, "product" | "product_version" | "architecture" | "frontend" | "backend" | "framework">): string[];
 
 export declare function GuardianComponent({ sections, onSelect, currentFramework, currentUseCase, CustomConsole, GuideView, playgroundLogo, playgroundUid, browserUrl, useVm, sandboxUid, codeZipFile, completeCodeZipFile, variant, themeColor, hasPreview, isFrame, apiKey, env, chatUid, hideHeader, // Hardcoded to true by default, not exposed in Sandbox.tsx
-    gitUrl, hasNetworkView, stationaryPublishedUrl }: GuardianComponentProps): default_2.JSX.Element;
+    gitUrl, hasNetworkView }: GuardianComponentProps): default_2.JSX.Element;
 
 export declare interface GuardianComponentProps {
     name: string;
@@ -447,8 +447,6 @@ export declare interface GuardianComponentProps {
     gitUrl?: string;
     /** Whether to show the network requests view tab */
     hasNetworkView?: boolean;
-    /** When true, keeps the first browserUrl per use case (prevents URL changes when toggling options) */
-    stationaryPublishedUrl?: boolean;
 }
 
 /**
@@ -501,7 +499,7 @@ export declare type GuardianNestedConfig = Record<string, GuardianUseCaseConfig>
  * are now handled in Sandbox.tsx via the tree selector sync mechanism.
  * This component receives the already-resolved framework from the tree selector.
  */
-export declare function GuardianPlayground({ sandboxConfig, sections, onSelect, useCase, framework, isFrame, apiKey, env, chatUid, theme, hasNetworkView, stationaryPublishedUrl }: GuardianPlaygroundProps): default_2.JSX.Element;
+export declare function GuardianPlayground({ sandboxConfig, sections, onSelect, useCase, framework, isFrame, apiKey, env, chatUid, theme, hasNetworkView }: GuardianPlaygroundProps): default_2.JSX.Element;
 
 declare interface GuardianPlaygroundProps {
     /** Sandbox configuration */
@@ -526,8 +524,6 @@ declare interface GuardianPlaygroundProps {
     theme?: ThemeMode;
     /** Whether to show the network requests view tab */
     hasNetworkView?: boolean;
-    /** When true, keeps the first browserUrl per use case (prevents URL changes when toggling options) */
-    stationaryPublishedUrl?: boolean;
 }
 
 export declare function GuardianProvider({ children }: {
@@ -674,15 +670,6 @@ declare class SampleAppSDK {
  * />
  * ```
  */
-/**
- *
- * Configurations for the config param
- * {
- *  isFrame: boolean;
- * }
- *
- *
- */
 export declare function Sandbox({ apiKey, sandboxId, env, themeColor, theme, config }: SandboxProps): default_2.JSX.Element | null;
 
 /**
@@ -719,8 +706,6 @@ declare interface SandboxConfigOptions {
     isFrame?: boolean;
     /** Whether to show the network requests view tab. Defaults to false */
     hasNetworkView?: boolean;
-    /** Whether to keep the first browserUrl per use case (prevents URL changes when toggling options) */
-    stationaryPublishedUrl?: boolean;
 }
 
 /**